1\\n if self.shorten_cond_schedule:\\n self.make_cond_schedule()\\n\\n def instantiate_first_stage(self, config):\\n model = instantiate_from_config(config)\\n self.first_stage_model = model.eval()\\n self.first_stage_model.train = disabled_train\\n for param in self.first_stage_model.parameters():\\n param.requires_grad = False\\n\\n def instantiate_cond_stage(self, config):\\n if not self.cond_stage_trainable:\\n if config == \\\"__is_first_stage__\\\":\\n print(\\\"Using first stage also as cond stage.\\\")\\n self.cond_stage_model = self.first_stage_model\\n elif config == \\\"__is_unconditional__\\\":\\n print(f\\\"Training {self.__class__.__name__} as an unconditional model.\\\")\\n self.cond_stage_model = None\\n # self.be_unconditional = True\\n else:\\n model = instantiate_from_config(config)\\n self.cond_stage_model = model.eval()\\n self.cond_stage_model.train = disabled_train\\n for param in self.cond_stage_model.parameters():\\n param.requires_grad = False\\n else:\\n assert config != \\\"__is_first_stage__\\\"\\n assert config != \\\"__is_unconditional__\\\"\\n model = instantiate_from_config(config)\\n self.cond_stage_model = model\\n\\n def _get_denoise_row_from_list(\\n self, samples, desc=\\\"\\\", force_no_decoder_quantization=False\\n ):\\n denoise_row = []\\n for zd in tqdm(samples, desc=desc):\\n denoise_row.append(\\n self.decode_first_stage(\\n zd.to(self.device), force_not_quantize=force_no_decoder_quantization\\n )\\n )\\n n_imgs_per_row = len(denoise_row)\\n denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W\\n denoise_grid = rearrange(denoise_row, \\\"n b c h w -> b n c h w\\\")\\n denoise_grid = rearrange(denoise_grid, \\\"b n c h w -> (b n) c h w\\\")\\n denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)\\n return denoise_grid\\n\\n def get_first_stage_encoding(self, encoder_posterior):\\n if isinstance(encoder_posterior, DiagonalGaussianDistribution):\\n z = encoder_posterior.sample()\\n elif isinstance(encoder_posterior, torch.Tensor):\\n z = encoder_posterior\\n else:\\n raise NotImplementedError(\\n f\\\"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented\\\"\\n )\\n return self.scale_factor * z\\n\\n def get_learned_conditioning(self, c):\\n if self.cond_stage_forward is None:\\n if hasattr(self.cond_stage_model, \\\"encode\\\") and callable(\\n self.cond_stage_model.encode\\n ):\\n c = self.cond_stage_model.encode(c)\\n if isinstance(c, DiagonalGaussianDistribution):\\n c = c.mode()\\n else:\\n c = self.cond_stage_model(c)\\n else:\\n assert hasattr(self.cond_stage_model, self.cond_stage_forward)\\n c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)\\n return c\\n\\n def meshgrid(self, h, w):\\n y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)\\n x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)\\n\\n arr = torch.cat([y, x], dim=-1)\\n return arr\\n\\n def delta_border(self, h, w):\\n \\\"\\\"\\\"\\n :param h: height\\n :param w: width\\n :return: normalized distance to image border,\\n wtith min distance = 0 at border and max dist = 0.5 at image center\\n \\\"\\\"\\\"\\n lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)\\n arr = self.meshgrid(h, w) / lower_right_corner\\n dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]\\n dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]\\n edge_dist = torch.min(\\n torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1\\n )[0]\\n return edge_dist\\n\\n def get_weighting(self, h, w, Ly, Lx, device):\\n weighting = self.delta_border(h, w)\\n weighting = torch.clip(\\n weighting,\\n self.split_input_params[\\\"clip_min_weight\\\"],\\n self.split_input_params[\\\"clip_max_weight\\\"],\\n )\\n weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)\\n\\n if self.split_input_params[\\\"tie_braker\\\"]:\\n L_weighting = self.delta_border(Ly, Lx)\\n L_weighting = torch.clip(\\n L_weighting,\\n self.split_input_params[\\\"clip_min_tie_weight\\\"],\\n self.split_input_params[\\\"clip_max_tie_weight\\\"],\\n )\\n\\n L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)\\n weighting = weighting * L_weighting\\n return weighting\\n\\n def get_fold_unfold(\\n self, x, kernel_size, stride, uf=1, df=1\\n ): # todo load once not every time, shorten code\\n \\\"\\\"\\\"\\n :param x: img of size (bs, c, h, w)\\n :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])\\n \\\"\\\"\\\"\\n bs, nc, h, w = x.shape\\n\\n # number of crops in image\\n Ly = (h - kernel_size[0]) // stride[0] + 1\\n Lx = (w - kernel_size[1]) // stride[1] + 1\\n\\n if uf == 1 and df == 1:\\n fold_params = dict(\\n kernel_size=kernel_size, dilation=1, padding=0, stride=stride\\n )\\n unfold = torch.nn.Unfold(**fold_params)\\n\\n fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)\\n\\n weighting = self.get_weighting(\\n kernel_size[0], kernel_size[1], Ly, Lx, x.device\\n ).to(x.dtype)\\n normalization = fold(weighting).view(1, 1, h, w) # normalizes the overlap\\n weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))\\n\\n elif uf > 1 and df == 1:\\n fold_params = dict(\\n kernel_size=kernel_size, dilation=1, padding=0, stride=stride\\n )\\n unfold = torch.nn.Unfold(**fold_params)\\n\\n fold_params2 = dict(\\n kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),\\n dilation=1,\\n padding=0,\\n stride=(stride[0] * uf, stride[1] * uf),\\n )\\n fold = torch.nn.Fold(\\n output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2\\n )\\n\\n weighting = self.get_weighting(\\n kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device\\n ).to(x.dtype)\\n normalization = fold(weighting).view(\\n 1, 1, h * uf, w * uf\\n ) # normalizes the overlap\\n weighting = weighting.view(\\n (1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx)\\n )\\n\\n elif df > 1 and uf == 1:\\n fold_params = dict(\\n kernel_size=kernel_size, dilation=1, padding=0, stride=stride\\n )\\n unfold = torch.nn.Unfold(**fold_params)\\n\\n fold_params2 = dict(\\n kernel_size=(kernel_size[0] // df, kernel_size[0] // df),\\n dilation=1,\\n padding=0,\\n stride=(stride[0] // df, stride[1] // df),\\n )\\n fold = torch.nn.Fold(\\n output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2\\n )\\n\\n weighting = self.get_weighting(\\n kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device\\n ).to(x.dtype)\\n normalization = fold(weighting).view(\\n 1, 1, h // df, w // df\\n ) # normalizes the overlap\\n weighting = weighting.view(\\n (1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx)\\n )\\n\\n else:\\n raise NotImplementedError\\n\\n return fold, unfold, normalization, weighting\\n\\n @torch.no_grad()\\n def get_input(\\n self,\\n batch,\\n k,\\n return_first_stage_outputs=False,\\n force_c_encode=False,\\n cond_key=None,\\n return_original_cond=False,\\n bs=None,\\n uncond=0.05,\\n ):\\n x = super().get_input(batch, k)\\n T = batch[\\\"T\\\"].to(memory_format=torch.contiguous_format).float()\\n\\n if bs is not None:\\n x = x[:bs]\\n T = T[:bs].to(self.device)\\n\\n x = x.to(self.device)\\n encoder_posterior = self.encode_first_stage(x)\\n z = self.get_first_stage_encoding(encoder_posterior).detach()\\n cond_key = cond_key or self.cond_stage_key\\n xc = super().get_input(batch, cond_key).to(self.device)\\n if bs is not None:\\n xc = xc[:bs]\\n cond = {}\\n\\n # To support classifier-free guidance, randomly drop out only text conditioning 5%, only image conditioning 5%, and both 5%.\\n random = torch.rand(x.size(0), device=x.device)\\n prompt_mask = rearrange(random < 2 * uncond, \\\"n -> n 1 1\\\")\\n input_mask = 1 - rearrange(\\n (random >= uncond).float() * (random < 3 * uncond).float(), \\\"n -> n 1 1 1\\\"\\n )\\n null_prompt = self.get_learned_conditioning([\\\"\\\"])\\n\\n # z.shape: [8, 4, 64, 64]; c.shape: [8, 1, 768]\\n # print('=========== xc shape ===========', xc.shape)\\n with torch.enable_grad():\\n clip_emb = self.get_learned_conditioning(xc).detach()\\n null_prompt = self.get_learned_conditioning([\\\"\\\"]).detach()\\n cond[\\\"c_crossattn\\\"] = [\\n self.cc_projection(\\n torch.cat(\\n [\\n torch.where(prompt_mask, null_prompt, clip_emb),\\n T[:, None, :],\\n ],\\n dim=-1,\\n )\\n )\\n ]\\n cond[\\\"c_concat\\\"] = [\\n input_mask * self.encode_first_stage((xc.to(self.device))).mode().detach()\\n ]\\n out = [z, cond]\\n if return_first_stage_outputs:\\n xrec = self.decode_first_stage(z)\\n out.extend([x, xrec])\\n if return_original_cond:\\n out.append(xc)\\n return out\\n\\n # @torch.no_grad()\\n def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):\\n if predict_cids:\\n if z.dim() == 4:\\n z = torch.argmax(z.exp(), dim=1).long()\\n z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)\\n z = rearrange(z, \\\"b h w c -> b c h w\\\").contiguous()\\n\\n z = 1.0 / self.scale_factor * z\\n\\n if hasattr(self, \\\"split_input_params\\\"):\\n if self.split_input_params[\\\"patch_distributed_vq\\\"]:\\n ks = self.split_input_params[\\\"ks\\\"] # eg. (128, 128)\\n stride = self.split_input_params[\\\"stride\\\"] # eg. (64, 64)\\n uf = self.split_input_params[\\\"vqf\\\"]\\n bs, nc, h, w = z.shape\\n if ks[0] > h or ks[1] > w:\\n ks = (min(ks[0], h), min(ks[1], w))\\n print(\\\"reducing Kernel\\\")\\n\\n if stride[0] > h or stride[1] > w:\\n stride = (min(stride[0], h), min(stride[1], w))\\n print(\\\"reducing stride\\\")\\n\\n fold, unfold, normalization, weighting = self.get_fold_unfold(\\n z, ks, stride, uf=uf\\n )\\n\\n z = unfold(z) # (bn, nc * prod(**ks), L)\\n # 1. Reshape to img shape\\n z = z.view(\\n (z.shape[0], -1, ks[0], ks[1], z.shape[-1])\\n ) # (bn, nc, ks[0], ks[1], L )\\n\\n # 2. apply model loop over last dim\\n if isinstance(self.first_stage_model, VQModelInterface):\\n output_list = [\\n self.first_stage_model.decode(\\n z[:, :, :, :, i],\\n force_not_quantize=predict_cids or force_not_quantize,\\n )\\n for i in range(z.shape[-1])\\n ]\\n else:\\n output_list = [\\n self.first_stage_model.decode(z[:, :, :, :, i])\\n for i in range(z.shape[-1])\\n ]\\n\\n o = torch.stack(output_list, axis=-1) # # (bn, nc, ks[0], ks[1], L)\\n o = o * weighting\\n # Reverse 1. reshape to img shape\\n o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)\\n # stitch crops together\\n decoded = fold(o)\\n decoded = decoded / normalization # norm is shape (1, 1, h, w)\\n return decoded\\n else:\\n if isinstance(self.first_stage_model, VQModelInterface):\\n return self.first_stage_model.decode(\\n z, force_not_quantize=predict_cids or force_not_quantize\\n )\\n else:\\n return self.first_stage_model.decode(z)\\n\\n else:\\n if isinstance(self.first_stage_model, VQModelInterface):\\n return self.first_stage_model.decode(\\n z, force_not_quantize=predict_cids or force_not_quantize\\n )\\n else:\\n return self.first_stage_model.decode(z)\\n\\n @torch.no_grad()\\n def encode_first_stage(self, x):\\n if hasattr(self, \\\"split_input_params\\\"):\\n if self.split_input_params[\\\"patch_distributed_vq\\\"]:\\n ks = self.split_input_params[\\\"ks\\\"] # eg. (128, 128)\\n stride = self.split_input_params[\\\"stride\\\"] # eg. (64, 64)\\n df = self.split_input_params[\\\"vqf\\\"]\\n self.split_input_params[\\\"original_image_size\\\"] = x.shape[-2:]\\n bs, nc, h, w = x.shape\\n if ks[0] > h or ks[1] > w:\\n ks = (min(ks[0], h), min(ks[1], w))\\n print(\\\"reducing Kernel\\\")\\n\\n if stride[0] > h or stride[1] > w:\\n stride = (min(stride[0], h), min(stride[1], w))\\n print(\\\"reducing stride\\\")\\n\\n fold, unfold, normalization, weighting = self.get_fold_unfold(\\n x, ks, stride, df=df\\n )\\n z = unfold(x) # (bn, nc * prod(**ks), L)\\n # Reshape to img shape\\n z = z.view(\\n (z.shape[0], -1, ks[0], ks[1], z.shape[-1])\\n ) # (bn, nc, ks[0], ks[1], L )\\n\\n output_list = [\\n self.first_stage_model.encode(z[:, :, :, :, i])\\n for i in range(z.shape[-1])\\n ]\\n\\n o = torch.stack(output_list, axis=-1)\\n o = o * weighting\\n\\n # Reverse reshape to img shape\\n o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)\\n # stitch crops together\\n decoded = fold(o)\\n decoded = decoded / normalization\\n return decoded\\n\\n else:\\n return self.first_stage_model.encode(x)\\n else:\\n return self.first_stage_model.encode(x)\\n\\n def shared_step(self, batch, step_ratio=None, **kwargs):\\n x, c = self.get_input(batch, self.first_stage_key)\\n loss = self(x, c, step_ratio=step_ratio)\\n return loss\\n\\n def forward(self, x, c, step_ratio=None, *args, **kwargs):\\n if step_ratio is not None:\\n t = np.round((1 - step_ratio) * self.num_timesteps).clip(0, self.num_timesteps - 1)\\n t = torch.full((x.shape[0],), t, dtype=torch.long, device=self.device)\\n else:\\n t = torch.randint(\\n 0, self.num_timesteps, (x.shape[0],), device=self.device\\n ).long()\\n if self.model.conditioning_key is not None:\\n assert c is not None\\n # if self.cond_stage_trainable:\\n # c = self.get_learned_conditioning(c)\\n if self.shorten_cond_schedule: # TODO: drop this option\\n tc = self.cond_ids[t].to(self.device)\\n c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))\\n return self.p_losses(x, c, t, *args, **kwargs)\\n\\n def _rescale_annotations(self, bboxes, crop_coordinates): # TODO: move to dataset\\n def rescale_bbox(bbox):\\n x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2])\\n y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3])\\n w = min(bbox[2] / crop_coordinates[2], 1 - x0)\\n h = min(bbox[3] / crop_coordinates[3], 1 - y0)\\n return x0, y0, w, h\\n\\n return [rescale_bbox(b) for b in bboxes]\\n\\n def apply_model(self, x_noisy, t, cond, return_ids=False):\\n if isinstance(cond, dict):\\n # hybrid case, cond is exptected to be a dict\\n pass\\n else:\\n if not isinstance(cond, list):\\n cond = [cond]\\n key = (\\n \\\"c_concat\\\" if self.model.conditioning_key == \\\"concat\\\" else \\\"c_crossattn\\\"\\n )\\n cond = {key: cond}\\n\\n if hasattr(self, \\\"split_input_params\\\"):\\n assert len(cond) == 1 # todo can only deal with one conditioning atm\\n assert not return_ids\\n ks = self.split_input_params[\\\"ks\\\"] # eg. (128, 128)\\n stride = self.split_input_params[\\\"stride\\\"] # eg. (64, 64)\\n\\n h, w = x_noisy.shape[-2:]\\n\\n fold, unfold, normalization, weighting = self.get_fold_unfold(\\n x_noisy, ks, stride\\n )\\n\\n z = unfold(x_noisy) # (bn, nc * prod(**ks), L)\\n # Reshape to img shape\\n z = z.view(\\n (z.shape[0], -1, ks[0], ks[1], z.shape[-1])\\n ) # (bn, nc, ks[0], ks[1], L )\\n z_list = [z[:, :, :, :, i] for i in range(z.shape[-1])]\\n\\n if (\\n self.cond_stage_key in [\\\"image\\\", \\\"LR_image\\\", \\\"segmentation\\\", \\\"bbox_img\\\"]\\n and self.model.conditioning_key\\n ): # todo check for completeness\\n c_key = next(iter(cond.keys())) # get key\\n c = next(iter(cond.values())) # get value\\n assert len(c) == 1 # todo extend to list with more than one elem\\n c = c[0] # get element\\n\\n c = unfold(c)\\n c = c.view(\\n (c.shape[0], -1, ks[0], ks[1], c.shape[-1])\\n ) # (bn, nc, ks[0], ks[1], L )\\n\\n cond_list = [{c_key: [c[:, :, :, :, i]]} for i in range(c.shape[-1])]\\n\\n elif self.cond_stage_key == \\\"coordinates_bbox\\\":\\n assert (\\n \\\"original_image_size\\\" in self.split_input_params\\n ), \\\"BoudingBoxRescaling is missing original_image_size\\\"\\n\\n # assuming padding of unfold is always 0 and its dilation is always 1\\n n_patches_per_row = int((w - ks[0]) / stride[0] + 1)\\n full_img_h, full_img_w = self.split_input_params[\\\"original_image_size\\\"]\\n # as we are operating on latents, we need the factor from the original image size to the\\n # spatial latent size to properly rescale the crops for regenerating the bbox annotations\\n num_downs = self.first_stage_model.encoder.num_resolutions - 1\\n rescale_latent = 2 ** (num_downs)\\n\\n # get top left postions of patches as conforming for the bbbox tokenizer, therefore we\\n # need to rescale the tl patch coordinates to be in between (0,1)\\n tl_patch_coordinates = [\\n (\\n rescale_latent\\n * stride[0]\\n * (patch_nr % n_patches_per_row)\\n / full_img_w,\\n rescale_latent\\n * stride[1]\\n * (patch_nr // n_patches_per_row)\\n / full_img_h,\\n )\\n for patch_nr in range(z.shape[-1])\\n ]\\n\\n # patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w)\\n patch_limits = [\\n (\\n x_tl,\\n y_tl,\\n rescale_latent * ks[0] / full_img_w,\\n rescale_latent * ks[1] / full_img_h,\\n )\\n for x_tl, y_tl in tl_patch_coordinates\\n ]\\n # patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates]\\n\\n # tokenize crop coordinates for the bounding boxes of the respective patches\\n patch_limits_tknzd = [\\n torch.LongTensor(self.bbox_tokenizer._crop_encoder(bbox))[None].to(\\n self.device\\n )\\n for bbox in patch_limits\\n ] # list of length l with tensors of shape (1, 2)\\n # cut tknzd crop position from conditioning\\n assert isinstance(cond, dict), \\\"cond must be dict to be fed into model\\\"\\n cut_cond = cond[\\\"c_crossattn\\\"][0][..., :-2].to(self.device)\\n\\n adapted_cond = torch.stack(\\n [torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd]\\n )\\n adapted_cond = rearrange(adapted_cond, \\\"l b n -> (l b) n\\\")\\n adapted_cond = self.get_learned_conditioning(adapted_cond)\\n adapted_cond = rearrange(\\n adapted_cond, \\\"(l b) n d -> l b n d\\\", l=z.shape[-1]\\n )\\n\\n cond_list = [{\\\"c_crossattn\\\": [e]} for e in adapted_cond]\\n\\n else:\\n cond_list = [\\n cond for i in range(z.shape[-1])\\n ] # Todo make this more efficient\\n\\n # apply model by loop over crops\\n output_list = [\\n self.model(z_list[i], t, **cond_list[i]) for i in range(z.shape[-1])\\n ]\\n assert not isinstance(\\n output_list[0], tuple\\n ) # todo cant deal with multiple model outputs check this never happens\\n\\n o = torch.stack(output_list, axis=-1)\\n o = o * weighting\\n # Reverse reshape to img shape\\n o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)\\n # stitch crops together\\n x_recon = fold(o) / normalization\\n\\n else:\\n x_recon = self.model(x_noisy, t, **cond)\\n\\n if isinstance(x_recon, tuple) and not return_ids:\\n return x_recon[0]\\n else:\\n return x_recon\\n\\n def _predict_eps_from_xstart(self, x_t, t, pred_xstart):\\n return (\\n extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t\\n - pred_xstart\\n ) / extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)\\n\\n def _prior_bpd(self, x_start):\\n \\\"\\\"\\\"\\n Get the prior KL term for the variational lower-bound, measured in\\n bits-per-dim.\\n This term can't be optimized, as it only depends on the encoder.\\n :param x_start: the [N x C x ...] tensor of inputs.\\n :return: a batch of [N] KL values (in bits), one per batch element.\\n \\\"\\\"\\\"\\n batch_size = x_start.shape[0]\\n t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)\\n qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)\\n kl_prior = normal_kl(\\n mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0\\n )\\n return mean_flat(kl_prior) / np.log(2.0)\\n\\n def p_losses(self, x_start, cond, t, noise=None):\\n noise = default(noise, lambda: torch.randn_like(x_start))\\n x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)\\n model_output = self.apply_model(x_noisy, t, cond)\\n\\n loss_dict = {}\\n prefix = \\\"train\\\" if self.training else \\\"val\\\"\\n\\n if self.parameterization == \\\"x0\\\":\\n target = x_start\\n elif self.parameterization == \\\"eps\\\":\\n target = noise\\n else:\\n raise NotImplementedError()\\n\\n loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])\\n loss_dict.update({f\\\"{prefix}/loss_simple\\\": loss_simple.mean()})\\n\\n if self.logvar.device != self.device:\\n self.logvar = self.logvar.to(self.device)\\n\\n logvar_t = self.logvar[t].to(self.device)\\n loss = loss_simple / torch.exp(logvar_t) + logvar_t\\n # loss = loss_simple / torch.exp(self.logvar) + self.logvar\\n if self.learn_logvar:\\n loss_dict.update({f\\\"{prefix}/loss_gamma\\\": loss.mean()})\\n loss_dict.update({\\\"logvar\\\": self.logvar.data.mean()})\\n\\n loss = self.l_simple_weight * loss.mean()\\n\\n loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))\\n loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()\\n loss_dict.update({f\\\"{prefix}/loss_vlb\\\": loss_vlb})\\n loss += self.original_elbo_weight * loss_vlb\\n loss_dict.update({f\\\"{prefix}/loss\\\": loss})\\n\\n return loss, loss_dict\\n\\n def p_mean_variance(\\n self,\\n x,\\n c,\\n t,\\n clip_denoised: bool,\\n return_codebook_ids=False,\\n quantize_denoised=False,\\n return_x0=False,\\n score_corrector=None,\\n corrector_kwargs=None,\\n ):\\n t_in = t\\n model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)\\n\\n if score_corrector is not None:\\n assert self.parameterization == \\\"eps\\\"\\n model_out = score_corrector.modify_score(\\n self, model_out, x, t, c, **corrector_kwargs\\n )\\n\\n if return_codebook_ids:\\n model_out, logits = model_out\\n\\n if self.parameterization == \\\"eps\\\":\\n x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)\\n elif self.parameterization == \\\"x0\\\":\\n x_recon = model_out\\n else:\\n raise NotImplementedError()\\n\\n if clip_denoised:\\n x_recon.clamp_(-1.0, 1.0)\\n if quantize_denoised:\\n x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)\\n model_mean, posterior_variance, posterior_log_variance = self.q_posterior(\\n x_start=x_recon, x_t=x, t=t\\n )\\n if return_codebook_ids:\\n return model_mean, posterior_variance, posterior_log_variance, logits\\n elif return_x0:\\n return model_mean, posterior_variance, posterior_log_variance, x_recon\\n else:\\n return model_mean, posterior_variance, posterior_log_variance\\n\\n @torch.no_grad()\\n def p_sample(\\n self,\\n x,\\n c,\\n t,\\n clip_denoised=False,\\n repeat_noise=False,\\n return_codebook_ids=False,\\n quantize_denoised=False,\\n return_x0=False,\\n temperature=1.0,\\n noise_dropout=0.0,\\n score_corrector=None,\\n corrector_kwargs=None,\\n ):\\n b, *_, device = *x.shape, x.device\\n outputs = self.p_mean_variance(\\n x=x,\\n c=c,\\n t=t,\\n clip_denoised=clip_denoised,\\n return_codebook_ids=return_codebook_ids,\\n quantize_denoised=quantize_denoised,\\n return_x0=return_x0,\\n score_corrector=score_corrector,\\n corrector_kwargs=corrector_kwargs,\\n )\\n if return_codebook_ids:\\n raise DeprecationWarning(\\\"Support dropped.\\\")\\n model_mean, _, model_log_variance, logits = outputs\\n elif return_x0:\\n model_mean, _, model_log_variance, x0 = outputs\\n else:\\n model_mean, _, model_log_variance = outputs\\n\\n noise = noise_like(x.shape, device, repeat_noise) * temperature\\n if noise_dropout > 0.0:\\n noise = torch.nn.functional.dropout(noise, p=noise_dropout)\\n # no noise when t == 0\\n nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))\\n\\n if return_codebook_ids:\\n return model_mean + nonzero_mask * (\\n 0.5 * model_log_variance\\n ).exp() * noise, logits.argmax(dim=1)\\n if return_x0:\\n return (\\n model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise,\\n x0,\\n )\\n else:\\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise\\n\\n @torch.no_grad()\\n def progressive_denoising(\\n self,\\n cond,\\n shape,\\n verbose=True,\\n callback=None,\\n quantize_denoised=False,\\n img_callback=None,\\n mask=None,\\n x0=None,\\n temperature=1.0,\\n noise_dropout=0.0,\\n score_corrector=None,\\n corrector_kwargs=None,\\n batch_size=None,\\n x_T=None,\\n start_T=None,\\n log_every_t=None,\\n ):\\n if not log_every_t:\\n log_every_t = self.log_every_t\\n timesteps = self.num_timesteps\\n if batch_size is not None:\\n b = batch_size if batch_size is not None else shape[0]\\n shape = [batch_size] + list(shape)\\n else:\\n b = batch_size = shape[0]\\n if x_T is None:\\n img = torch.randn(shape, device=self.device)\\n else:\\n img = x_T\\n intermediates = []\\n if cond is not None:\\n if isinstance(cond, dict):\\n cond = {\\n key: cond[key][:batch_size]\\n if not isinstance(cond[key], list)\\n else list(map(lambda x: x[:batch_size], cond[key]))\\n for key in cond\\n }\\n else:\\n cond = (\\n [c[:batch_size] for c in cond]\\n if isinstance(cond, list)\\n else cond[:batch_size]\\n )\\n\\n if start_T is not None:\\n timesteps = min(timesteps, start_T)\\n iterator = (\\n tqdm(\\n reversed(range(0, timesteps)),\\n desc=\\\"Progressive Generation\\\",\\n total=timesteps,\\n )\\n if verbose\\n else reversed(range(0, timesteps))\\n )\\n if type(temperature) == float:\\n temperature = [temperature] * timesteps\\n\\n for i in iterator:\\n ts = torch.full((b,), i, device=self.device, dtype=torch.long)\\n if self.shorten_cond_schedule:\\n assert self.model.conditioning_key != \\\"hybrid\\\"\\n tc = self.cond_ids[ts].to(cond.device)\\n cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))\\n\\n img, x0_partial = self.p_sample(\\n img,\\n cond,\\n ts,\\n clip_denoised=self.clip_denoised,\\n quantize_denoised=quantize_denoised,\\n return_x0=True,\\n temperature=temperature[i],\\n noise_dropout=noise_dropout,\\n score_corrector=score_corrector,\\n corrector_kwargs=corrector_kwargs,\\n )\\n if mask is not None:\\n assert x0 is not None\\n img_orig = self.q_sample(x0, ts)\\n img = img_orig * mask + (1.0 - mask) * img\\n\\n if i % log_every_t == 0 or i == timesteps - 1:\\n intermediates.append(x0_partial)\\n if callback:\\n callback(i)\\n if img_callback:\\n img_callback(img, i)\\n return img, intermediates\\n\\n @torch.no_grad()\\n def p_sample_loop(\\n self,\\n cond,\\n shape,\\n return_intermediates=False,\\n x_T=None,\\n verbose=True,\\n callback=None,\\n timesteps=None,\\n quantize_denoised=False,\\n mask=None,\\n x0=None,\\n img_callback=None,\\n start_T=None,\\n log_every_t=None,\\n ):\\n if not log_every_t:\\n log_every_t = self.log_every_t\\n device = self.betas.device\\n b = shape[0]\\n if x_T is None:\\n img = torch.randn(shape, device=device)\\n else:\\n img = x_T\\n\\n intermediates = [img]\\n if timesteps is None:\\n timesteps = self.num_timesteps\\n\\n if start_T is not None:\\n timesteps = min(timesteps, start_T)\\n iterator = (\\n tqdm(reversed(range(0, timesteps)), desc=\\\"Sampling t\\\", total=timesteps)\\n if verbose\\n else reversed(range(0, timesteps))\\n )\\n\\n if mask is not None:\\n assert x0 is not None\\n assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match\\n\\n for i in iterator:\\n ts = torch.full((b,), i, device=device, dtype=torch.long)\\n if self.shorten_cond_schedule:\\n assert self.model.conditioning_key != \\\"hybrid\\\"\\n tc = self.cond_ids[ts].to(cond.device)\\n cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))\\n\\n img = self.p_sample(\\n img,\\n cond,\\n ts,\\n clip_denoised=self.clip_denoised,\\n quantize_denoised=quantize_denoised,\\n )\\n if mask is not None:\\n img_orig = self.q_sample(x0, ts)\\n img = img_orig * mask + (1.0 - mask) * img\\n\\n if i % log_every_t == 0 or i == timesteps - 1:\\n intermediates.append(img)\\n if callback:\\n callback(i)\\n if img_callback:\\n img_callback(img, i)\\n\\n if return_intermediates:\\n return img, intermediates\\n return img\\n\\n @torch.no_grad()\\n def sample(\\n self,\\n cond,\\n batch_size=16,\\n return_intermediates=False,\\n x_T=None,\\n verbose=True,\\n timesteps=None,\\n quantize_denoised=False,\\n mask=None,\\n x0=None,\\n shape=None,\\n **kwargs,\\n ):\\n if shape is None:\\n shape = (batch_size, self.channels, self.image_size, self.image_size)\\n if cond is not None:\\n if isinstance(cond, dict):\\n cond = {\\n key: cond[key][:batch_size]\\n if not isinstance(cond[key], list)\\n else list(map(lambda x: x[:batch_size], cond[key]))\\n for key in cond\\n }\\n else:\\n cond = (\\n [c[:batch_size] for c in cond]\\n if isinstance(cond, list)\\n else cond[:batch_size]\\n )\\n return self.p_sample_loop(\\n cond,\\n shape,\\n return_intermediates=return_intermediates,\\n x_T=x_T,\\n verbose=verbose,\\n timesteps=timesteps,\\n quantize_denoised=quantize_denoised,\\n mask=mask,\\n x0=x0,\\n )\\n\\n @torch.no_grad()\\n def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):\\n if ddim:\\n ddim_sampler = DDIMSampler(self)\\n shape = (self.channels, self.image_size, self.image_size)\\n samples, intermediates = ddim_sampler.sample(\\n ddim_steps, batch_size, shape, cond, verbose=False, **kwargs\\n )\\n\\n else:\\n samples, intermediates = self.sample(\\n cond=cond, batch_size=batch_size, return_intermediates=True, **kwargs\\n )\\n\\n return samples, intermediates\\n\\n @torch.no_grad()\\n def get_unconditional_conditioning(\\n self, batch_size, null_label=None, image_size=512\\n ):\\n if null_label is not None:\\n xc = null_label\\n if isinstance(xc, ListConfig):\\n xc = list(xc)\\n if isinstance(xc, dict) or isinstance(xc, list):\\n c = self.get_learned_conditioning(xc)\\n else:\\n if hasattr(xc, \\\"to\\\"):\\n xc = xc.to(self.device)\\n c = self.get_learned_conditioning(xc)\\n else:\\n # todo: get null label from cond_stage_model\\n raise NotImplementedError()\\n c = repeat(c, \\\"1 ... -> b ...\\\", b=batch_size).to(self.device)\\n cond = {}\\n cond[\\\"c_crossattn\\\"] = [c]\\n cond[\\\"c_concat\\\"] = [\\n torch.zeros([batch_size, 4, image_size // 8, image_size // 8]).to(\\n self.device\\n )\\n ]\\n return cond\\n\\n @torch.no_grad()\\n def log_images(\\n self,\\n batch,\\n N=8,\\n n_row=4,\\n sample=True,\\n ddim_steps=200,\\n ddim_eta=1.0,\\n return_keys=None,\\n quantize_denoised=True,\\n inpaint=True,\\n plot_denoise_rows=False,\\n plot_progressive_rows=True,\\n plot_diffusion_rows=True,\\n unconditional_guidance_scale=1.0,\\n unconditional_guidance_label=None,\\n use_ema_scope=True,\\n **kwargs,\\n ):\\n ema_scope = self.ema_scope if use_ema_scope else nullcontext\\n use_ddim = ddim_steps is not None\\n\\n log = dict()\\n z, c, x, xrec, xc = self.get_input(\\n batch,\\n self.first_stage_key,\\n return_first_stage_outputs=True,\\n force_c_encode=True,\\n return_original_cond=True,\\n bs=N,\\n )\\n N = min(x.shape[0], N)\\n n_row = min(x.shape[0], n_row)\\n log[\\\"inputs\\\"] = x\\n log[\\\"reconstruction\\\"] = xrec\\n if self.model.conditioning_key is not None:\\n if hasattr(self.cond_stage_model, \\\"decode\\\"):\\n xc = self.cond_stage_model.decode(c)\\n log[\\\"conditioning\\\"] = xc\\n elif self.cond_stage_key in [\\\"caption\\\", \\\"txt\\\"]:\\n xc = log_txt_as_img(\\n (x.shape[2], x.shape[3]),\\n batch[self.cond_stage_key],\\n size=x.shape[2] // 25,\\n )\\n log[\\\"conditioning\\\"] = xc\\n elif self.cond_stage_key == \\\"class_label\\\":\\n xc = log_txt_as_img(\\n (x.shape[2], x.shape[3]),\\n batch[\\\"human_label\\\"],\\n size=x.shape[2] // 25,\\n )\\n log[\\\"conditioning\\\"] = xc\\n elif isimage(xc):\\n log[\\\"conditioning\\\"] = xc\\n if ismap(xc):\\n log[\\\"original_conditioning\\\"] = self.to_rgb(xc)\\n\\n if plot_diffusion_rows:\\n # get diffusion row\\n diffusion_row = list()\\n z_start = z[:n_row]\\n for t in range(self.num_timesteps):\\n if t % self.log_every_t == 0 or t == self.num_timesteps - 1:\\n t = repeat(torch.tensor([t]), \\\"1 -> b\\\", b=n_row)\\n t = t.to(self.device).long()\\n noise = torch.randn_like(z_start)\\n z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)\\n diffusion_row.append(self.decode_first_stage(z_noisy))\\n\\n diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W\\n diffusion_grid = rearrange(diffusion_row, \\\"n b c h w -> b n c h w\\\")\\n diffusion_grid = rearrange(diffusion_grid, \\\"b n c h w -> (b n) c h w\\\")\\n diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])\\n log[\\\"diffusion_row\\\"] = diffusion_grid\\n\\n if sample:\\n # get denoise row\\n with ema_scope(\\\"Sampling\\\"):\\n samples, z_denoise_row = self.sample_log(\\n cond=c,\\n batch_size=N,\\n ddim=use_ddim,\\n ddim_steps=ddim_steps,\\n eta=ddim_eta,\\n )\\n # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)\\n x_samples = self.decode_first_stage(samples)\\n log[\\\"samples\\\"] = x_samples\\n if plot_denoise_rows:\\n denoise_grid = self._get_denoise_row_from_list(z_denoise_row)\\n log[\\\"denoise_row\\\"] = denoise_grid\\n\\n if (\\n quantize_denoised\\n and not isinstance(self.first_stage_model, AutoencoderKL)\\n and not isinstance(self.first_stage_model, IdentityFirstStage)\\n ):\\n # also display when quantizing x0 while sampling\\n with ema_scope(\\\"Plotting Quantized Denoised\\\"):\\n samples, z_denoise_row = self.sample_log(\\n cond=c,\\n batch_size=N,\\n ddim=use_ddim,\\n ddim_steps=ddim_steps,\\n eta=ddim_eta,\\n quantize_denoised=True,\\n )\\n # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,\\n # quantize_denoised=True)\\n x_samples = self.decode_first_stage(samples.to(self.device))\\n log[\\\"samples_x0_quantized\\\"] = x_samples\\n\\n if unconditional_guidance_scale > 1.0:\\n uc = self.get_unconditional_conditioning(\\n N, unconditional_guidance_label, image_size=x.shape[-1]\\n )\\n # uc = torch.zeros_like(c)\\n with ema_scope(\\\"Sampling with classifier-free guidance\\\"):\\n samples_cfg, _ = self.sample_log(\\n cond=c,\\n batch_size=N,\\n ddim=use_ddim,\\n ddim_steps=ddim_steps,\\n eta=ddim_eta,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=uc,\\n )\\n x_samples_cfg = self.decode_first_stage(samples_cfg)\\n log[\\n f\\\"samples_cfg_scale_{unconditional_guidance_scale:.2f}\\\"\\n ] = x_samples_cfg\\n\\n if inpaint:\\n # make a simple center square\\n b, h, w = z.shape[0], z.shape[2], z.shape[3]\\n mask = torch.ones(N, h, w).to(self.device)\\n # zeros will be filled in\\n mask[:, h // 4 : 3 * h // 4, w // 4 : 3 * w // 4] = 0.0\\n mask = mask[:, None, ...]\\n with ema_scope(\\\"Plotting Inpaint\\\"):\\n samples, _ = self.sample_log(\\n cond=c,\\n batch_size=N,\\n ddim=use_ddim,\\n eta=ddim_eta,\\n ddim_steps=ddim_steps,\\n x0=z[:N],\\n mask=mask,\\n )\\n x_samples = self.decode_first_stage(samples.to(self.device))\\n log[\\\"samples_inpainting\\\"] = x_samples\\n log[\\\"mask\\\"] = mask\\n\\n # outpaint\\n mask = 1.0 - mask\\n with ema_scope(\\\"Plotting Outpaint\\\"):\\n samples, _ = self.sample_log(\\n cond=c,\\n batch_size=N,\\n ddim=use_ddim,\\n eta=ddim_eta,\\n ddim_steps=ddim_steps,\\n x0=z[:N],\\n mask=mask,\\n )\\n x_samples = self.decode_first_stage(samples.to(self.device))\\n log[\\\"samples_outpainting\\\"] = x_samples\\n\\n if plot_progressive_rows:\\n with ema_scope(\\\"Plotting Progressives\\\"):\\n img, progressives = self.progressive_denoising(\\n c,\\n shape=(self.channels, self.image_size, self.image_size),\\n batch_size=N,\\n )\\n prog_row = self._get_denoise_row_from_list(\\n progressives, desc=\\\"Progressive Generation\\\"\\n )\\n log[\\\"progressive_row\\\"] = prog_row\\n\\n if return_keys:\\n if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:\\n return log\\n else:\\n return {key: log[key] for key in return_keys}\\n return log\\n\\n def configure_optimizers(self):\\n lr = self.learning_rate\\n params = []\\n if self.unet_trainable == \\\"attn\\\":\\n print(\\\"Training only unet attention layers\\\")\\n for n, m in self.model.named_modules():\\n if isinstance(m, CrossAttention) and n.endswith(\\\"attn2\\\"):\\n params.extend(m.parameters())\\n if self.unet_trainable == \\\"conv_in\\\":\\n print(\\\"Training only unet input conv layers\\\")\\n params = list(self.model.diffusion_model.input_blocks[0][0].parameters())\\n elif self.unet_trainable is True or self.unet_trainable == \\\"all\\\":\\n print(\\\"Training the full unet\\\")\\n params = list(self.model.parameters())\\n else:\\n raise ValueError(\\n f\\\"Unrecognised setting for unet_trainable: {self.unet_trainable}\\\"\\n )\\n\\n if self.cond_stage_trainable:\\n print(f\\\"{self.__class__.__name__}: Also optimizing conditioner params!\\\")\\n params = params + list(self.cond_stage_model.parameters())\\n if self.learn_logvar:\\n print(\\\"Diffusion model optimizing logvar\\\")\\n params.append(self.logvar)\\n\\n if self.cc_projection is not None:\\n params = params + list(self.cc_projection.parameters())\\n print(\\\"========== optimizing for cc projection weight ==========\\\")\\n\\n opt = torch.optim.AdamW(\\n [\\n {\\\"params\\\": self.model.parameters(), \\\"lr\\\": lr},\\n {\\\"params\\\": self.cc_projection.parameters(), \\\"lr\\\": 10.0 * lr},\\n ],\\n lr=lr,\\n )\\n if self.use_scheduler:\\n assert \\\"target\\\" in self.scheduler_config\\n scheduler = instantiate_from_config(self.scheduler_config)\\n\\n print(\\\"Setting up LambdaLR scheduler...\\\")\\n scheduler = [\\n {\\n \\\"scheduler\\\": LambdaLR(opt, lr_lambda=scheduler.schedule),\\n \\\"interval\\\": \\\"step\\\",\\n \\\"frequency\\\": 1,\\n }\\n ]\\n return [opt], scheduler\\n return opt\\n\\n @torch.no_grad()\\n def to_rgb(self, x):\\n x = x.float()\\n if not hasattr(self, \\\"colorize\\\"):\\n self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)\\n x = nn.functional.conv2d(x, weight=self.colorize)\\n x = 2.0 * (x - x.min()) / (x.max() - x.min()) - 1.0\\n return x\"\n },\n {\n \"identifier\": \"load_model_from_config\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def load_model_from_config(config, ckpt, device, vram_O=False, verbose=False):\\n print(f\\\"[INFO] Loading model from {ckpt}\\\")\\n pl_sd = torch.load(ckpt, map_location=\\\"cpu\\\")\\n\\n if \\\"global_step\\\" in pl_sd and verbose:\\n print(f'[INFO] Global Step: {pl_sd[\\\"global_step\\\"]}')\\n\\n sd = pl_sd[\\\"state_dict\\\"]\\n\\n model = instantiate_from_config(config.model)\\n m, u = model.load_state_dict(sd, strict=False)\\n\\n if len(m) > 0 and verbose:\\n print(\\\"[INFO] Missing keys: \\\\n\\\", m)\\n if len(u) > 0 and verbose:\\n print(\\\"[INFO] Unexpected keys: \\\\n\\\", u)\\n\\n # manually load ema and delete it to save GPU memory\\n if model.use_ema:\\n if verbose:\\n print(\\\"[INFO] Loading EMA\\\")\\n model.model_ema.copy_to(model.model)\\n del model.model_ema\\n\\n if vram_O:\\n # we don't need decoder\\n del model.first_stage_model.decoder\\n\\n torch.cuda.empty_cache()\\n model.eval().to(device)\\n\\n return model\"\n },\n {\n \"identifier\": \"make_T\",\n \"path\": \"util/pose.py\",\n \"snippet\": \"def make_T(theta, azimuth, distance, in_deg=False):\\n if in_deg:\\n theta, azimuth = theta.deg2rad(), azimuth.deg2rad()\\n return torch.stack(\\n (\\n theta,\\n torch.sin(azimuth),\\n torch.cos(azimuth),\\n distance,\\n )\\n )\"\n },\n {\n \"identifier\": \"default\",\n \"path\": \"util/util.py\",\n \"snippet\": \"def default(val, d):\\n if exists(val):\\n return val\\n return d() if isfunction(d) else d\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import itertools\nimport torch\nimport torch.nn as nn\nfrom dataclasses import dataclass\nfrom diffusers import DDIMScheduler\nfrom einops import rearrange\nfrom omegaconf import OmegaConf\nfrom ldm.lora import (\n inject_trainable_lora_extended,\n monkeypatch_remove_lora,\n save_lora_weight,\n)\nfrom ldm.models.diffusion.ddpm import LatentDiffusion\nfrom ldm.util import load_model_from_config\nfrom util.pose import make_T\nfrom util.typing import *\nfrom util.util import default"},"token_num":{"kind":"number","value":15836,"string":"15,836"},"cropped_code":{"kind":"string","value":" self.configure()\n\n def configure(self) -> None:\n print(\"[INFO] Loading Zero123...\")\n\n self.pretrained_config = OmegaConf.load(self.config.pretrained_config)\n self.weights_dtype = torch.float32\n self.model: LatentDiffusion = load_model_from_config(\n self.pretrained_config,\n self.config.pretrained_model_name_or_path,\n device=self.device,\n vram_O=self.config.vram_O,\n )\n\n for p in self.model.parameters():\n p.requires_grad_(False)\n\n self.num_train_timesteps = self.pretrained_config.model.params.timesteps\n self.scheduler = DDIMScheduler(\n self.num_train_timesteps,\n self.pretrained_config.model.params.linear_start,\n self.pretrained_config.model.params.linear_end,\n beta_schedule=\"scaled_linear\",\n clip_sample=False,\n set_alpha_to_one=False,\n steps_offset=1,\n )\n\n self.num_train_timesteps = self.scheduler.config.num_train_timesteps\n self.set_min_max_steps(\n min_step_percent=self.config.min_step_percent,\n max_step_percent=self.config.max_step_percent,\n )\n\n print(\"[INFO] Loaded Zero123\")\n\n @torch.cuda.amp.autocast(enabled=False)\n def set_min_max_steps(\n self, min_step_percent: float = 0.02, max_step_percent: float = 0.98\n ):\n self.min_step = int(self.num_train_timesteps * min_step_percent)\n self.max_step = int(self.num_train_timesteps * max_step_percent)\n\n @torch.cuda.amp.autocast(enabled=False)\n @torch.no_grad()\n def get_image_embeds(\n self, image: Float[Tensor, \"B 3 256 256\"]\n ) -> Tuple[Float[Tensor, \"B 1 768\"], Float[Tensor, \"B 4 32 32\"]]:\n c_crossattn = self.model.get_learned_conditioning(image.to(self.weights_dtype))\n c_concat = self.model.encode_first_stage(image.to(self.weights_dtype)).mode()\n return c_crossattn, c_concat\n\n @torch.cuda.amp.autocast(enabled=False)\n def encode_image(\n self, image: Float[Tensor, \"B 3 256 256\"]\n ) -> Float[Tensor, \"B 4 32 32\"]:\n input_dtype = image.dtype\n latent = self.model.get_first_stage_encoding(\n self.model.encode_first_stage(image.to(self.weights_dtype))\n )\n return latent.to(input_dtype) # [B, 4, 32, 32] Latent space image\n\n @torch.cuda.amp.autocast(enabled=False)\n def decode_latent(\n self,\n latent: Float[Tensor, \"B 4 H W\"],\n ) -> Float[Tensor, \"B 3 512 512\"]:\n input_dtype = latent.dtype\n image = self.model.decode_first_stage(latent)\n image = (image * 0.5 + 0.5).clamp(0, 1)\n return image.to(input_dtype)\n\n @staticmethod\n @torch.no_grad()\n def make_cond(cond):\n \"\"\"Add zeros to the beginning of cond\"\"\"\n return {k: [torch.cat([torch.zeros_like(v), v])] for k, v in cond.items()}\n\n @torch.cuda.amp.autocast(enabled=False)\n @torch.no_grad()\n def clip_camera_projection(\n self,\n theta: Float[Tensor, \"B\"],\n azimuth: Float[Tensor, \"B\"],\n distance: Float[Tensor, \"B\"],\n c_crossattn: Float[Tensor, \"B 1 768\"],\n in_deg: bool = False,\n ):\n T = make_T(theta, azimuth, distance, in_deg=in_deg).T[:, None, :]\n clip_emb = self.model.cc_projection(torch.cat([c_crossattn, T], dim=-1))\n return clip_emb\n\n def inject_lora(\n self,\n ckpt_fp: str = None,\n rank: int = 12,\n target_replace_module: List[str] = [\"CrossAttention\", \"GEGLU\"],\n eval: bool = False,\n ):\n print(\n f\"[INFO] Injecting LoRA from \"\n + (str(ckpt_fp) if ckpt_fp is not None else \"scratch\"),\n )\n\n lora_params, _ = inject_trainable_lora_extended(\n self.model.model,\n target_replace_module=set(target_replace_module),\n r=rank,\n loras=ckpt_fp,\n eval=eval,\n )\n if not eval:\n self.require_grad_params += itertools.chain(*lora_params)\n return self\n\n def save_lora(\n self,\n ckpt_fp: str,\n target_replace_module: List[str] = [\"CrossAttention\", \"GEGLU\"],\n ):\n"},"all_code":{"kind":"string","value":"\n\n\n\nclass Zero123(nn.Module):\n @dataclass\n class Config:\n pretrained_model_name_or_path: str = \"ldm/ckpt/zero123-xl.ckpt\"\n pretrained_config: str = \"ldm/ckpt/sd-objaverse-finetune-c_concat-256.yaml\"\n vram_O: bool = False\n\n min_step_percent: float = 0.02\n max_step_percent: float = 0.98\n\n config: Config\n\n def __init__(self, **kwargs) -> None:\n super().__init__()\n self.config = OmegaConf.structured(self.Config(**kwargs))\n self.device = \"cuda\"\n self.require_grad_params = []\n self.configure()\n\n def configure(self) -> None:\n print(\"[INFO] Loading Zero123...\")\n\n self.pretrained_config = OmegaConf.load(self.config.pretrained_config)\n self.weights_dtype = torch.float32\n self.model: LatentDiffusion = load_model_from_config(\n self.pretrained_config,\n self.config.pretrained_model_name_or_path,\n device=self.device,\n vram_O=self.config.vram_O,\n )\n\n for p in self.model.parameters():\n p.requires_grad_(False)\n\n self.num_train_timesteps = self.pretrained_config.model.params.timesteps\n self.scheduler = DDIMScheduler(\n self.num_train_timesteps,\n self.pretrained_config.model.params.linear_start,\n self.pretrained_config.model.params.linear_end,\n beta_schedule=\"scaled_linear\",\n clip_sample=False,\n set_alpha_to_one=False,\n steps_offset=1,\n )\n\n self.num_train_timesteps = self.scheduler.config.num_train_timesteps\n self.set_min_max_steps(\n min_step_percent=self.config.min_step_percent,\n max_step_percent=self.config.max_step_percent,\n )\n\n print(\"[INFO] Loaded Zero123\")\n\n @torch.cuda.amp.autocast(enabled=False)\n def set_min_max_steps(\n self, min_step_percent: float = 0.02, max_step_percent: float = 0.98\n ):\n self.min_step = int(self.num_train_timesteps * min_step_percent)\n self.max_step = int(self.num_train_timesteps * max_step_percent)\n\n @torch.cuda.amp.autocast(enabled=False)\n @torch.no_grad()\n def get_image_embeds(\n self, image: Float[Tensor, \"B 3 256 256\"]\n ) -> Tuple[Float[Tensor, \"B 1 768\"], Float[Tensor, \"B 4 32 32\"]]:\n c_crossattn = self.model.get_learned_conditioning(image.to(self.weights_dtype))\n c_concat = self.model.encode_first_stage(image.to(self.weights_dtype)).mode()\n return c_crossattn, c_concat\n\n @torch.cuda.amp.autocast(enabled=False)\n def encode_image(\n self, image: Float[Tensor, \"B 3 256 256\"]\n ) -> Float[Tensor, \"B 4 32 32\"]:\n input_dtype = image.dtype\n latent = self.model.get_first_stage_encoding(\n self.model.encode_first_stage(image.to(self.weights_dtype))\n )\n return latent.to(input_dtype) # [B, 4, 32, 32] Latent space image\n\n @torch.cuda.amp.autocast(enabled=False)\n def decode_latent(\n self,\n latent: Float[Tensor, \"B 4 H W\"],\n ) -> Float[Tensor, \"B 3 512 512\"]:\n input_dtype = latent.dtype\n image = self.model.decode_first_stage(latent)\n image = (image * 0.5 + 0.5).clamp(0, 1)\n return image.to(input_dtype)\n\n @staticmethod\n @torch.no_grad()\n def make_cond(cond):\n \"\"\"Add zeros to the beginning of cond\"\"\"\n return {k: [torch.cat([torch.zeros_like(v), v])] for k, v in cond.items()}\n\n @torch.cuda.amp.autocast(enabled=False)\n @torch.no_grad()\n def clip_camera_projection(\n self,\n theta: Float[Tensor, \"B\"],\n azimuth: Float[Tensor, \"B\"],\n distance: Float[Tensor, \"B\"],\n c_crossattn: Float[Tensor, \"B 1 768\"],\n in_deg: bool = False,\n ):\n T = make_T(theta, azimuth, distance, in_deg=in_deg).T[:, None, :]\n clip_emb = self.model.cc_projection(torch.cat([c_crossattn, T], dim=-1))\n return clip_emb\n\n def inject_lora(\n self,\n ckpt_fp: str = None,\n rank: int = 12,\n target_replace_module: List[str] = [\"CrossAttention\", \"GEGLU\"],\n eval: bool = False,\n ):\n print(\n f\"[INFO] Injecting LoRA from \"\n + (str(ckpt_fp) if ckpt_fp is not None else \"scratch\"),\n )\n\n lora_params, _ = inject_trainable_lora_extended(\n self.model.model,\n target_replace_module=set(target_replace_module),\n r=rank,\n loras=ckpt_fp,\n eval=eval,\n )\n if not eval:\n self.require_grad_params += itertools.chain(*lora_params)\n return self\n\n def save_lora(\n self,\n ckpt_fp: str,\n target_replace_module: List[str] = [\"CrossAttention\", \"GEGLU\"],\n ):"},"next_line":{"kind":"string","value":" save_lora_weight("},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-12-17 12:45:38+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5669,"cells":{"repo_name":{"kind":"string","value":"penghao-wu/vstar"},"file_path":{"kind":"string","value":"VisualSearch/utils/dataset.py"},"context":{"kind":"list like","value":[{"identifier":"conversation","path":"VisualSearch/model/llava/conversation.py","snippet":"class SeparatorStyle(Enum):\nclass Conversation:\n SINGLE = auto()\n TWO = auto()\n MPT = auto()\n PLAIN = auto()\n LLAMA_2 = auto()\n W, H = image.size\n H, W = longest_edge, shortest_edge\n H, W = shortest_edge, longest_edge\n W, H = image.size\n H, W = longest_edge, shortest_edge\n H, W = shortest_edge, longest_edge\n def get_prompt(self):\n def append_message(self, role, message):\n def get_images(self, return_pil=False):\n def expand2square(pil_img, background_color=(122, 116, 104)):\n def to_gradio_chatbot(self):\n def copy(self):\n def dict(self):"},{"identifier":"DEFAULT_IMAGE_TOKEN","path":"VisualSearch/model/llava/constants.py","snippet":"DEFAULT_IMAGE_TOKEN = \"<image>\""},{"identifier":"IGNORE_INDEX","path":"VisualSearch/model/llava/constants.py","snippet":"IGNORE_INDEX = -100"},{"identifier":"IMAGE_TOKEN_INDEX","path":"VisualSearch/model/llava/constants.py","snippet":"IMAGE_TOKEN_INDEX = -200"},{"identifier":"tokenizer_image_token","path":"VisualSearch/model/llava/mm_utils.py","snippet":"def tokenizer_image_token(\n prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None\n):\n prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split(\"<image>\")]\n\n def insert_separator(X, sep):\n return [ele for sublist in zip(X, [sep] * len(X)) for ele in sublist][:-1]\n\n input_ids = []\n offset = 0\n if (\n len(prompt_chunks) > 0\n and len(prompt_chunks[0]) > 0\n and prompt_chunks[0][0] == tokenizer.bos_token_id\n ):\n offset = 1\n input_ids.append(prompt_chunks[0][0])\n\n for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):\n input_ids.extend(x[offset:])\n\n if return_tensors is not None:\n if return_tensors == \"pt\":\n return torch.tensor(input_ids, dtype=torch.long)\n raise ValueError(f\"Unsupported tensor type: {return_tensors}\")\n return input_ids"},{"identifier":"get_mask_from_json","path":"VisualSearch/utils/data_processing.py","snippet":"def get_mask_from_json(json_path, img):\n try:\n with open(json_path, \"r\") as r:\n anno = json.loads(r.read())\n except:\n with open(json_path, \"r\", encoding=\"cp1252\") as r:\n anno = json.loads(r.read())\n\n inform = anno[\"shapes\"]\n comments = anno[\"text\"]\n is_sentence = anno[\"is_sentence\"]\n\n height, width = img.shape[:2]\n\n ### sort polies by area\n area_list = []\n valid_poly_list = []\n for i in inform:\n label_id = i[\"label\"]\n points = i[\"points\"]\n if \"flag\" == label_id.lower(): ## meaningless deprecated annotations\n continue\n\n tmp_mask = np.zeros((height, width), dtype=np.uint8)\n cv2.polylines(tmp_mask, np.array([points], dtype=np.int32), True, 1, 1)\n cv2.fillPoly(tmp_mask, np.array([points], dtype=np.int32), 1)\n tmp_area = tmp_mask.sum()\n\n area_list.append(tmp_area)\n valid_poly_list.append(i)\n\n ### ground-truth mask\n sort_index = np.argsort(area_list)[::-1].astype(np.int32)\n sort_index = list(sort_index)\n sort_inform = []\n for s_idx in sort_index:\n sort_inform.append(valid_poly_list[s_idx])\n\n mask = np.zeros((height, width), dtype=np.uint8)\n for i in sort_inform:\n label_id = i[\"label\"]\n points = i[\"points\"]\n\n if \"ignore\" in label_id.lower():\n label_value = 255 # ignored during evaluation\n else:\n label_value = 1 # target\n\n cv2.polylines(mask, np.array([points], dtype=np.int32), True, label_value, 1)\n cv2.fillPoly(mask, np.array([points], dtype=np.int32), label_value)\n\n return mask, comments, is_sentence"},{"identifier":"REFER","path":"VisualSearch/utils/refer.py","snippet":"class REFER:\n def __init__(self, data_root, dataset=\"refcoco\", splitBy=\"unc\"):\n # provide data_root folder which contains refclef, refcoco, refcoco+ and refcocog\n # also provide dataset name and splitBy information\n # e.g., dataset = 'refcoco', splitBy = 'unc'\n print(\"loading dataset %s into memory...\" % dataset)\n self.ROOT_DIR = osp.abspath(osp.dirname(__file__))\n self.DATA_DIR = osp.join(data_root, dataset)\n if dataset in [\"refcoco\", \"refcoco+\", \"refcocog\"]:\n self.IMAGE_DIR = osp.join(data_root, \"images/mscoco/images/train2014\")\n elif dataset == \"refclef\":\n self.IMAGE_DIR = osp.join(data_root, \"images/saiapr_tc-12\")\n else:\n print(\"No refer dataset is called [%s]\" % dataset)\n sys.exit()\n\n self.dataset = dataset\n\n # load refs from data/dataset/refs(dataset).json\n tic = time.time()\n\n ref_file = osp.join(self.DATA_DIR, \"refs(\" + splitBy + \").p\")\n print(\"ref_file: \", ref_file)\n self.data = {}\n self.data[\"dataset\"] = dataset\n self.data[\"refs\"] = pickle.load(open(ref_file, \"rb\"))\n\n # load annotations from data/dataset/instances.json\n instances_file = osp.join(self.DATA_DIR, \"instances.json\")\n instances = json.load(open(instances_file, \"rb\"))\n self.data[\"images\"] = instances[\"images\"]\n self.data[\"annotations\"] = instances[\"annotations\"]\n self.data[\"categories\"] = instances[\"categories\"]\n\n # create index\n self.createIndex()\n print(\"DONE (t=%.2fs)\" % (time.time() - tic))\n\n def createIndex(self):\n # create sets of mapping\n # 1) Refs: \t \t{ref_id: ref}\n # 2) Anns: \t \t{ann_id: ann}\n # 3) Imgs:\t\t \t{image_id: image}\n # 4) Cats: \t \t{category_id: category_name}\n # 5) Sents: \t{sent_id: sent}\n # 6) imgToRefs: \t{image_id: refs}\n # 7) imgToAnns: \t{image_id: anns}\n # 8) refToAnn: \t{ref_id: ann}\n # 9) annToRef: \t{ann_id: ref}\n # 10) catToRefs: \t{category_id: refs}\n # 11) sentToRef: \t{sent_id: ref}\n # 12) sentToTokens: {sent_id: tokens}\n print(\"creating index...\")\n # fetch info from instances\n Anns, Imgs, Cats, imgToAnns = {}, {}, {}, {}\n for ann in self.data[\"annotations\"]:\n Anns[ann[\"id\"]] = ann\n imgToAnns[ann[\"image_id\"]] = imgToAnns.get(ann[\"image_id\"], []) + [ann]\n for img in self.data[\"images\"]:\n Imgs[img[\"id\"]] = img\n for cat in self.data[\"categories\"]:\n Cats[cat[\"id\"]] = cat[\"name\"]\n\n # fetch info from refs\n Refs, imgToRefs, refToAnn, annToRef, catToRefs = {}, {}, {}, {}, {}\n Sents, sentToRef, sentToTokens = {}, {}, {}\n for ref in self.data[\"refs\"]:\n # ids\n ref_id = ref[\"ref_id\"]\n ann_id = ref[\"ann_id\"]\n category_id = ref[\"category_id\"]\n image_id = ref[\"image_id\"]\n\n # add mapping related to ref\n Refs[ref_id] = ref\n imgToRefs[image_id] = imgToRefs.get(image_id, []) + [ref]\n catToRefs[category_id] = catToRefs.get(category_id, []) + [ref]\n refToAnn[ref_id] = Anns[ann_id]\n annToRef[ann_id] = ref\n\n # add mapping of sent\n for sent in ref[\"sentences\"]:\n Sents[sent[\"sent_id\"]] = sent\n sentToRef[sent[\"sent_id\"]] = ref\n sentToTokens[sent[\"sent_id\"]] = sent[\"tokens\"]\n\n # create class members\n self.Refs = Refs\n self.Anns = Anns\n self.Imgs = Imgs\n self.Cats = Cats\n self.Sents = Sents\n self.imgToRefs = imgToRefs\n self.imgToAnns = imgToAnns\n self.refToAnn = refToAnn\n self.annToRef = annToRef\n self.catToRefs = catToRefs\n self.sentToRef = sentToRef\n self.sentToTokens = sentToTokens\n print(\"index created.\")\n\n def getRefIds(self, image_ids=[], cat_ids=[], ref_ids=[], split=\"\"):\n image_ids = image_ids if type(image_ids) == list else [image_ids]\n cat_ids = cat_ids if type(cat_ids) == list else [cat_ids]\n ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]\n\n if len(image_ids) == len(cat_ids) == len(ref_ids) == len(split) == 0:\n refs = self.data[\"refs\"]\n else:\n if not len(image_ids) == 0:\n refs = [self.imgToRefs[image_id] for image_id in image_ids]\n else:\n refs = self.data[\"refs\"]\n if not len(cat_ids) == 0:\n refs = [ref for ref in refs if ref[\"category_id\"] in cat_ids]\n if not len(ref_ids) == 0:\n refs = [ref for ref in refs if ref[\"ref_id\"] in ref_ids]\n if not len(split) == 0:\n if split in [\"testA\", \"testB\", \"testC\"]:\n refs = [\n ref for ref in refs if split[-1] in ref[\"split\"]\n ] # we also consider testAB, testBC, ...\n elif split in [\"testAB\", \"testBC\", \"testAC\"]:\n refs = [\n ref for ref in refs if ref[\"split\"] == split\n ] # rarely used I guess...\n elif split == \"test\":\n refs = [ref for ref in refs if \"test\" in ref[\"split\"]]\n elif split == \"train\" or split == \"val\":\n refs = [ref for ref in refs if ref[\"split\"] == split]\n else:\n print(\"No such split [%s]\" % split)\n sys.exit()\n ref_ids = [ref[\"ref_id\"] for ref in refs]\n return ref_ids\n\n def getAnnIds(self, image_ids=[], cat_ids=[], ref_ids=[]):\n image_ids = image_ids if type(image_ids) == list else [image_ids]\n cat_ids = cat_ids if type(cat_ids) == list else [cat_ids]\n ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]\n\n if len(image_ids) == len(cat_ids) == len(ref_ids) == 0:\n ann_ids = [ann[\"id\"] for ann in self.data[\"annotations\"]]\n else:\n if not len(image_ids) == 0:\n lists = [\n self.imgToAnns[image_id]\n for image_id in image_ids\n if image_id in self.imgToAnns\n ] # list of [anns]\n anns = list(itertools.chain.from_iterable(lists))\n else:\n anns = self.data[\"annotations\"]\n if not len(cat_ids) == 0:\n anns = [ann for ann in anns if ann[\"category_id\"] in cat_ids]\n ann_ids = [ann[\"id\"] for ann in anns]\n if not len(ref_ids) == 0:\n ids = set(ann_ids).intersection(\n set([self.Refs[ref_id][\"ann_id\"] for ref_id in ref_ids])\n )\n return ann_ids\n\n def getImgIds(self, ref_ids=[]):\n ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]\n\n if not len(ref_ids) == 0:\n image_ids = list(set([self.Refs[ref_id][\"image_id\"] for ref_id in ref_ids]))\n else:\n image_ids = self.Imgs.keys()\n return image_ids\n\n def getCatIds(self):\n return self.Cats.keys()\n\n def loadRefs(self, ref_ids=[]):\n if type(ref_ids) == list:\n return [self.Refs[ref_id] for ref_id in ref_ids]\n elif type(ref_ids) == int:\n return [self.Refs[ref_ids]]\n\n def loadAnns(self, ann_ids=[]):\n if type(ann_ids) == list:\n return [self.Anns[ann_id] for ann_id in ann_ids]\n elif type(ann_ids) == int or type(ann_ids) == unicode:\n return [self.Anns[ann_ids]]\n\n def loadImgs(self, image_ids=[]):\n if type(image_ids) == list:\n return [self.Imgs[image_id] for image_id in image_ids]\n elif type(image_ids) == int:\n return [self.Imgs[image_ids]]\n\n def loadCats(self, cat_ids=[]):\n if type(cat_ids) == list:\n return [self.Cats[cat_id] for cat_id in cat_ids]\n elif type(cat_ids) == int:\n return [self.Cats[cat_ids]]\n\n def getRefBox(self, ref_id):\n ref = self.Refs[ref_id]\n ann = self.refToAnn[ref_id]\n return ann[\"bbox\"] # [x, y, w, h]\n\n def showRef(self, ref, seg_box=\"seg\"):\n ax = plt.gca()\n # show image\n image = self.Imgs[ref[\"image_id\"]]\n I = io.imread(osp.join(self.IMAGE_DIR, image[\"file_name\"]))\n ax.imshow(I)\n # show refer expression\n for sid, sent in enumerate(ref[\"sentences\"]):\n print(\"%s. %s\" % (sid + 1, sent[\"sent\"]))\n # show segmentations\n if seg_box == \"seg\":\n ann_id = ref[\"ann_id\"]\n ann = self.Anns[ann_id]\n polygons = []\n color = []\n c = \"none\"\n if type(ann[\"segmentation\"][0]) == list:\n # polygon used for refcoco*\n for seg in ann[\"segmentation\"]:\n poly = np.array(seg).reshape((len(seg) / 2, 2))\n polygons.append(Polygon(poly, True, alpha=0.4))\n color.append(c)\n p = PatchCollection(\n polygons,\n facecolors=color,\n edgecolors=(1, 1, 0, 0),\n linewidths=3,\n alpha=1,\n )\n ax.add_collection(p) # thick yellow polygon\n p = PatchCollection(\n polygons,\n facecolors=color,\n edgecolors=(1, 0, 0, 0),\n linewidths=1,\n alpha=1,\n )\n ax.add_collection(p) # thin red polygon\n else:\n # mask used for refclef\n rle = ann[\"segmentation\"]\n m = mask.decode(rle)\n img = np.ones((m.shape[0], m.shape[1], 3))\n color_mask = np.array([2.0, 166.0, 101.0]) / 255\n for i in range(3):\n img[:, :, i] = color_mask[i]\n ax.imshow(np.dstack((img, m * 0.5)))\n # show bounding-box\n elif seg_box == \"box\":\n ann_id = ref[\"ann_id\"]\n ann = self.Anns[ann_id]\n bbox = self.getRefBox(ref[\"ref_id\"])\n box_plot = Rectangle(\n (bbox[0], bbox[1]),\n bbox[2],\n bbox[3],\n fill=False,\n edgecolor=\"green\",\n linewidth=3,\n )\n ax.add_patch(box_plot)\n\n def getMask(self, ref):\n # return mask, area and mask-center\n ann = self.refToAnn[ref[\"ref_id\"]]\n image = self.Imgs[ref[\"image_id\"]]\n if type(ann[\"segmentation\"][0]) == list: # polygon\n rle = mask.frPyObjects(ann[\"segmentation\"], image[\"height\"], image[\"width\"])\n else:\n rle = ann[\"segmentation\"]\n m = mask.decode(rle)\n m = np.sum(\n m, axis=2\n ) # sometimes there are multiple binary map (corresponding to multiple segs)\n m = m.astype(np.uint8) # convert to np.uint8\n # compute area\n area = sum(mask.area(rle)) # should be close to ann['area']\n return {\"mask\": m, \"area\": area}\n # # position\n # position_x = np.mean(np.where(m==1)[1]) # [1] means columns (matlab style) -> x (c style)\n # position_y = np.mean(np.where(m==1)[0]) # [0] means rows (matlab style) -> y (c style)\n # # mass position (if there were multiple regions, we use the largest one.)\n # label_m = label(m, connectivity=m.ndim)\n # regions = regionprops(label_m)\n # if len(regions) > 0:\n # \tlargest_id = np.argmax(np.array([props.filled_area for props in regions]))\n # \tlargest_props = regions[largest_id]\n # \tmass_y, mass_x = largest_props.centroid\n # else:\n # \tmass_x, mass_y = position_x, position_y\n # # if centroid is not in mask, we find the closest point to it from mask\n # if m[mass_y, mass_x] != 1:\n # \tprint('Finding closes mask point ...')\n # \tkernel = np.ones((10, 10),np.uint8)\n # \tme = cv2.erode(m, kernel, iterations = 1)\n # \tpoints = zip(np.where(me == 1)[0].tolist(), np.where(me == 1)[1].tolist()) # row, col style\n # \tpoints = np.array(points)\n # \tdist = np.sum((points - (mass_y, mass_x))**2, axis=1)\n # \tid = np.argsort(dist)[0]\n # \tmass_y, mass_x = points[id]\n # \t# return\n # return {'mask': m, 'area': area, 'position_x': position_x, 'position_y': position_y, 'mass_x': mass_x, 'mass_y': mass_y}\n # # show image and mask\n # I = io.imread(osp.join(self.IMAGE_DIR, image['file_name']))\n # plt.figure()\n # plt.imshow(I)\n # ax = plt.gca()\n # img = np.ones( (m.shape[0], m.shape[1], 3) )\n # color_mask = np.array([2.0,166.0,101.0])/255\n # for i in range(3):\n # img[:,:,i] = color_mask[i]\n # ax.imshow(np.dstack( (img, m*0.5) ))\n # plt.show()\n\n def showMask(self, ref):\n M = self.getMask(ref)\n msk = M[\"mask\"]\n ax = plt.gca()\n ax.imshow(msk)"},{"identifier":"ReferSegDataset","path":"VisualSearch/utils/refer_seg_dataset.py","snippet":"class ReferSegDataset(torch.utils.data.Dataset):\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n img_size = 1024\n ignore_label = 255\n\n def __init__(\n self,\n base_dir,\n tokenizer,\n vision_tower,\n samples_per_epoch=500 * 8 * 2 * 10,\n precision: str = \"fp32\",\n num_classes_per_sample: int = 3,\n exclude_val=False,\n refer_seg_data=\"refclef||refcoco||refcoco+||refcocog\",\n ):\n self.exclude_val = exclude_val\n self.samples_per_epoch = samples_per_epoch\n self.num_classes_per_sample = num_classes_per_sample\n\n self.base_dir = base_dir\n self.tokenizer = tokenizer\n self.precision = precision\n self.transform = OwlViTProcessor.from_pretrained(\"google/owlvit-base-patch16\")\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\n\n self.short_question_list = SHORT_QUESTION_LIST\n self.answer_list = ANSWER_LIST\n\n DATA_DIR = os.path.join(base_dir, \"refer_seg\")\n self.refer_seg_ds_list = refer_seg_data.split(\n \"||\"\n ) # ['refclef', 'refcoco', 'refcoco+', 'refcocog']\n self.refer_seg_data = {}\n for ds in self.refer_seg_ds_list:\n if ds == \"refcocog\":\n splitBy = \"umd\"\n else:\n splitBy = \"unc\"\n\n if ds == \"grefcoco\":\n refer_api = G_REFER(DATA_DIR, ds, splitBy)\n else:\n refer_api = REFER(DATA_DIR, ds, splitBy)\n ref_ids_train = refer_api.getRefIds(split=\"train\")\n images_ids_train = refer_api.getImgIds(ref_ids=ref_ids_train)\n refs_train = refer_api.loadRefs(ref_ids=ref_ids_train)\n\n refer_seg_ds = {}\n refer_seg_ds[\"images\"] = []\n loaded_images = refer_api.loadImgs(image_ids=images_ids_train)\n\n for item in loaded_images:\n item = item.copy()\n if ds == \"refclef\":\n item[\"file_name\"] = os.path.join(\n DATA_DIR, \"images/saiapr_tc-12\", item[\"file_name\"]\n )\n else:\n item[\"file_name\"] = os.path.join(\n DATA_DIR, \"images/mscoco/images/train2014\", item[\"file_name\"]\n )\n refer_seg_ds[\"images\"].append(item)\n refer_seg_ds[\"annotations\"] = refer_api.Anns # anns_train\n\n print(\n \"dataset {} (refs {}) (train split) has {} images and {} annotations.\".format(\n ds,\n splitBy,\n len(refer_seg_ds[\"images\"]),\n len(refer_seg_ds[\"annotations\"]),\n )\n )\n\n img2refs = {}\n for ref in refs_train:\n image_id = ref[\"image_id\"]\n img2refs[image_id] = img2refs.get(image_id, []) + [\n ref,\n ]\n refer_seg_ds[\"img2refs\"] = img2refs\n self.refer_seg_data[ds] = refer_seg_ds\n\n def __len__(self):\n return self.samples_per_epoch\n\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"Normalize pixel values and pad to a square input.\"\"\"\n # Normalize colors\n x = (x - self.pixel_mean) / self.pixel_std\n\n # Pad\n h, w = x.shape[-2:]\n padh = self.img_size - h\n padw = self.img_size - w\n x = F.pad(x, (0, padw, 0, padh))\n return x\n\n def __getitem__(self, idx):\n ds = random.randint(0, len(self.refer_seg_ds_list) - 1)\n ds = self.refer_seg_ds_list[ds]\n refer_seg_ds = self.refer_seg_data[ds]\n images = refer_seg_ds[\"images\"]\n annotations = refer_seg_ds[\"annotations\"]\n img2refs = refer_seg_ds[\"img2refs\"]\n idx = random.randint(0, len(images) - 1)\n image_info = images[idx]\n image_path = image_info[\"file_name\"]\n image_id = image_info[\"id\"]\n refs = img2refs[image_id]\n if len(refs) == 0:\n return self.__getitem__(0)\n\n sents = []\n ann_ids = []\n for ref in refs:\n for sent in ref[\"sentences\"]:\n text = sent[\"sent\"]\n sents.append(text)\n ann_ids.append(ref[\"ann_id\"])\n if len(sents) >= self.num_classes_per_sample:\n sampled_inds = np.random.choice(\n list(range(len(sents))), size=self.num_classes_per_sample, replace=False\n )\n else:\n sampled_inds = list(range(len(sents)))\n sampled_sents = np.vectorize(sents.__getitem__)(sampled_inds).tolist()\n # sampled_ann_ids = np.vectorize(ann_ids.__getitem__)(sampled_inds).tolist()\n sampled_ann_ids = [ann_ids[ind] for ind in sampled_inds]\n sampled_classes = sampled_sents\n image = cv2.imread(image_path)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n # preprocess image for clip\n image_clip = self.clip_image_processor.preprocess(\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\"pt\")[\"pixel_values\"][0]\n original_size = image.shape[:2]\n image = self.transform(images=image, return_tensors=\"pt\")['pixel_values'][0]\n resize = image.shape[:2]\n\n questions = []\n answers = []\n for text in sampled_classes:\n text = text.strip()\n assert len(text.split(\"||\")) == 1\n question_template = random.choice(self.short_question_list)\n questions.append(question_template.format(class_name=text.lower()))\n answers.append(random.choice(self.answer_list))\n\n conversations = []\n conv = conversation_lib.default_conversation.copy()\n\n i = 0\n while i < len(questions):\n conv.messages = []\n conv.append_message(conv.roles[0], questions[i])\n conv.append_message(conv.roles[1], answers[i])\n conversations.append(conv.get_prompt())\n i += 1\n\n flag = False\n masks = []\n bboxes_labels = []\n for ann_id in sampled_ann_ids:\n if isinstance(ann_id, list):\n assert False\n flag = True\n if -1 in ann_id:\n assert len(ann_id) == 1\n m = np.zeros((image_info[\"height\"], image_info[\"width\"])).astype(\n np.uint8\n )\n else:\n m_final = np.zeros(\n (image_info[\"height\"], image_info[\"width\"])\n ).astype(np.uint8)\n for ann_id_i in ann_id:\n ann = annotations[ann_id_i]\n\n if len(ann[\"segmentation\"]) == 0:\n m = np.zeros(\n (image_info[\"height\"], image_info[\"width\"])\n ).astype(np.uint8)\n else:\n if type(ann[\"segmentation\"][0]) == list: # polygon\n rle = mask.frPyObjects(\n ann[\"segmentation\"],\n image_info[\"height\"],\n image_info[\"width\"],\n )\n else:\n rle = ann[\"segmentation\"]\n for i in range(len(rle)):\n if not isinstance(rle[i][\"counts\"], bytes):\n rle[i][\"counts\"] = rle[i][\"counts\"].encode()\n m = mask.decode(rle)\n m = np.sum(\n m, axis=2\n ) # sometimes there are multiple binary map (corresponding to multiple segs)\n m = m.astype(np.uint8) # convert to np.uint8\n m_final = m_final | m\n m = m_final\n masks.append(m)\n continue\n \n ann = annotations[ann_id]\n cur_bboxes = [ann['bbox']]\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\n # xywh to x1y1x2y2\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\n cur_bboxes = cur_bboxes[keep]\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\n if len(cur_bboxes) == 0:\n return self.__getitem__(0)\n bboxes_labels.append(cur_bboxes)\n \n if len(ann[\"segmentation\"]) == 0:\n m = np.zeros((image_info[\"height\"], image_info[\"width\"])).astype(\n np.uint8\n )\n masks.append(m)\n continue\n\n if type(ann[\"segmentation\"][0]) == list: # polygon\n rle = mask.frPyObjects(\n ann[\"segmentation\"], image_info[\"height\"], image_info[\"width\"]\n )\n else:\n rle = ann[\"segmentation\"]\n for i in range(len(rle)):\n if not isinstance(rle[i][\"counts\"], bytes):\n rle[i][\"counts\"] = rle[i][\"counts\"].encode()\n m = mask.decode(rle)\n m = np.sum(\n m, axis=2\n ) # sometimes there are multiple binary map (corresponding to multiple segs)\n m = m.astype(np.uint8) # convert to np.uint8\n masks.append(m)\n bboxes_valid = [1]*len(bboxes_labels)\n masks_valid = [1]*len(bboxes_labels)\n masks = np.stack(masks, axis=0)\n\n\n masks = torch.from_numpy(masks)\n label = torch.ones(masks.shape[1], masks.shape[2]) * self.ignore_label\n\n return (\n image_path,\n image,\n image_clip,\n conversations,\n masks,\n label,\n bboxes_labels,\n bboxes_valid,\n masks_valid,\n resize,\n questions,\n sampled_classes,\n )"},{"identifier":"SegDetDataset","path":"VisualSearch/utils/general_segdet_dataset.py","snippet":"class SegDetDataset(torch.utils.data.Dataset):\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n img_size = 1024\n ignore_label = 255\n\n def __init__(\n self,\n base_dir,\n tokenizer,\n vision_tower,\n samples_per_epoch=500 * 8 * 2 * 10,\n precision: str = \"fp32\",\n num_classes_per_sample: int = 3,\n exclude_val=False,\n general_segdet_data=\"objects365||cocostuff||paco_lvis\",\n general_segdet_sample_rate=[2,1,1]\n ):\n self.exclude_val = exclude_val\n self.samples_per_epoch = samples_per_epoch\n self.num_classes_per_sample = num_classes_per_sample\n\n self.base_dir = base_dir\n self.tokenizer = tokenizer\n self.precision = precision\n self.transform = OwlViTProcessor.from_pretrained(\"google/owlvit-base-patch16\")\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\n\n self.short_question_list = SHORT_QUESTION_LIST\n self.answer_list = ANSWER_LIST\n\n self.data2list = {}\n self.data2classes = {}\n\n self.general_segdet_datas = general_segdet_data.split(\"||\")\n num_images = []\n for ds in self.general_segdet_datas:\n if ds == \"cocostuff\":\n classes, images, labels, bboxes = eval(\"init_{}\".format(ds))(base_dir)\n self.data2list[ds] = (images, labels, bboxes)\n elif ds == \"objects365\":\n classes, images, bboxes = eval(\"init_{}\".format(ds))(base_dir)\n self.data2list[ds] = (images, bboxes)\n else:\n classes, images, labels = eval(\"init_{}\".format(ds))(base_dir)\n self.data2list[ds] = (images, labels)\n self.data2classes[ds] = classes\n num_images.append(len(images))\n sample_rate = np.array(general_segdet_sample_rate)\n self.sample_rate = sample_rate / sample_rate.sum()\n\n if \"cocostuff\" in self.general_segdet_datas:\n self.cocostuff_class2index = {\n c: i for i, c in enumerate(self.data2classes[\"cocostuff\"])\n }\n\n def __len__(self):\n return self.samples_per_epoch\n\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"Normalize pixel values and pad to a square input.\"\"\"\n # Normalize colors\n x = (x - self.pixel_mean) / self.pixel_std\n\n # Pad\n h, w = x.shape[-2:]\n padh = self.img_size - h\n padw = self.img_size - w\n x = F.pad(x, (0, padw, 0, padh))\n return x\n\n def __getitem__(self, idx):\n ds = np.random.choice(list(range(len(self.general_segdet_datas))), p=self.sample_rate)\n ds = self.general_segdet_datas[ds]\n\n if ds in [\"paco_lvis\"]:\n class_map = self.data2classes[ds]\n img_ids, coco_api = self.data2list[ds]\n idx = random.randint(0, len(img_ids) - 1)\n img_id = img_ids[idx]\n image_info = coco_api.loadImgs([img_id])[0]\n file_name = image_info[\"file_name\"]\n if ds == \"pascal_part\":\n file_name = os.path.join(\n \"VOCdevkit\", \"VOC2010\", \"JPEGImages\", file_name\n )\n image_path = os.path.join(self.base_dir, \"vlpart\", ds, file_name)\n elif ds == \"paco_lvis\":\n image_path = os.path.join(self.base_dir, \"coco2017\", file_name)\n image = cv2.imread(image_path)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n # preprocess image for clip\n image_clip = self.clip_image_processor.preprocess(\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\"pt\"\n )[\"pixel_values\"][0]\n original_size = image.shape[:2]\n image = self.transform(images=image, return_tensors=\"pt\")['pixel_values'][0]\n resize = image.shape[:2]\n annIds = coco_api.getAnnIds(imgIds=image_info[\"id\"])\n anns = coco_api.loadAnns(annIds)\n anns_category2instances = dict()\n for ann in anns:\n category_id = ann['category_id']\n if category_id not in anns_category2instances:\n anns_category2instances[category_id] = []\n anns_category2instances[category_id].append(ann)\n if len(anns_category2instances) == 0:\n return self.__getitem__(0)\n if len(anns_category2instances) >= self.num_classes_per_sample:\n sampled_anns = np.random.choice(\n list(anns_category2instances.keys()), size=self.num_classes_per_sample, replace=False\n ).tolist()\n else:\n sampled_anns = list(anns_category2instances.keys())\n sampled_classes = []\n for category_id in sampled_anns:\n sampled_cls = class_map[category_id]\n if isinstance(sampled_cls, tuple):\n obj, part = sampled_cls\n if random.random() < 0.5:\n name = obj + \" \" + part\n else:\n name = \"the {} of the {}\".format(part, obj)\n else:\n name = sampled_cls\n name = name.replace('_', ' ')\n sampled_classes.append(name)\n\n elif ds in [\"cocostuff\"]:\n image, labels, bboxes_all = self.data2list[ds]\n idx = random.randint(0, len(image) - 1)\n image_path = image[idx]\n label_path = labels[idx]\n bboxes = bboxes_all[idx]\n label = Image.open(label_path)\n label = np.array(label)\n if ds == \"ade20k\":\n label[label == 0] = 255\n label -= 1\n label[label == 254] = 255\n elif ds == \"cocostuff\":\n for c, i in self.cocostuff_class2index.items():\n if \"-\" in c:\n label[label == i] = 255\n img = cv2.imread(image_path)\n image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n # preprocess image for clip\n image_clip = self.clip_image_processor.preprocess(\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\"pt\"\n )[\"pixel_values\"][0]\n original_size = image.shape[:2]\n image = self.transform(images=image, return_tensors=\"pt\")['pixel_values'][0]\n resize = image.shape[:2]\n unique_label = np.unique(label).tolist()\n if 255 in unique_label:\n unique_label.remove(255)\n if len(unique_label) == 0:\n return self.__getitem__(0)\n\n classes = [self.data2classes[ds][class_id] for class_id in unique_label]\n if len(classes) >= self.num_classes_per_sample:\n sampled_classes = np.random.choice(\n classes, size=self.num_classes_per_sample, replace=False\n ).tolist()\n else:\n sampled_classes = classes\n\n elif ds in ['objects365']:\n image, bboxes_all = self.data2list[ds]\n idx = random.randint(0, len(image) - 1)\n image_path = image[idx]\n bboxes = bboxes_all[idx]\n img = cv2.imread(image_path)\n image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n # preprocess image for clip\n image_clip = self.clip_image_processor.preprocess(\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\"pt\"\n )[\"pixel_values\"][0]\n original_size = image.shape[:2]\n image = self.transform(images=image, return_tensors=\"pt\")['pixel_values'][0]\n resize = image.shape[:2]\n unique_label = set()\n for bbox_info in bboxes:\n unique_label.add(bbox_info['category_id'])\n unique_label = list(unique_label)\n if len(unique_label) == 0:\n return self.__getitem__(0)\n\n classes = [self.data2classes[ds][class_id] for class_id in unique_label]\n if len(classes) >= self.num_classes_per_sample:\n sampled_classes = np.random.choice(\n classes, size=self.num_classes_per_sample, replace=False\n ).tolist()\n else:\n sampled_classes = classes\n\n\n questions = []\n answers = []\n class_ids = []\n bboxes_labels = []\n for i, sampled_cls in enumerate(sampled_classes):\n text = sampled_cls\n if ds in ['objects365']:\n text = random.sample(text.split('/'), 1)[0]\n \n assert len(text.split(\"||\")) == 1\n question_template = random.choice(self.short_question_list)\n questions.append(question_template.format(class_name=text.lower()))\n\n answers.append(random.choice(self.answer_list))\n\n if ds in [\"paco_lvis\", \"pascal_part\"]:\n category_id = sampled_anns[i]\n cur_bboxes = [instance['bbox'] for instance in anns_category2instances[category_id]]\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\n # xywh to x1y1x2y2\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\n cur_bboxes = cur_bboxes[keep]\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\n if len(cur_bboxes) == 0:\n return self.__getitem__(0)\n bboxes_labels.append(cur_bboxes)\n continue\n\n class_id = self.data2classes[ds].tolist().index(sampled_cls)\n class_ids.append(class_id)\n if ds in ['objects365']:\n cur_bboxes = [bbox['bbox'] for bbox in bboxes if bbox['category_id'] == class_id]\n else:\n cur_bboxes = [bbox['bbox'] for bbox in bboxes if bbox['category_id']-1 == class_id]\n cur_bboxes = cur_bboxes[:100]\n assert len(cur_bboxes) > 0\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\n # xywh to x1y1x2y2\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\n cur_bboxes = cur_bboxes[keep]\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\n if len(cur_bboxes) == 0:\n return self.__getitem__(0)\n bboxes_labels.append(cur_bboxes)\n bboxes_valid = [1]*len(bboxes_labels)\n masks_valid = [1]*len(bboxes_labels)\n conversations = []\n conv = conversation_lib.default_conversation.copy()\n\n i = 0\n while i < len(questions):\n conv.messages = []\n conv.append_message(conv.roles[0], questions[i])\n conv.append_message(conv.roles[1], answers[i])\n conversations.append(conv.get_prompt())\n i += 1\n\n if ds in [\"paco_lvis\", \"pascal_part\"]:\n masks = []\n for category_id in sampled_anns:\n try:\n cur_anns = anns_category2instances[category_id]\n cur_mask = None\n for ann in cur_anns:\n if cur_mask is None:\n cur_mask = coco_api.annToMask(ann)\n else:\n cur_mask = cur_mask | coco_api.annToMask(ann)\n assert cur_mask is not None\n masks.append(cur_mask)\n except Exception as e:\n print(e)\n return self.__getitem__(0)\n\n masks = np.stack(masks, axis=0)\n masks = torch.from_numpy(masks)\n label = torch.ones(masks.shape[1], masks.shape[2]) * self.ignore_label\n elif ds in ['objects365']:\n masks = torch.rand(len(bboxes_labels), *original_size)\n label = torch.ones(original_size) * self.ignore_label\n masks_valid = [0]*len(bboxes_labels)\n else:\n label = torch.from_numpy(label).long()\n masks = []\n for class_id in class_ids:\n masks.append(label == class_id)\n masks = torch.stack(masks, dim=0)\n return (\n image_path,\n image,\n image_clip,\n conversations,\n masks,\n label,\n bboxes_labels,\n bboxes_valid,\n masks_valid,\n resize,\n questions,\n sampled_classes,\n )"},{"identifier":"MixedGroundingDataset","path":"VisualSearch/utils/mixed_grounding_dataset.py","snippet":"class MixedGroundingDataset(torch.utils.data.Dataset):\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n img_size = 1024\n ignore_label = 255\n\n def __init__(\n self,\n base_dir,\n tokenizer,\n vision_tower,\n samples_per_epoch=500 * 8 * 2 * 10,\n precision: str = \"fp32\",\n num_classes_per_sample: int = 3,\n exclude_val=False,\n ):\n self.samples_per_epoch = samples_per_epoch\n self.num_classes_per_sample = num_classes_per_sample\n\n self.base_dir = base_dir\n self.tokenizer = tokenizer\n self.precision = precision\n self.transform = OwlViTProcessor.from_pretrained(\"google/owlvit-base-patch16\")\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\n\n self.short_question_list = SHORT_QUESTION_LIST\n self.answer_list = ANSWER_LIST\n\n with open(os.path.join(base_dir, 'MixedGrounding', 'goldG_train.json')) as f:\n self.images = json.load(f)\n\n def __len__(self):\n return self.samples_per_epoch\n\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"Normalize pixel values and pad to a square input.\"\"\"\n # Normalize colors\n x = (x - self.pixel_mean) / self.pixel_std\n\n # Pad\n h, w = x.shape[-2:]\n padh = self.img_size - h\n padw = self.img_size - w\n x = F.pad(x, (0, padw, 0, padh))\n return x\n\n def __getitem__(self, idx):\n\n idx = random.randint(0, len(self.images) - 1)\n image_info = self.images[idx]\n image_data_source = image_info['data_source']\n file_name = image_info[\"file_name\"]\n assert image_data_source in ['coco', 'vg', 'flickr']\n if image_data_source == 'coco':\n image_path = os.path.join(self.base_dir, 'coco2014/train2014', file_name)\n elif image_data_source == 'vg':\n image_path = os.path.join(self.base_dir, 'MixedGrounding/GQA/images', file_name)\n else:\n image_path = os.path.join(self.base_dir, 'MixedGrounding/flickr30k-images', file_name)\n caption = image_info['caption']\n instances = image_info['instances']\n if len(instances) == 0:\n return self.__getitem__(0)\n\n if len(instances) >= self.num_classes_per_sample:\n sampled_inds = np.random.choice(\n list(range(len(instances))), size=self.num_classes_per_sample, replace=False\n )\n else:\n sampled_inds = list(range(len(instances)))\n\n sampled_classes = sampled_inds\n \n image = cv2.imread(image_path)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n\n # preprocess image for clip\n image_clip = self.clip_image_processor.preprocess(\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\"pt\")[\"pixel_values\"][0]\n original_size = image.shape[:2]\n image = self.transform(images=image, return_tensors=\"pt\")['pixel_values'][0]\n resize = image.shape[:2]\n\n questions = []\n answers = []\n bboxes_labels = []\n for sample_ind in sampled_inds:\n text = []\n tokens_positive = instances[sample_ind]['tokens_positive']\n for token in tokens_positive:\n text.append(caption[token[0]:token[1]])\n text = \" \".join(text)\n text = text.strip()\n question_template = random.choice(self.short_question_list)\n questions.append(question_template.format(class_name=text.lower()))\n answers.append(random.choice(self.answer_list))\n\n cur_bboxes = [instances[sample_ind]['bbox']]\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\n # xywh to x1y1x2y2\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\n cur_bboxes = cur_bboxes[keep]\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\n if len(cur_bboxes) == 0:\n return self.__getitem__(0)\n bboxes_labels.append(cur_bboxes)\n\n conversations = []\n conv = conversation_lib.default_conversation.copy()\n\n i = 0\n while i < len(questions):\n conv.messages = []\n conv.append_message(conv.roles[0], questions[i])\n conv.append_message(conv.roles[1], answers[i])\n conversations.append(conv.get_prompt())\n i += 1\n \n bboxes_valid = [1]*len(bboxes_labels)\n masks_valid = [0]*len(bboxes_labels)\n masks = torch.rand(len(bboxes_labels), *original_size)\n label = torch.ones(original_size) * self.ignore_label\n\n return (\n image_path,\n image,\n image_clip,\n conversations,\n masks,\n label,\n bboxes_labels,\n bboxes_valid,\n masks_valid,\n resize,\n questions,\n sampled_classes,\n )"},{"identifier":"VQADataset","path":"VisualSearch/utils/vqa_dataset.py","snippet":"class VQADataset(torch.utils.data.Dataset):\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n img_size = 1024\n ignore_label = 255\n\n def __init__(\n self,\n base_image_dir,\n tokenizer,\n vision_tower,\n samples_per_epoch=500 * 8 * 2 * 10,\n precision: str = \"fp32\",\n num_classes_per_sample: int = 3,\n exclude_val=False,\n vqa_data=\"possible_locations_conv_86k||llava_instruct_150k\",\n vqa_sample_rate=[2,1],\n ):\n self.exclude_val = exclude_val\n self.samples_per_epoch = samples_per_epoch\n self.num_classes_per_sample = num_classes_per_sample\n\n self.base_image_dir = base_image_dir\n self.tokenizer = tokenizer\n self.precision = precision\n self.transform = OwlViTProcessor.from_pretrained(\"google/owlvit-base-patch16\")\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\n\n DATA_DIR = os.path.join(base_image_dir, \"vsm_vqa_data\")\n self.vqa_image_root = os.path.join(base_image_dir, \"coco2017/train2017\")\n vqa_datas = vqa_data.split(\"||\")\n self.vqa_datas = []\n for data in vqa_datas:\n with open(os.path.join(DATA_DIR, \"{}.json\".format(data))) as f:\n data = json.load(f)\n self.vqa_datas.append(data)\n sample_rate = np.array(vqa_sample_rate)\n self.sample_rate = sample_rate / sample_rate.sum()\n\n def __len__(self):\n return self.samples_per_epoch\n\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"Normalize pixel values and pad to a square input.\"\"\"\n # Normalize colors\n x = (x - self.pixel_mean) / self.pixel_std\n\n # Pad\n h, w = x.shape[-2:]\n padh = self.img_size - h\n padw = self.img_size - w\n x = F.pad(x, (0, padw, 0, padh))\n return x\n\n def __getitem__(self, idx):\n ds = np.random.choice(list(range(len(self.vqa_datas))), p=self.sample_rate)\n ds = self.vqa_datas[ds]\n idx = random.randint(0, len(ds) - 1)\n item = ds[idx]\n image_path = os.path.join(self.vqa_image_root, item[\"image\"])\n image = cv2.imread(image_path)\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n ori_size = image.shape[:2]\n image_clip = self.clip_image_processor.preprocess(\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\"pt\")[\"pixel_values\"][0]\n\n image = self.transform(images=image, return_tensors=\"pt\")['pixel_values'][0]\n resize = image.shape[:2]\n\n conv = conversation_lib.default_conversation.copy()\n source = item[\"conversations\"]\n source = preprocess_multimodal(\n copy.deepcopy(source),\n mm_use_im_start_end=conv.sep_style == conversation_lib.SeparatorStyle.TWO,\n )\n roles = {\"human\": conv.roles[0], \"gpt\": conv.roles[1]}\n conversations = []\n if roles[source[0][\"from\"]] != conv.roles[0]:\n # Skip the first one if it is not from human\n source = source[1:]\n conv.messages = []\n for j, sentence in enumerate(source):\n role = roles[sentence[\"from\"]]\n assert role == conv.roles[j % 2], f\"{j}\"\n conv.append_message(role, sentence[\"value\"])\n conversations.append(conv.get_prompt())\n\n questions = conversations\n sampled_classes = conversations\n\n masks = torch.rand(1, *ori_size)\n label = torch.ones(ori_size) * self.ignore_label\n bboxes_labels = [torch.tensor([[0.5,0.5,1.0,1.0]])]\n bboxes_valid = [0]\n masks_valid = [0]\n\n return (\n image_path,\n image,\n image_clip,\n conversations,\n masks,\n label,\n bboxes_labels,\n bboxes_valid,\n masks_valid,\n resize,\n questions,\n sampled_classes,\n )"},{"identifier":"DEFAULT_IM_END_TOKEN","path":"VisualSearch/utils/utils.py","snippet":"DEFAULT_IM_END_TOKEN = \"<im_end>\""},{"identifier":"DEFAULT_IM_START_TOKEN","path":"VisualSearch/utils/utils.py","snippet":"DEFAULT_IM_START_TOKEN = \"<im_start>\""},{"identifier":"DEFAULT_IMAGE_TOKEN","path":"VisualSearch/utils/utils.py","snippet":"DEFAULT_IMAGE_TOKEN = \"<image>\""},{"identifier":"box_xyxy_to_cxcywh","path":"VisualSearch/utils/utils.py","snippet":"def box_xyxy_to_cxcywh(x):\n x0, y0, x1, y1 = x.unbind(-1)\n b = [(x0 + x1) / 2, (y0 + y1) / 2,\n (x1 - x0), (y1 - y0)]\n return torch.stack(b, dim=-1)"},{"identifier":"expand2square","path":"VisualSearch/utils/utils.py","snippet":"def expand2square(pil_img, background_color):\n width, height = pil_img.size\n if width == height:\n return pil_img\n elif width > height:\n result = Image.new(pil_img.mode, (width, width), background_color)\n result.paste(pil_img, (0, 0))\n return result\n else:\n result = Image.new(pil_img.mode, (height, height), background_color)\n result.paste(pil_img, (0, 0))\n return result"}],"string":"[\n {\n \"identifier\": \"conversation\",\n \"path\": \"VisualSearch/model/llava/conversation.py\",\n \"snippet\": \"class SeparatorStyle(Enum):\\nclass Conversation:\\n SINGLE = auto()\\n TWO = auto()\\n MPT = auto()\\n PLAIN = auto()\\n LLAMA_2 = auto()\\n W, H = image.size\\n H, W = longest_edge, shortest_edge\\n H, W = shortest_edge, longest_edge\\n W, H = image.size\\n H, W = longest_edge, shortest_edge\\n H, W = shortest_edge, longest_edge\\n def get_prompt(self):\\n def append_message(self, role, message):\\n def get_images(self, return_pil=False):\\n def expand2square(pil_img, background_color=(122, 116, 104)):\\n def to_gradio_chatbot(self):\\n def copy(self):\\n def dict(self):\"\n },\n {\n \"identifier\": \"DEFAULT_IMAGE_TOKEN\",\n \"path\": \"VisualSearch/model/llava/constants.py\",\n \"snippet\": \"DEFAULT_IMAGE_TOKEN = \\\"<image>\\\"\"\n },\n {\n \"identifier\": \"IGNORE_INDEX\",\n \"path\": \"VisualSearch/model/llava/constants.py\",\n \"snippet\": \"IGNORE_INDEX = -100\"\n },\n {\n \"identifier\": \"IMAGE_TOKEN_INDEX\",\n \"path\": \"VisualSearch/model/llava/constants.py\",\n \"snippet\": \"IMAGE_TOKEN_INDEX = -200\"\n },\n {\n \"identifier\": \"tokenizer_image_token\",\n \"path\": \"VisualSearch/model/llava/mm_utils.py\",\n \"snippet\": \"def tokenizer_image_token(\\n prompt, tokenizer, image_token_index=IMAGE_TOKEN_INDEX, return_tensors=None\\n):\\n prompt_chunks = [tokenizer(chunk).input_ids for chunk in prompt.split(\\\"<image>\\\")]\\n\\n def insert_separator(X, sep):\\n return [ele for sublist in zip(X, [sep] * len(X)) for ele in sublist][:-1]\\n\\n input_ids = []\\n offset = 0\\n if (\\n len(prompt_chunks) > 0\\n and len(prompt_chunks[0]) > 0\\n and prompt_chunks[0][0] == tokenizer.bos_token_id\\n ):\\n offset = 1\\n input_ids.append(prompt_chunks[0][0])\\n\\n for x in insert_separator(prompt_chunks, [image_token_index] * (offset + 1)):\\n input_ids.extend(x[offset:])\\n\\n if return_tensors is not None:\\n if return_tensors == \\\"pt\\\":\\n return torch.tensor(input_ids, dtype=torch.long)\\n raise ValueError(f\\\"Unsupported tensor type: {return_tensors}\\\")\\n return input_ids\"\n },\n {\n \"identifier\": \"get_mask_from_json\",\n \"path\": \"VisualSearch/utils/data_processing.py\",\n \"snippet\": \"def get_mask_from_json(json_path, img):\\n try:\\n with open(json_path, \\\"r\\\") as r:\\n anno = json.loads(r.read())\\n except:\\n with open(json_path, \\\"r\\\", encoding=\\\"cp1252\\\") as r:\\n anno = json.loads(r.read())\\n\\n inform = anno[\\\"shapes\\\"]\\n comments = anno[\\\"text\\\"]\\n is_sentence = anno[\\\"is_sentence\\\"]\\n\\n height, width = img.shape[:2]\\n\\n ### sort polies by area\\n area_list = []\\n valid_poly_list = []\\n for i in inform:\\n label_id = i[\\\"label\\\"]\\n points = i[\\\"points\\\"]\\n if \\\"flag\\\" == label_id.lower(): ## meaningless deprecated annotations\\n continue\\n\\n tmp_mask = np.zeros((height, width), dtype=np.uint8)\\n cv2.polylines(tmp_mask, np.array([points], dtype=np.int32), True, 1, 1)\\n cv2.fillPoly(tmp_mask, np.array([points], dtype=np.int32), 1)\\n tmp_area = tmp_mask.sum()\\n\\n area_list.append(tmp_area)\\n valid_poly_list.append(i)\\n\\n ### ground-truth mask\\n sort_index = np.argsort(area_list)[::-1].astype(np.int32)\\n sort_index = list(sort_index)\\n sort_inform = []\\n for s_idx in sort_index:\\n sort_inform.append(valid_poly_list[s_idx])\\n\\n mask = np.zeros((height, width), dtype=np.uint8)\\n for i in sort_inform:\\n label_id = i[\\\"label\\\"]\\n points = i[\\\"points\\\"]\\n\\n if \\\"ignore\\\" in label_id.lower():\\n label_value = 255 # ignored during evaluation\\n else:\\n label_value = 1 # target\\n\\n cv2.polylines(mask, np.array([points], dtype=np.int32), True, label_value, 1)\\n cv2.fillPoly(mask, np.array([points], dtype=np.int32), label_value)\\n\\n return mask, comments, is_sentence\"\n },\n {\n \"identifier\": \"REFER\",\n \"path\": \"VisualSearch/utils/refer.py\",\n \"snippet\": \"class REFER:\\n def __init__(self, data_root, dataset=\\\"refcoco\\\", splitBy=\\\"unc\\\"):\\n # provide data_root folder which contains refclef, refcoco, refcoco+ and refcocog\\n # also provide dataset name and splitBy information\\n # e.g., dataset = 'refcoco', splitBy = 'unc'\\n print(\\\"loading dataset %s into memory...\\\" % dataset)\\n self.ROOT_DIR = osp.abspath(osp.dirname(__file__))\\n self.DATA_DIR = osp.join(data_root, dataset)\\n if dataset in [\\\"refcoco\\\", \\\"refcoco+\\\", \\\"refcocog\\\"]:\\n self.IMAGE_DIR = osp.join(data_root, \\\"images/mscoco/images/train2014\\\")\\n elif dataset == \\\"refclef\\\":\\n self.IMAGE_DIR = osp.join(data_root, \\\"images/saiapr_tc-12\\\")\\n else:\\n print(\\\"No refer dataset is called [%s]\\\" % dataset)\\n sys.exit()\\n\\n self.dataset = dataset\\n\\n # load refs from data/dataset/refs(dataset).json\\n tic = time.time()\\n\\n ref_file = osp.join(self.DATA_DIR, \\\"refs(\\\" + splitBy + \\\").p\\\")\\n print(\\\"ref_file: \\\", ref_file)\\n self.data = {}\\n self.data[\\\"dataset\\\"] = dataset\\n self.data[\\\"refs\\\"] = pickle.load(open(ref_file, \\\"rb\\\"))\\n\\n # load annotations from data/dataset/instances.json\\n instances_file = osp.join(self.DATA_DIR, \\\"instances.json\\\")\\n instances = json.load(open(instances_file, \\\"rb\\\"))\\n self.data[\\\"images\\\"] = instances[\\\"images\\\"]\\n self.data[\\\"annotations\\\"] = instances[\\\"annotations\\\"]\\n self.data[\\\"categories\\\"] = instances[\\\"categories\\\"]\\n\\n # create index\\n self.createIndex()\\n print(\\\"DONE (t=%.2fs)\\\" % (time.time() - tic))\\n\\n def createIndex(self):\\n # create sets of mapping\\n # 1) Refs: \\t \\t{ref_id: ref}\\n # 2) Anns: \\t \\t{ann_id: ann}\\n # 3) Imgs:\\t\\t \\t{image_id: image}\\n # 4) Cats: \\t \\t{category_id: category_name}\\n # 5) Sents: \\t{sent_id: sent}\\n # 6) imgToRefs: \\t{image_id: refs}\\n # 7) imgToAnns: \\t{image_id: anns}\\n # 8) refToAnn: \\t{ref_id: ann}\\n # 9) annToRef: \\t{ann_id: ref}\\n # 10) catToRefs: \\t{category_id: refs}\\n # 11) sentToRef: \\t{sent_id: ref}\\n # 12) sentToTokens: {sent_id: tokens}\\n print(\\\"creating index...\\\")\\n # fetch info from instances\\n Anns, Imgs, Cats, imgToAnns = {}, {}, {}, {}\\n for ann in self.data[\\\"annotations\\\"]:\\n Anns[ann[\\\"id\\\"]] = ann\\n imgToAnns[ann[\\\"image_id\\\"]] = imgToAnns.get(ann[\\\"image_id\\\"], []) + [ann]\\n for img in self.data[\\\"images\\\"]:\\n Imgs[img[\\\"id\\\"]] = img\\n for cat in self.data[\\\"categories\\\"]:\\n Cats[cat[\\\"id\\\"]] = cat[\\\"name\\\"]\\n\\n # fetch info from refs\\n Refs, imgToRefs, refToAnn, annToRef, catToRefs = {}, {}, {}, {}, {}\\n Sents, sentToRef, sentToTokens = {}, {}, {}\\n for ref in self.data[\\\"refs\\\"]:\\n # ids\\n ref_id = ref[\\\"ref_id\\\"]\\n ann_id = ref[\\\"ann_id\\\"]\\n category_id = ref[\\\"category_id\\\"]\\n image_id = ref[\\\"image_id\\\"]\\n\\n # add mapping related to ref\\n Refs[ref_id] = ref\\n imgToRefs[image_id] = imgToRefs.get(image_id, []) + [ref]\\n catToRefs[category_id] = catToRefs.get(category_id, []) + [ref]\\n refToAnn[ref_id] = Anns[ann_id]\\n annToRef[ann_id] = ref\\n\\n # add mapping of sent\\n for sent in ref[\\\"sentences\\\"]:\\n Sents[sent[\\\"sent_id\\\"]] = sent\\n sentToRef[sent[\\\"sent_id\\\"]] = ref\\n sentToTokens[sent[\\\"sent_id\\\"]] = sent[\\\"tokens\\\"]\\n\\n # create class members\\n self.Refs = Refs\\n self.Anns = Anns\\n self.Imgs = Imgs\\n self.Cats = Cats\\n self.Sents = Sents\\n self.imgToRefs = imgToRefs\\n self.imgToAnns = imgToAnns\\n self.refToAnn = refToAnn\\n self.annToRef = annToRef\\n self.catToRefs = catToRefs\\n self.sentToRef = sentToRef\\n self.sentToTokens = sentToTokens\\n print(\\\"index created.\\\")\\n\\n def getRefIds(self, image_ids=[], cat_ids=[], ref_ids=[], split=\\\"\\\"):\\n image_ids = image_ids if type(image_ids) == list else [image_ids]\\n cat_ids = cat_ids if type(cat_ids) == list else [cat_ids]\\n ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]\\n\\n if len(image_ids) == len(cat_ids) == len(ref_ids) == len(split) == 0:\\n refs = self.data[\\\"refs\\\"]\\n else:\\n if not len(image_ids) == 0:\\n refs = [self.imgToRefs[image_id] for image_id in image_ids]\\n else:\\n refs = self.data[\\\"refs\\\"]\\n if not len(cat_ids) == 0:\\n refs = [ref for ref in refs if ref[\\\"category_id\\\"] in cat_ids]\\n if not len(ref_ids) == 0:\\n refs = [ref for ref in refs if ref[\\\"ref_id\\\"] in ref_ids]\\n if not len(split) == 0:\\n if split in [\\\"testA\\\", \\\"testB\\\", \\\"testC\\\"]:\\n refs = [\\n ref for ref in refs if split[-1] in ref[\\\"split\\\"]\\n ] # we also consider testAB, testBC, ...\\n elif split in [\\\"testAB\\\", \\\"testBC\\\", \\\"testAC\\\"]:\\n refs = [\\n ref for ref in refs if ref[\\\"split\\\"] == split\\n ] # rarely used I guess...\\n elif split == \\\"test\\\":\\n refs = [ref for ref in refs if \\\"test\\\" in ref[\\\"split\\\"]]\\n elif split == \\\"train\\\" or split == \\\"val\\\":\\n refs = [ref for ref in refs if ref[\\\"split\\\"] == split]\\n else:\\n print(\\\"No such split [%s]\\\" % split)\\n sys.exit()\\n ref_ids = [ref[\\\"ref_id\\\"] for ref in refs]\\n return ref_ids\\n\\n def getAnnIds(self, image_ids=[], cat_ids=[], ref_ids=[]):\\n image_ids = image_ids if type(image_ids) == list else [image_ids]\\n cat_ids = cat_ids if type(cat_ids) == list else [cat_ids]\\n ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]\\n\\n if len(image_ids) == len(cat_ids) == len(ref_ids) == 0:\\n ann_ids = [ann[\\\"id\\\"] for ann in self.data[\\\"annotations\\\"]]\\n else:\\n if not len(image_ids) == 0:\\n lists = [\\n self.imgToAnns[image_id]\\n for image_id in image_ids\\n if image_id in self.imgToAnns\\n ] # list of [anns]\\n anns = list(itertools.chain.from_iterable(lists))\\n else:\\n anns = self.data[\\\"annotations\\\"]\\n if not len(cat_ids) == 0:\\n anns = [ann for ann in anns if ann[\\\"category_id\\\"] in cat_ids]\\n ann_ids = [ann[\\\"id\\\"] for ann in anns]\\n if not len(ref_ids) == 0:\\n ids = set(ann_ids).intersection(\\n set([self.Refs[ref_id][\\\"ann_id\\\"] for ref_id in ref_ids])\\n )\\n return ann_ids\\n\\n def getImgIds(self, ref_ids=[]):\\n ref_ids = ref_ids if type(ref_ids) == list else [ref_ids]\\n\\n if not len(ref_ids) == 0:\\n image_ids = list(set([self.Refs[ref_id][\\\"image_id\\\"] for ref_id in ref_ids]))\\n else:\\n image_ids = self.Imgs.keys()\\n return image_ids\\n\\n def getCatIds(self):\\n return self.Cats.keys()\\n\\n def loadRefs(self, ref_ids=[]):\\n if type(ref_ids) == list:\\n return [self.Refs[ref_id] for ref_id in ref_ids]\\n elif type(ref_ids) == int:\\n return [self.Refs[ref_ids]]\\n\\n def loadAnns(self, ann_ids=[]):\\n if type(ann_ids) == list:\\n return [self.Anns[ann_id] for ann_id in ann_ids]\\n elif type(ann_ids) == int or type(ann_ids) == unicode:\\n return [self.Anns[ann_ids]]\\n\\n def loadImgs(self, image_ids=[]):\\n if type(image_ids) == list:\\n return [self.Imgs[image_id] for image_id in image_ids]\\n elif type(image_ids) == int:\\n return [self.Imgs[image_ids]]\\n\\n def loadCats(self, cat_ids=[]):\\n if type(cat_ids) == list:\\n return [self.Cats[cat_id] for cat_id in cat_ids]\\n elif type(cat_ids) == int:\\n return [self.Cats[cat_ids]]\\n\\n def getRefBox(self, ref_id):\\n ref = self.Refs[ref_id]\\n ann = self.refToAnn[ref_id]\\n return ann[\\\"bbox\\\"] # [x, y, w, h]\\n\\n def showRef(self, ref, seg_box=\\\"seg\\\"):\\n ax = plt.gca()\\n # show image\\n image = self.Imgs[ref[\\\"image_id\\\"]]\\n I = io.imread(osp.join(self.IMAGE_DIR, image[\\\"file_name\\\"]))\\n ax.imshow(I)\\n # show refer expression\\n for sid, sent in enumerate(ref[\\\"sentences\\\"]):\\n print(\\\"%s. %s\\\" % (sid + 1, sent[\\\"sent\\\"]))\\n # show segmentations\\n if seg_box == \\\"seg\\\":\\n ann_id = ref[\\\"ann_id\\\"]\\n ann = self.Anns[ann_id]\\n polygons = []\\n color = []\\n c = \\\"none\\\"\\n if type(ann[\\\"segmentation\\\"][0]) == list:\\n # polygon used for refcoco*\\n for seg in ann[\\\"segmentation\\\"]:\\n poly = np.array(seg).reshape((len(seg) / 2, 2))\\n polygons.append(Polygon(poly, True, alpha=0.4))\\n color.append(c)\\n p = PatchCollection(\\n polygons,\\n facecolors=color,\\n edgecolors=(1, 1, 0, 0),\\n linewidths=3,\\n alpha=1,\\n )\\n ax.add_collection(p) # thick yellow polygon\\n p = PatchCollection(\\n polygons,\\n facecolors=color,\\n edgecolors=(1, 0, 0, 0),\\n linewidths=1,\\n alpha=1,\\n )\\n ax.add_collection(p) # thin red polygon\\n else:\\n # mask used for refclef\\n rle = ann[\\\"segmentation\\\"]\\n m = mask.decode(rle)\\n img = np.ones((m.shape[0], m.shape[1], 3))\\n color_mask = np.array([2.0, 166.0, 101.0]) / 255\\n for i in range(3):\\n img[:, :, i] = color_mask[i]\\n ax.imshow(np.dstack((img, m * 0.5)))\\n # show bounding-box\\n elif seg_box == \\\"box\\\":\\n ann_id = ref[\\\"ann_id\\\"]\\n ann = self.Anns[ann_id]\\n bbox = self.getRefBox(ref[\\\"ref_id\\\"])\\n box_plot = Rectangle(\\n (bbox[0], bbox[1]),\\n bbox[2],\\n bbox[3],\\n fill=False,\\n edgecolor=\\\"green\\\",\\n linewidth=3,\\n )\\n ax.add_patch(box_plot)\\n\\n def getMask(self, ref):\\n # return mask, area and mask-center\\n ann = self.refToAnn[ref[\\\"ref_id\\\"]]\\n image = self.Imgs[ref[\\\"image_id\\\"]]\\n if type(ann[\\\"segmentation\\\"][0]) == list: # polygon\\n rle = mask.frPyObjects(ann[\\\"segmentation\\\"], image[\\\"height\\\"], image[\\\"width\\\"])\\n else:\\n rle = ann[\\\"segmentation\\\"]\\n m = mask.decode(rle)\\n m = np.sum(\\n m, axis=2\\n ) # sometimes there are multiple binary map (corresponding to multiple segs)\\n m = m.astype(np.uint8) # convert to np.uint8\\n # compute area\\n area = sum(mask.area(rle)) # should be close to ann['area']\\n return {\\\"mask\\\": m, \\\"area\\\": area}\\n # # position\\n # position_x = np.mean(np.where(m==1)[1]) # [1] means columns (matlab style) -> x (c style)\\n # position_y = np.mean(np.where(m==1)[0]) # [0] means rows (matlab style) -> y (c style)\\n # # mass position (if there were multiple regions, we use the largest one.)\\n # label_m = label(m, connectivity=m.ndim)\\n # regions = regionprops(label_m)\\n # if len(regions) > 0:\\n # \\tlargest_id = np.argmax(np.array([props.filled_area for props in regions]))\\n # \\tlargest_props = regions[largest_id]\\n # \\tmass_y, mass_x = largest_props.centroid\\n # else:\\n # \\tmass_x, mass_y = position_x, position_y\\n # # if centroid is not in mask, we find the closest point to it from mask\\n # if m[mass_y, mass_x] != 1:\\n # \\tprint('Finding closes mask point ...')\\n # \\tkernel = np.ones((10, 10),np.uint8)\\n # \\tme = cv2.erode(m, kernel, iterations = 1)\\n # \\tpoints = zip(np.where(me == 1)[0].tolist(), np.where(me == 1)[1].tolist()) # row, col style\\n # \\tpoints = np.array(points)\\n # \\tdist = np.sum((points - (mass_y, mass_x))**2, axis=1)\\n # \\tid = np.argsort(dist)[0]\\n # \\tmass_y, mass_x = points[id]\\n # \\t# return\\n # return {'mask': m, 'area': area, 'position_x': position_x, 'position_y': position_y, 'mass_x': mass_x, 'mass_y': mass_y}\\n # # show image and mask\\n # I = io.imread(osp.join(self.IMAGE_DIR, image['file_name']))\\n # plt.figure()\\n # plt.imshow(I)\\n # ax = plt.gca()\\n # img = np.ones( (m.shape[0], m.shape[1], 3) )\\n # color_mask = np.array([2.0,166.0,101.0])/255\\n # for i in range(3):\\n # img[:,:,i] = color_mask[i]\\n # ax.imshow(np.dstack( (img, m*0.5) ))\\n # plt.show()\\n\\n def showMask(self, ref):\\n M = self.getMask(ref)\\n msk = M[\\\"mask\\\"]\\n ax = plt.gca()\\n ax.imshow(msk)\"\n },\n {\n \"identifier\": \"ReferSegDataset\",\n \"path\": \"VisualSearch/utils/refer_seg_dataset.py\",\n \"snippet\": \"class ReferSegDataset(torch.utils.data.Dataset):\\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\\n img_size = 1024\\n ignore_label = 255\\n\\n def __init__(\\n self,\\n base_dir,\\n tokenizer,\\n vision_tower,\\n samples_per_epoch=500 * 8 * 2 * 10,\\n precision: str = \\\"fp32\\\",\\n num_classes_per_sample: int = 3,\\n exclude_val=False,\\n refer_seg_data=\\\"refclef||refcoco||refcoco+||refcocog\\\",\\n ):\\n self.exclude_val = exclude_val\\n self.samples_per_epoch = samples_per_epoch\\n self.num_classes_per_sample = num_classes_per_sample\\n\\n self.base_dir = base_dir\\n self.tokenizer = tokenizer\\n self.precision = precision\\n self.transform = OwlViTProcessor.from_pretrained(\\\"google/owlvit-base-patch16\\\")\\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\\n\\n self.short_question_list = SHORT_QUESTION_LIST\\n self.answer_list = ANSWER_LIST\\n\\n DATA_DIR = os.path.join(base_dir, \\\"refer_seg\\\")\\n self.refer_seg_ds_list = refer_seg_data.split(\\n \\\"||\\\"\\n ) # ['refclef', 'refcoco', 'refcoco+', 'refcocog']\\n self.refer_seg_data = {}\\n for ds in self.refer_seg_ds_list:\\n if ds == \\\"refcocog\\\":\\n splitBy = \\\"umd\\\"\\n else:\\n splitBy = \\\"unc\\\"\\n\\n if ds == \\\"grefcoco\\\":\\n refer_api = G_REFER(DATA_DIR, ds, splitBy)\\n else:\\n refer_api = REFER(DATA_DIR, ds, splitBy)\\n ref_ids_train = refer_api.getRefIds(split=\\\"train\\\")\\n images_ids_train = refer_api.getImgIds(ref_ids=ref_ids_train)\\n refs_train = refer_api.loadRefs(ref_ids=ref_ids_train)\\n\\n refer_seg_ds = {}\\n refer_seg_ds[\\\"images\\\"] = []\\n loaded_images = refer_api.loadImgs(image_ids=images_ids_train)\\n\\n for item in loaded_images:\\n item = item.copy()\\n if ds == \\\"refclef\\\":\\n item[\\\"file_name\\\"] = os.path.join(\\n DATA_DIR, \\\"images/saiapr_tc-12\\\", item[\\\"file_name\\\"]\\n )\\n else:\\n item[\\\"file_name\\\"] = os.path.join(\\n DATA_DIR, \\\"images/mscoco/images/train2014\\\", item[\\\"file_name\\\"]\\n )\\n refer_seg_ds[\\\"images\\\"].append(item)\\n refer_seg_ds[\\\"annotations\\\"] = refer_api.Anns # anns_train\\n\\n print(\\n \\\"dataset {} (refs {}) (train split) has {} images and {} annotations.\\\".format(\\n ds,\\n splitBy,\\n len(refer_seg_ds[\\\"images\\\"]),\\n len(refer_seg_ds[\\\"annotations\\\"]),\\n )\\n )\\n\\n img2refs = {}\\n for ref in refs_train:\\n image_id = ref[\\\"image_id\\\"]\\n img2refs[image_id] = img2refs.get(image_id, []) + [\\n ref,\\n ]\\n refer_seg_ds[\\\"img2refs\\\"] = img2refs\\n self.refer_seg_data[ds] = refer_seg_ds\\n\\n def __len__(self):\\n return self.samples_per_epoch\\n\\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"Normalize pixel values and pad to a square input.\\\"\\\"\\\"\\n # Normalize colors\\n x = (x - self.pixel_mean) / self.pixel_std\\n\\n # Pad\\n h, w = x.shape[-2:]\\n padh = self.img_size - h\\n padw = self.img_size - w\\n x = F.pad(x, (0, padw, 0, padh))\\n return x\\n\\n def __getitem__(self, idx):\\n ds = random.randint(0, len(self.refer_seg_ds_list) - 1)\\n ds = self.refer_seg_ds_list[ds]\\n refer_seg_ds = self.refer_seg_data[ds]\\n images = refer_seg_ds[\\\"images\\\"]\\n annotations = refer_seg_ds[\\\"annotations\\\"]\\n img2refs = refer_seg_ds[\\\"img2refs\\\"]\\n idx = random.randint(0, len(images) - 1)\\n image_info = images[idx]\\n image_path = image_info[\\\"file_name\\\"]\\n image_id = image_info[\\\"id\\\"]\\n refs = img2refs[image_id]\\n if len(refs) == 0:\\n return self.__getitem__(0)\\n\\n sents = []\\n ann_ids = []\\n for ref in refs:\\n for sent in ref[\\\"sentences\\\"]:\\n text = sent[\\\"sent\\\"]\\n sents.append(text)\\n ann_ids.append(ref[\\\"ann_id\\\"])\\n if len(sents) >= self.num_classes_per_sample:\\n sampled_inds = np.random.choice(\\n list(range(len(sents))), size=self.num_classes_per_sample, replace=False\\n )\\n else:\\n sampled_inds = list(range(len(sents)))\\n sampled_sents = np.vectorize(sents.__getitem__)(sampled_inds).tolist()\\n # sampled_ann_ids = np.vectorize(ann_ids.__getitem__)(sampled_inds).tolist()\\n sampled_ann_ids = [ann_ids[ind] for ind in sampled_inds]\\n sampled_classes = sampled_sents\\n image = cv2.imread(image_path)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n\\n # preprocess image for clip\\n image_clip = self.clip_image_processor.preprocess(\\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\\\"pt\\\")[\\\"pixel_values\\\"][0]\\n original_size = image.shape[:2]\\n image = self.transform(images=image, return_tensors=\\\"pt\\\")['pixel_values'][0]\\n resize = image.shape[:2]\\n\\n questions = []\\n answers = []\\n for text in sampled_classes:\\n text = text.strip()\\n assert len(text.split(\\\"||\\\")) == 1\\n question_template = random.choice(self.short_question_list)\\n questions.append(question_template.format(class_name=text.lower()))\\n answers.append(random.choice(self.answer_list))\\n\\n conversations = []\\n conv = conversation_lib.default_conversation.copy()\\n\\n i = 0\\n while i < len(questions):\\n conv.messages = []\\n conv.append_message(conv.roles[0], questions[i])\\n conv.append_message(conv.roles[1], answers[i])\\n conversations.append(conv.get_prompt())\\n i += 1\\n\\n flag = False\\n masks = []\\n bboxes_labels = []\\n for ann_id in sampled_ann_ids:\\n if isinstance(ann_id, list):\\n assert False\\n flag = True\\n if -1 in ann_id:\\n assert len(ann_id) == 1\\n m = np.zeros((image_info[\\\"height\\\"], image_info[\\\"width\\\"])).astype(\\n np.uint8\\n )\\n else:\\n m_final = np.zeros(\\n (image_info[\\\"height\\\"], image_info[\\\"width\\\"])\\n ).astype(np.uint8)\\n for ann_id_i in ann_id:\\n ann = annotations[ann_id_i]\\n\\n if len(ann[\\\"segmentation\\\"]) == 0:\\n m = np.zeros(\\n (image_info[\\\"height\\\"], image_info[\\\"width\\\"])\\n ).astype(np.uint8)\\n else:\\n if type(ann[\\\"segmentation\\\"][0]) == list: # polygon\\n rle = mask.frPyObjects(\\n ann[\\\"segmentation\\\"],\\n image_info[\\\"height\\\"],\\n image_info[\\\"width\\\"],\\n )\\n else:\\n rle = ann[\\\"segmentation\\\"]\\n for i in range(len(rle)):\\n if not isinstance(rle[i][\\\"counts\\\"], bytes):\\n rle[i][\\\"counts\\\"] = rle[i][\\\"counts\\\"].encode()\\n m = mask.decode(rle)\\n m = np.sum(\\n m, axis=2\\n ) # sometimes there are multiple binary map (corresponding to multiple segs)\\n m = m.astype(np.uint8) # convert to np.uint8\\n m_final = m_final | m\\n m = m_final\\n masks.append(m)\\n continue\\n \\n ann = annotations[ann_id]\\n cur_bboxes = [ann['bbox']]\\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\\n # xywh to x1y1x2y2\\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\\n cur_bboxes = cur_bboxes[keep]\\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\\n if len(cur_bboxes) == 0:\\n return self.__getitem__(0)\\n bboxes_labels.append(cur_bboxes)\\n \\n if len(ann[\\\"segmentation\\\"]) == 0:\\n m = np.zeros((image_info[\\\"height\\\"], image_info[\\\"width\\\"])).astype(\\n np.uint8\\n )\\n masks.append(m)\\n continue\\n\\n if type(ann[\\\"segmentation\\\"][0]) == list: # polygon\\n rle = mask.frPyObjects(\\n ann[\\\"segmentation\\\"], image_info[\\\"height\\\"], image_info[\\\"width\\\"]\\n )\\n else:\\n rle = ann[\\\"segmentation\\\"]\\n for i in range(len(rle)):\\n if not isinstance(rle[i][\\\"counts\\\"], bytes):\\n rle[i][\\\"counts\\\"] = rle[i][\\\"counts\\\"].encode()\\n m = mask.decode(rle)\\n m = np.sum(\\n m, axis=2\\n ) # sometimes there are multiple binary map (corresponding to multiple segs)\\n m = m.astype(np.uint8) # convert to np.uint8\\n masks.append(m)\\n bboxes_valid = [1]*len(bboxes_labels)\\n masks_valid = [1]*len(bboxes_labels)\\n masks = np.stack(masks, axis=0)\\n\\n\\n masks = torch.from_numpy(masks)\\n label = torch.ones(masks.shape[1], masks.shape[2]) * self.ignore_label\\n\\n return (\\n image_path,\\n image,\\n image_clip,\\n conversations,\\n masks,\\n label,\\n bboxes_labels,\\n bboxes_valid,\\n masks_valid,\\n resize,\\n questions,\\n sampled_classes,\\n )\"\n },\n {\n \"identifier\": \"SegDetDataset\",\n \"path\": \"VisualSearch/utils/general_segdet_dataset.py\",\n \"snippet\": \"class SegDetDataset(torch.utils.data.Dataset):\\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\\n img_size = 1024\\n ignore_label = 255\\n\\n def __init__(\\n self,\\n base_dir,\\n tokenizer,\\n vision_tower,\\n samples_per_epoch=500 * 8 * 2 * 10,\\n precision: str = \\\"fp32\\\",\\n num_classes_per_sample: int = 3,\\n exclude_val=False,\\n general_segdet_data=\\\"objects365||cocostuff||paco_lvis\\\",\\n general_segdet_sample_rate=[2,1,1]\\n ):\\n self.exclude_val = exclude_val\\n self.samples_per_epoch = samples_per_epoch\\n self.num_classes_per_sample = num_classes_per_sample\\n\\n self.base_dir = base_dir\\n self.tokenizer = tokenizer\\n self.precision = precision\\n self.transform = OwlViTProcessor.from_pretrained(\\\"google/owlvit-base-patch16\\\")\\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\\n\\n self.short_question_list = SHORT_QUESTION_LIST\\n self.answer_list = ANSWER_LIST\\n\\n self.data2list = {}\\n self.data2classes = {}\\n\\n self.general_segdet_datas = general_segdet_data.split(\\\"||\\\")\\n num_images = []\\n for ds in self.general_segdet_datas:\\n if ds == \\\"cocostuff\\\":\\n classes, images, labels, bboxes = eval(\\\"init_{}\\\".format(ds))(base_dir)\\n self.data2list[ds] = (images, labels, bboxes)\\n elif ds == \\\"objects365\\\":\\n classes, images, bboxes = eval(\\\"init_{}\\\".format(ds))(base_dir)\\n self.data2list[ds] = (images, bboxes)\\n else:\\n classes, images, labels = eval(\\\"init_{}\\\".format(ds))(base_dir)\\n self.data2list[ds] = (images, labels)\\n self.data2classes[ds] = classes\\n num_images.append(len(images))\\n sample_rate = np.array(general_segdet_sample_rate)\\n self.sample_rate = sample_rate / sample_rate.sum()\\n\\n if \\\"cocostuff\\\" in self.general_segdet_datas:\\n self.cocostuff_class2index = {\\n c: i for i, c in enumerate(self.data2classes[\\\"cocostuff\\\"])\\n }\\n\\n def __len__(self):\\n return self.samples_per_epoch\\n\\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"Normalize pixel values and pad to a square input.\\\"\\\"\\\"\\n # Normalize colors\\n x = (x - self.pixel_mean) / self.pixel_std\\n\\n # Pad\\n h, w = x.shape[-2:]\\n padh = self.img_size - h\\n padw = self.img_size - w\\n x = F.pad(x, (0, padw, 0, padh))\\n return x\\n\\n def __getitem__(self, idx):\\n ds = np.random.choice(list(range(len(self.general_segdet_datas))), p=self.sample_rate)\\n ds = self.general_segdet_datas[ds]\\n\\n if ds in [\\\"paco_lvis\\\"]:\\n class_map = self.data2classes[ds]\\n img_ids, coco_api = self.data2list[ds]\\n idx = random.randint(0, len(img_ids) - 1)\\n img_id = img_ids[idx]\\n image_info = coco_api.loadImgs([img_id])[0]\\n file_name = image_info[\\\"file_name\\\"]\\n if ds == \\\"pascal_part\\\":\\n file_name = os.path.join(\\n \\\"VOCdevkit\\\", \\\"VOC2010\\\", \\\"JPEGImages\\\", file_name\\n )\\n image_path = os.path.join(self.base_dir, \\\"vlpart\\\", ds, file_name)\\n elif ds == \\\"paco_lvis\\\":\\n image_path = os.path.join(self.base_dir, \\\"coco2017\\\", file_name)\\n image = cv2.imread(image_path)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n\\n # preprocess image for clip\\n image_clip = self.clip_image_processor.preprocess(\\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\\\"pt\\\"\\n )[\\\"pixel_values\\\"][0]\\n original_size = image.shape[:2]\\n image = self.transform(images=image, return_tensors=\\\"pt\\\")['pixel_values'][0]\\n resize = image.shape[:2]\\n annIds = coco_api.getAnnIds(imgIds=image_info[\\\"id\\\"])\\n anns = coco_api.loadAnns(annIds)\\n anns_category2instances = dict()\\n for ann in anns:\\n category_id = ann['category_id']\\n if category_id not in anns_category2instances:\\n anns_category2instances[category_id] = []\\n anns_category2instances[category_id].append(ann)\\n if len(anns_category2instances) == 0:\\n return self.__getitem__(0)\\n if len(anns_category2instances) >= self.num_classes_per_sample:\\n sampled_anns = np.random.choice(\\n list(anns_category2instances.keys()), size=self.num_classes_per_sample, replace=False\\n ).tolist()\\n else:\\n sampled_anns = list(anns_category2instances.keys())\\n sampled_classes = []\\n for category_id in sampled_anns:\\n sampled_cls = class_map[category_id]\\n if isinstance(sampled_cls, tuple):\\n obj, part = sampled_cls\\n if random.random() < 0.5:\\n name = obj + \\\" \\\" + part\\n else:\\n name = \\\"the {} of the {}\\\".format(part, obj)\\n else:\\n name = sampled_cls\\n name = name.replace('_', ' ')\\n sampled_classes.append(name)\\n\\n elif ds in [\\\"cocostuff\\\"]:\\n image, labels, bboxes_all = self.data2list[ds]\\n idx = random.randint(0, len(image) - 1)\\n image_path = image[idx]\\n label_path = labels[idx]\\n bboxes = bboxes_all[idx]\\n label = Image.open(label_path)\\n label = np.array(label)\\n if ds == \\\"ade20k\\\":\\n label[label == 0] = 255\\n label -= 1\\n label[label == 254] = 255\\n elif ds == \\\"cocostuff\\\":\\n for c, i in self.cocostuff_class2index.items():\\n if \\\"-\\\" in c:\\n label[label == i] = 255\\n img = cv2.imread(image_path)\\n image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n # preprocess image for clip\\n image_clip = self.clip_image_processor.preprocess(\\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\\\"pt\\\"\\n )[\\\"pixel_values\\\"][0]\\n original_size = image.shape[:2]\\n image = self.transform(images=image, return_tensors=\\\"pt\\\")['pixel_values'][0]\\n resize = image.shape[:2]\\n unique_label = np.unique(label).tolist()\\n if 255 in unique_label:\\n unique_label.remove(255)\\n if len(unique_label) == 0:\\n return self.__getitem__(0)\\n\\n classes = [self.data2classes[ds][class_id] for class_id in unique_label]\\n if len(classes) >= self.num_classes_per_sample:\\n sampled_classes = np.random.choice(\\n classes, size=self.num_classes_per_sample, replace=False\\n ).tolist()\\n else:\\n sampled_classes = classes\\n\\n elif ds in ['objects365']:\\n image, bboxes_all = self.data2list[ds]\\n idx = random.randint(0, len(image) - 1)\\n image_path = image[idx]\\n bboxes = bboxes_all[idx]\\n img = cv2.imread(image_path)\\n image = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n # preprocess image for clip\\n image_clip = self.clip_image_processor.preprocess(\\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\\\"pt\\\"\\n )[\\\"pixel_values\\\"][0]\\n original_size = image.shape[:2]\\n image = self.transform(images=image, return_tensors=\\\"pt\\\")['pixel_values'][0]\\n resize = image.shape[:2]\\n unique_label = set()\\n for bbox_info in bboxes:\\n unique_label.add(bbox_info['category_id'])\\n unique_label = list(unique_label)\\n if len(unique_label) == 0:\\n return self.__getitem__(0)\\n\\n classes = [self.data2classes[ds][class_id] for class_id in unique_label]\\n if len(classes) >= self.num_classes_per_sample:\\n sampled_classes = np.random.choice(\\n classes, size=self.num_classes_per_sample, replace=False\\n ).tolist()\\n else:\\n sampled_classes = classes\\n\\n\\n questions = []\\n answers = []\\n class_ids = []\\n bboxes_labels = []\\n for i, sampled_cls in enumerate(sampled_classes):\\n text = sampled_cls\\n if ds in ['objects365']:\\n text = random.sample(text.split('/'), 1)[0]\\n \\n assert len(text.split(\\\"||\\\")) == 1\\n question_template = random.choice(self.short_question_list)\\n questions.append(question_template.format(class_name=text.lower()))\\n\\n answers.append(random.choice(self.answer_list))\\n\\n if ds in [\\\"paco_lvis\\\", \\\"pascal_part\\\"]:\\n category_id = sampled_anns[i]\\n cur_bboxes = [instance['bbox'] for instance in anns_category2instances[category_id]]\\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\\n # xywh to x1y1x2y2\\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\\n cur_bboxes = cur_bboxes[keep]\\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\\n if len(cur_bboxes) == 0:\\n return self.__getitem__(0)\\n bboxes_labels.append(cur_bboxes)\\n continue\\n\\n class_id = self.data2classes[ds].tolist().index(sampled_cls)\\n class_ids.append(class_id)\\n if ds in ['objects365']:\\n cur_bboxes = [bbox['bbox'] for bbox in bboxes if bbox['category_id'] == class_id]\\n else:\\n cur_bboxes = [bbox['bbox'] for bbox in bboxes if bbox['category_id']-1 == class_id]\\n cur_bboxes = cur_bboxes[:100]\\n assert len(cur_bboxes) > 0\\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\\n # xywh to x1y1x2y2\\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\\n cur_bboxes = cur_bboxes[keep]\\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\\n if len(cur_bboxes) == 0:\\n return self.__getitem__(0)\\n bboxes_labels.append(cur_bboxes)\\n bboxes_valid = [1]*len(bboxes_labels)\\n masks_valid = [1]*len(bboxes_labels)\\n conversations = []\\n conv = conversation_lib.default_conversation.copy()\\n\\n i = 0\\n while i < len(questions):\\n conv.messages = []\\n conv.append_message(conv.roles[0], questions[i])\\n conv.append_message(conv.roles[1], answers[i])\\n conversations.append(conv.get_prompt())\\n i += 1\\n\\n if ds in [\\\"paco_lvis\\\", \\\"pascal_part\\\"]:\\n masks = []\\n for category_id in sampled_anns:\\n try:\\n cur_anns = anns_category2instances[category_id]\\n cur_mask = None\\n for ann in cur_anns:\\n if cur_mask is None:\\n cur_mask = coco_api.annToMask(ann)\\n else:\\n cur_mask = cur_mask | coco_api.annToMask(ann)\\n assert cur_mask is not None\\n masks.append(cur_mask)\\n except Exception as e:\\n print(e)\\n return self.__getitem__(0)\\n\\n masks = np.stack(masks, axis=0)\\n masks = torch.from_numpy(masks)\\n label = torch.ones(masks.shape[1], masks.shape[2]) * self.ignore_label\\n elif ds in ['objects365']:\\n masks = torch.rand(len(bboxes_labels), *original_size)\\n label = torch.ones(original_size) * self.ignore_label\\n masks_valid = [0]*len(bboxes_labels)\\n else:\\n label = torch.from_numpy(label).long()\\n masks = []\\n for class_id in class_ids:\\n masks.append(label == class_id)\\n masks = torch.stack(masks, dim=0)\\n return (\\n image_path,\\n image,\\n image_clip,\\n conversations,\\n masks,\\n label,\\n bboxes_labels,\\n bboxes_valid,\\n masks_valid,\\n resize,\\n questions,\\n sampled_classes,\\n )\"\n },\n {\n \"identifier\": \"MixedGroundingDataset\",\n \"path\": \"VisualSearch/utils/mixed_grounding_dataset.py\",\n \"snippet\": \"class MixedGroundingDataset(torch.utils.data.Dataset):\\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\\n img_size = 1024\\n ignore_label = 255\\n\\n def __init__(\\n self,\\n base_dir,\\n tokenizer,\\n vision_tower,\\n samples_per_epoch=500 * 8 * 2 * 10,\\n precision: str = \\\"fp32\\\",\\n num_classes_per_sample: int = 3,\\n exclude_val=False,\\n ):\\n self.samples_per_epoch = samples_per_epoch\\n self.num_classes_per_sample = num_classes_per_sample\\n\\n self.base_dir = base_dir\\n self.tokenizer = tokenizer\\n self.precision = precision\\n self.transform = OwlViTProcessor.from_pretrained(\\\"google/owlvit-base-patch16\\\")\\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\\n\\n self.short_question_list = SHORT_QUESTION_LIST\\n self.answer_list = ANSWER_LIST\\n\\n with open(os.path.join(base_dir, 'MixedGrounding', 'goldG_train.json')) as f:\\n self.images = json.load(f)\\n\\n def __len__(self):\\n return self.samples_per_epoch\\n\\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"Normalize pixel values and pad to a square input.\\\"\\\"\\\"\\n # Normalize colors\\n x = (x - self.pixel_mean) / self.pixel_std\\n\\n # Pad\\n h, w = x.shape[-2:]\\n padh = self.img_size - h\\n padw = self.img_size - w\\n x = F.pad(x, (0, padw, 0, padh))\\n return x\\n\\n def __getitem__(self, idx):\\n\\n idx = random.randint(0, len(self.images) - 1)\\n image_info = self.images[idx]\\n image_data_source = image_info['data_source']\\n file_name = image_info[\\\"file_name\\\"]\\n assert image_data_source in ['coco', 'vg', 'flickr']\\n if image_data_source == 'coco':\\n image_path = os.path.join(self.base_dir, 'coco2014/train2014', file_name)\\n elif image_data_source == 'vg':\\n image_path = os.path.join(self.base_dir, 'MixedGrounding/GQA/images', file_name)\\n else:\\n image_path = os.path.join(self.base_dir, 'MixedGrounding/flickr30k-images', file_name)\\n caption = image_info['caption']\\n instances = image_info['instances']\\n if len(instances) == 0:\\n return self.__getitem__(0)\\n\\n if len(instances) >= self.num_classes_per_sample:\\n sampled_inds = np.random.choice(\\n list(range(len(instances))), size=self.num_classes_per_sample, replace=False\\n )\\n else:\\n sampled_inds = list(range(len(instances)))\\n\\n sampled_classes = sampled_inds\\n \\n image = cv2.imread(image_path)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n\\n # preprocess image for clip\\n image_clip = self.clip_image_processor.preprocess(\\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\\\"pt\\\")[\\\"pixel_values\\\"][0]\\n original_size = image.shape[:2]\\n image = self.transform(images=image, return_tensors=\\\"pt\\\")['pixel_values'][0]\\n resize = image.shape[:2]\\n\\n questions = []\\n answers = []\\n bboxes_labels = []\\n for sample_ind in sampled_inds:\\n text = []\\n tokens_positive = instances[sample_ind]['tokens_positive']\\n for token in tokens_positive:\\n text.append(caption[token[0]:token[1]])\\n text = \\\" \\\".join(text)\\n text = text.strip()\\n question_template = random.choice(self.short_question_list)\\n questions.append(question_template.format(class_name=text.lower()))\\n answers.append(random.choice(self.answer_list))\\n\\n cur_bboxes = [instances[sample_ind]['bbox']]\\n cur_bboxes = torch.tensor(cur_bboxes).view(-1, 4)\\n # xywh to x1y1x2y2\\n cur_bboxes[:, 2:] += cur_bboxes[:, :2]\\n cur_bboxes[:, 0::2].clamp_(min=0, max=original_size[1])\\n cur_bboxes[:, 1::2].clamp_(min=0, max=original_size[0])\\n keep = (cur_bboxes[:, 3] > cur_bboxes[:, 1]) & (cur_bboxes[:, 2] > cur_bboxes[:, 0])\\n cur_bboxes = cur_bboxes[keep]\\n cur_bboxes = box_xyxy_to_cxcywh(cur_bboxes)\\n cur_bboxes = cur_bboxes / torch.tensor([original_size[1], original_size[0], original_size[1], original_size[0]], dtype=torch.float32)\\n if len(cur_bboxes) == 0:\\n return self.__getitem__(0)\\n bboxes_labels.append(cur_bboxes)\\n\\n conversations = []\\n conv = conversation_lib.default_conversation.copy()\\n\\n i = 0\\n while i < len(questions):\\n conv.messages = []\\n conv.append_message(conv.roles[0], questions[i])\\n conv.append_message(conv.roles[1], answers[i])\\n conversations.append(conv.get_prompt())\\n i += 1\\n \\n bboxes_valid = [1]*len(bboxes_labels)\\n masks_valid = [0]*len(bboxes_labels)\\n masks = torch.rand(len(bboxes_labels), *original_size)\\n label = torch.ones(original_size) * self.ignore_label\\n\\n return (\\n image_path,\\n image,\\n image_clip,\\n conversations,\\n masks,\\n label,\\n bboxes_labels,\\n bboxes_valid,\\n masks_valid,\\n resize,\\n questions,\\n sampled_classes,\\n )\"\n },\n {\n \"identifier\": \"VQADataset\",\n \"path\": \"VisualSearch/utils/vqa_dataset.py\",\n \"snippet\": \"class VQADataset(torch.utils.data.Dataset):\\n pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\\n pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\\n img_size = 1024\\n ignore_label = 255\\n\\n def __init__(\\n self,\\n base_image_dir,\\n tokenizer,\\n vision_tower,\\n samples_per_epoch=500 * 8 * 2 * 10,\\n precision: str = \\\"fp32\\\",\\n num_classes_per_sample: int = 3,\\n exclude_val=False,\\n vqa_data=\\\"possible_locations_conv_86k||llava_instruct_150k\\\",\\n vqa_sample_rate=[2,1],\\n ):\\n self.exclude_val = exclude_val\\n self.samples_per_epoch = samples_per_epoch\\n self.num_classes_per_sample = num_classes_per_sample\\n\\n self.base_image_dir = base_image_dir\\n self.tokenizer = tokenizer\\n self.precision = precision\\n self.transform = OwlViTProcessor.from_pretrained(\\\"google/owlvit-base-patch16\\\")\\n self.clip_image_processor = CLIPImageProcessor.from_pretrained(vision_tower)\\n\\n DATA_DIR = os.path.join(base_image_dir, \\\"vsm_vqa_data\\\")\\n self.vqa_image_root = os.path.join(base_image_dir, \\\"coco2017/train2017\\\")\\n vqa_datas = vqa_data.split(\\\"||\\\")\\n self.vqa_datas = []\\n for data in vqa_datas:\\n with open(os.path.join(DATA_DIR, \\\"{}.json\\\".format(data))) as f:\\n data = json.load(f)\\n self.vqa_datas.append(data)\\n sample_rate = np.array(vqa_sample_rate)\\n self.sample_rate = sample_rate / sample_rate.sum()\\n\\n def __len__(self):\\n return self.samples_per_epoch\\n\\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"Normalize pixel values and pad to a square input.\\\"\\\"\\\"\\n # Normalize colors\\n x = (x - self.pixel_mean) / self.pixel_std\\n\\n # Pad\\n h, w = x.shape[-2:]\\n padh = self.img_size - h\\n padw = self.img_size - w\\n x = F.pad(x, (0, padw, 0, padh))\\n return x\\n\\n def __getitem__(self, idx):\\n ds = np.random.choice(list(range(len(self.vqa_datas))), p=self.sample_rate)\\n ds = self.vqa_datas[ds]\\n idx = random.randint(0, len(ds) - 1)\\n item = ds[idx]\\n image_path = os.path.join(self.vqa_image_root, item[\\\"image\\\"])\\n image = cv2.imread(image_path)\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n ori_size = image.shape[:2]\\n image_clip = self.clip_image_processor.preprocess(\\n expand2square(Image.open(image_path).convert('RGB'), tuple(int(x*255) for x in self.clip_image_processor.image_mean)), return_tensors=\\\"pt\\\")[\\\"pixel_values\\\"][0]\\n\\n image = self.transform(images=image, return_tensors=\\\"pt\\\")['pixel_values'][0]\\n resize = image.shape[:2]\\n\\n conv = conversation_lib.default_conversation.copy()\\n source = item[\\\"conversations\\\"]\\n source = preprocess_multimodal(\\n copy.deepcopy(source),\\n mm_use_im_start_end=conv.sep_style == conversation_lib.SeparatorStyle.TWO,\\n )\\n roles = {\\\"human\\\": conv.roles[0], \\\"gpt\\\": conv.roles[1]}\\n conversations = []\\n if roles[source[0][\\\"from\\\"]] != conv.roles[0]:\\n # Skip the first one if it is not from human\\n source = source[1:]\\n conv.messages = []\\n for j, sentence in enumerate(source):\\n role = roles[sentence[\\\"from\\\"]]\\n assert role == conv.roles[j % 2], f\\\"{j}\\\"\\n conv.append_message(role, sentence[\\\"value\\\"])\\n conversations.append(conv.get_prompt())\\n\\n questions = conversations\\n sampled_classes = conversations\\n\\n masks = torch.rand(1, *ori_size)\\n label = torch.ones(ori_size) * self.ignore_label\\n bboxes_labels = [torch.tensor([[0.5,0.5,1.0,1.0]])]\\n bboxes_valid = [0]\\n masks_valid = [0]\\n\\n return (\\n image_path,\\n image,\\n image_clip,\\n conversations,\\n masks,\\n label,\\n bboxes_labels,\\n bboxes_valid,\\n masks_valid,\\n resize,\\n questions,\\n sampled_classes,\\n )\"\n },\n {\n \"identifier\": \"DEFAULT_IM_END_TOKEN\",\n \"path\": \"VisualSearch/utils/utils.py\",\n \"snippet\": \"DEFAULT_IM_END_TOKEN = \\\"<im_end>\\\"\"\n },\n {\n \"identifier\": \"DEFAULT_IM_START_TOKEN\",\n \"path\": \"VisualSearch/utils/utils.py\",\n \"snippet\": \"DEFAULT_IM_START_TOKEN = \\\"<im_start>\\\"\"\n },\n {\n \"identifier\": \"DEFAULT_IMAGE_TOKEN\",\n \"path\": \"VisualSearch/utils/utils.py\",\n \"snippet\": \"DEFAULT_IMAGE_TOKEN = \\\"<image>\\\"\"\n },\n {\n \"identifier\": \"box_xyxy_to_cxcywh\",\n \"path\": \"VisualSearch/utils/utils.py\",\n \"snippet\": \"def box_xyxy_to_cxcywh(x):\\n x0, y0, x1, y1 = x.unbind(-1)\\n b = [(x0 + x1) / 2, (y0 + y1) / 2,\\n (x1 - x0), (y1 - y0)]\\n return torch.stack(b, dim=-1)\"\n },\n {\n \"identifier\": \"expand2square\",\n \"path\": \"VisualSearch/utils/utils.py\",\n \"snippet\": \"def expand2square(pil_img, background_color):\\n width, height = pil_img.size\\n if width == height:\\n return pil_img\\n elif width > height:\\n result = Image.new(pil_img.mode, (width, width), background_color)\\n result.paste(pil_img, (0, 0))\\n return result\\n else:\\n result = Image.new(pil_img.mode, (height, height), background_color)\\n result.paste(pil_img, (0, 0))\\n return result\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import glob\nimport os\nimport random\nimport cv2\nimport numpy as np\nimport torch\nimport torch.nn.functional as F\nfrom PIL import Image\nfrom pycocotools import mask\nfrom transformers import CLIPImageProcessor\nfrom transformers import OwlViTProcessor\nfrom VisualSearch.model.llava import conversation as conversation_lib\nfrom VisualSearch.model.llava.constants import (DEFAULT_IMAGE_TOKEN, IGNORE_INDEX,\n\t\t\t\t\t\t\t\t IMAGE_TOKEN_INDEX)\nfrom VisualSearch.model.llava.mm_utils import tokenizer_image_token\nfrom VisualSearch.utils.data_processing import get_mask_from_json\nfrom VisualSearch.utils.refer import REFER\nfrom VisualSearch.utils.refer_seg_dataset import ReferSegDataset\nfrom VisualSearch.utils.general_segdet_dataset import SegDetDataset\nfrom VisualSearch.utils.mixed_grounding_dataset import MixedGroundingDataset\nfrom VisualSearch.utils.vqa_dataset import VQADataset\nfrom VisualSearch.utils.utils import (DEFAULT_IM_END_TOKEN, DEFAULT_IM_START_TOKEN,\n\t\t\t\t\tDEFAULT_IMAGE_TOKEN)\nfrom VisualSearch.utils.utils import box_xyxy_to_cxcywh, expand2square"},"token_num":{"kind":"number","value":16059,"string":"16,059"},"cropped_code":{"kind":"string","value":"\t\tself,\n\t\tbase_dir,\n\t\ttokenizer,\n\t\tvision_tower,\n\t\tsamples_per_epoch=500 * 8 * 2 * 10,\n\t\tprecision: str = \"fp32\",\n\t\tnum_classes_per_sample: int = 3,\n\t\texclude_val=False,\n\t\tdataset=\"general_segdet||refer_seg||vqa||reason_seg\",\n\t\tsample_rate=[9, 3, 3, 1],\n\t\tgeneral_segdet_data=\"objects365||cocostuff||paco_lvis\",\n\t\tgeneral_segdet_sample_rate=[2,1,1],\n\t\trefer_seg_data=\"refclef||refcoco||refcoco+||refcocog\",\n\t\tvqa_data=\"possible_locations_conv_86k||llava_instruct_80k\",\n\t\tvqa_sample_rate=[2,1],\n\t):\n\t\tself.exclude_val = exclude_val\n\t\tself.dataset = dataset\n\t\tself.samples_per_epoch = samples_per_epoch\n\t\tself.num_classes_per_sample = num_classes_per_sample\n\t\tsample_rate = np.array(sample_rate)\n\t\tself.sample_rate = sample_rate / sample_rate.sum()\n\n\t\tself.base_dir = base_dir\n\t\tself.tokenizer = tokenizer\n\t\tself.precision = precision\n\n\t\tself.datasets = dataset.split(\"||\")\n\n\t\tself.all_datasets = []\n\t\tfor dataset in self.datasets:\n\t\t\tif dataset == \"general_segdet\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tSegDetDataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t\tgeneral_segdet_data,\n\t\t\t\t\t\tgeneral_segdet_sample_rate,\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\telif dataset == \"refer_seg\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tReferSegDataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t\trefer_seg_data,\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\telif dataset == \"vqa\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tVQADataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t\tvqa_data,\n\t\t\t\t\t\tvqa_sample_rate,\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\telif dataset == \"mixed_grounding\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tMixedGroundingDataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t)\n\t\t\t\t)\n\n\tdef __len__(self):\n\t\treturn self.samples_per_epoch\n\n\tdef __getitem__(self, idx):\n\t\tind = np.random.choice(list(range(len(self.datasets))), p=self.sample_rate)\n\t\tdata = self.all_datasets[ind]\n\t\tinference = False\n\t\treturn *data[0], inference\n\n\nclass ValDataset(torch.utils.data.Dataset):\n\tpixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n\tpixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n\timg_size = 1024\n\tignore_label = 255\n\n\tdef __init__(\n\t\tself,\n\t\tbase_dir,\n\t\ttokenizer,\n\t\tvision_tower,\n\t\tval_dataset,\n\t):\n\t\tself.base_dir = base_dir\n\t\tsplits = val_dataset.split(\"|\")\n\t\tif len(splits) == 2:\n\t\t\tds, split = splits\n\t\t\timages = glob.glob(\n\t\t\t\tos.path.join(self.base_dir, \"reason_seg\", ds, split, \"*.jpg\")\n\t\t\t)\n\t\t\tself.images = images\n\t\t\tself.data_type = \"reason_seg\"\n\t\telif len(splits) == 3:\n\t\t\tself.base_dir = os.path.join(self.base_dir, 'refer_seg')\n\t\t\tds, splitBy, split = splits\n"},"all_code":{"kind":"string","value":"cv2.setNumThreads(1)\n\n\n\n\ndef collate_fn(\n\tbatch, tokenizer=None, conv_type=\"llava_v1\", use_mm_start_end=True, local_rank=-1\n):\n\timage_path_list = []\n\timages_list = []\n\timages_clip_list = []\n\tconversation_list = []\n\tmasks_list = []\n\tlabel_list = []\n\tbboxes_labels_list = []\n\tbboxes_valid_list = []\n\tmasks_valid_list = []\n\tresize_list = []\n\tquestions_list = []\n\tsampled_classes_list = []\n\toffset_list = [0]\n\tcnt = 0\n\tinferences = []\n\tfor (\n\t\timage_path,\n\t\timages,\n\t\timages_clip,\n\t\tconversations,\n\t\tmasks,\n\t\tlabel,\n\t\tbboxes_labels,\n\t\tbboxes_valid,\n\t\tmasks_valid,\n\t\tresize,\n\t\tquestions,\n\t\tsampled_classes,\n\t\tinference,\n\t) in batch:\n\t\timage_path_list.append(image_path)\n\t\timages_list.append(images)\n\t\timages_clip_list.append(images_clip)\n\t\tconversation_list.extend(conversations)\n\t\tlabel_list.append(label)\n\t\tmasks_list.append(masks.float())\n\t\tbboxes_labels_list.extend(bboxes_labels)\n\t\tbboxes_valid_list.extend(bboxes_valid)\n\t\tmasks_valid_list.append(torch.tensor(masks_valid))\n\t\tresize_list.append(resize)\n\t\tquestions_list.append(questions)\n\t\tsampled_classes_list.append(sampled_classes)\n\t\tcnt += len(conversations)\n\t\toffset_list.append(cnt)\n\t\tinferences.append(inference)\n\n\tif use_mm_start_end:\n\t\t# replace <image> token\n\t\tfor i in range(len(conversation_list)):\n\t\t\treplace_token = DEFAULT_IMAGE_TOKEN\n\t\t\treplace_token = (\n\t\t\t\tDEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN\n\t\t\t)\n\t\t\tconversation_list[i] = conversation_list[i].replace(\n\t\t\t\tDEFAULT_IMAGE_TOKEN, replace_token\n\t\t\t)\n\tinput_ids = [\n\t\ttokenizer_image_token(prompt, tokenizer, return_tensors=\"pt\")\n\t\tfor prompt in conversation_list\n\t]\n\tinput_ids = torch.nn.utils.rnn.pad_sequence(\n\t\tinput_ids, batch_first=True, padding_value=tokenizer.pad_token_id\n\t)\n\tattention_masks = input_ids.ne(tokenizer.pad_token_id)\n\n\tfor i in range(len(bboxes_valid_list)):\n\t\tbboxes_valid = bboxes_valid_list[i]\n\t\tattention_mask = attention_masks[i]\n\t\tif not bboxes_valid:\n\t\t\tattention_mask = attention_mask & input_ids[i].ne(tokenizer(\"[LOC]\", add_special_tokens=False).input_ids[0])\n\t\t\tattention_masks[i] = attention_mask\n\n\tconv = conversation_lib.default_conversation.copy()\n\ttargets = input_ids.clone()\n\n\tif conv_type == \"llava_v1\":\n\t\tsep = conv.sep + conv.roles[1] + \": \"\n\telse:\n\t\tsep = \"[/INST] \"\n\tfor conversation, target in zip(conversation_list, targets):\n\t\ttotal_len = int(target.ne(tokenizer.pad_token_id).sum())\n\n\t\trounds = conversation.split(conv.sep2)\n\t\tcur_len = 1\n\t\ttarget[:cur_len] = IGNORE_INDEX\n\t\tfor i, rou in enumerate(rounds):\n\t\t\tif rou == \"\":\n\t\t\t\tbreak\n\n\t\t\tparts = rou.split(sep)\n\t\t\t# if len(parts) != 2:\n\t\t\t# break\n\t\t\tassert len(parts) == 2, (len(parts), rou)\n\t\t\tparts[0] += sep\n\n\t\t\tif DEFAULT_IMAGE_TOKEN in conversation:\n\t\t\t\tround_len = len(tokenizer_image_token(rou, tokenizer))\n\t\t\t\tinstruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2\n\t\t\telse:\n\t\t\t\tround_len = len(tokenizer(rou).input_ids)\n\t\t\t\tinstruction_len = len(tokenizer(parts[0]).input_ids) - 2\n\n\t\t\ttarget[cur_len : cur_len + instruction_len] = IGNORE_INDEX\n\n\t\t\tcur_len += round_len\n\t\ttarget[cur_len:] = IGNORE_INDEX\n\n\t\tif False:\n\t\t\tz = target.clone()\n\t\t\tz = torch.where(z == IGNORE_INDEX, tokenizer.unk_token_id, z)\n\t\t\tif local_rank == 0:\n\t\t\t\tprint(\n\t\t\t\t\t\"conversation: \",\n\t\t\t\t\tconversation,\n\t\t\t\t\t\"tokenizer.decode(z): \",\n\t\t\t\t\ttokenizer.decode(z),\n\t\t\t\t)\n\n\t\tif cur_len < tokenizer.model_max_length:\n\t\t\tassert cur_len == total_len\n\n\tif inferences[0] == False:\n\t\ttruncate_len = tokenizer.model_max_length - 255\n\n\t\tif input_ids.shape[1] > truncate_len:\n\t\t\tinput_ids = input_ids[:, :truncate_len]\n\t\t\ttargets = targets[:, :truncate_len]\n\t\t\tattention_masks = attention_masks[:, :truncate_len]\n\n\treturn {\n\t\t\"image_paths\": image_path_list,\n\t\t\"images\": torch.stack(images_list, dim=0),\n\t\t\"images_clip\": torch.stack(images_clip_list, dim=0),\n\t\t\"input_ids\": input_ids,\n\t\t\"labels\": targets,\n\t\t\"bboxes_labels_list\": bboxes_labels_list,\n\t\t\"bboxes_valid_list\": torch.tensor(bboxes_valid_list),\n\t\t\"masks_valid_list\": masks_valid_list,\n\t\t\"attention_masks\": attention_masks,\n\t\t\"masks_list\": masks_list,\n\t\t\"label_list\": label_list,\n\t\t\"resize_list\": resize_list,\n\t\t\"offset\": torch.LongTensor(offset_list),\n\t\t\"questions_list\": questions_list,\n\t\t\"sampled_classes_list\": sampled_classes_list,\n\t\t\"inference\": inferences[0],\n\t\t\"conversation_list\": conversation_list,\n\t}\n\n\nclass HybridDataset(torch.utils.data.Dataset):\n\tpixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n\tpixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n\timg_size = 1024\n\tignore_label = 255\n\n\tdef __init__(\n\t\tself,\n\t\tbase_dir,\n\t\ttokenizer,\n\t\tvision_tower,\n\t\tsamples_per_epoch=500 * 8 * 2 * 10,\n\t\tprecision: str = \"fp32\",\n\t\tnum_classes_per_sample: int = 3,\n\t\texclude_val=False,\n\t\tdataset=\"general_segdet||refer_seg||vqa||reason_seg\",\n\t\tsample_rate=[9, 3, 3, 1],\n\t\tgeneral_segdet_data=\"objects365||cocostuff||paco_lvis\",\n\t\tgeneral_segdet_sample_rate=[2,1,1],\n\t\trefer_seg_data=\"refclef||refcoco||refcoco+||refcocog\",\n\t\tvqa_data=\"possible_locations_conv_86k||llava_instruct_80k\",\n\t\tvqa_sample_rate=[2,1],\n\t):\n\t\tself.exclude_val = exclude_val\n\t\tself.dataset = dataset\n\t\tself.samples_per_epoch = samples_per_epoch\n\t\tself.num_classes_per_sample = num_classes_per_sample\n\t\tsample_rate = np.array(sample_rate)\n\t\tself.sample_rate = sample_rate / sample_rate.sum()\n\n\t\tself.base_dir = base_dir\n\t\tself.tokenizer = tokenizer\n\t\tself.precision = precision\n\n\t\tself.datasets = dataset.split(\"||\")\n\n\t\tself.all_datasets = []\n\t\tfor dataset in self.datasets:\n\t\t\tif dataset == \"general_segdet\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tSegDetDataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t\tgeneral_segdet_data,\n\t\t\t\t\t\tgeneral_segdet_sample_rate,\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\telif dataset == \"refer_seg\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tReferSegDataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t\trefer_seg_data,\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\telif dataset == \"vqa\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tVQADataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t\tvqa_data,\n\t\t\t\t\t\tvqa_sample_rate,\n\t\t\t\t\t)\n\t\t\t\t)\n\t\t\telif dataset == \"mixed_grounding\":\n\t\t\t\tself.all_datasets.append(\n\t\t\t\t\tMixedGroundingDataset(\n\t\t\t\t\t\tbase_dir,\n\t\t\t\t\t\ttokenizer,\n\t\t\t\t\t\tvision_tower,\n\t\t\t\t\t\tsamples_per_epoch,\n\t\t\t\t\t\tprecision,\n\t\t\t\t\t\tnum_classes_per_sample,\n\t\t\t\t\t\texclude_val,\n\t\t\t\t\t)\n\t\t\t\t)\n\n\tdef __len__(self):\n\t\treturn self.samples_per_epoch\n\n\tdef __getitem__(self, idx):\n\t\tind = np.random.choice(list(range(len(self.datasets))), p=self.sample_rate)\n\t\tdata = self.all_datasets[ind]\n\t\tinference = False\n\t\treturn *data[0], inference\n\n\nclass ValDataset(torch.utils.data.Dataset):\n\tpixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)\n\tpixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)\n\timg_size = 1024\n\tignore_label = 255\n\n\tdef __init__(\n\t\tself,\n\t\tbase_dir,\n\t\ttokenizer,\n\t\tvision_tower,\n\t\tval_dataset,\n\t):\n\t\tself.base_dir = base_dir\n\t\tsplits = val_dataset.split(\"|\")\n\t\tif len(splits) == 2:\n\t\t\tds, split = splits\n\t\t\timages = glob.glob(\n\t\t\t\tos.path.join(self.base_dir, \"reason_seg\", ds, split, \"*.jpg\")\n\t\t\t)\n\t\t\tself.images = images\n\t\t\tself.data_type = \"reason_seg\"\n\t\telif len(splits) == 3:\n\t\t\tself.base_dir = os.path.join(self.base_dir, 'refer_seg')\n\t\t\tds, splitBy, split = splits"},"next_line":{"kind":"string","value":"\t\t\trefer_api = REFER(self.base_dir, ds, splitBy)"},"gold_snippet_index":{"kind":"number","value":6,"string":"6"},"created_at":{"kind":"string","value":"2023-12-15 14:58:24+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5670,"cells":{"repo_name":{"kind":"string","value":"sinoyou/nelf-pro"},"file_path":{"kind":"string","value":"nerfstudio/viewer/server/viewer_utils.py"},"context":{"kind":"list like","value":[{"identifier":"Cameras","path":"nerfstudio/cameras/cameras.py","snippet":"class Cameras(TensorDataclass):\n \"\"\"Dataparser outputs for the image dataset and the ray generator.\n\n Note: currently only supports cameras with the same principal points and types. The reason we type\n the focal lengths, principal points, and image sizes as tensors is to allow for batched cameras\n down the line in cases where your batches of camera data don't come from the same cameras.\n\n If a single value is provided, it is broadcasted to all cameras.\n\n Args:\n camera_to_worlds: Camera to world matrices. Tensor of per-image c2w matrices, in [R | t] format\n fx: Focal length x\n fy: Focal length y\n cx: Principal point x\n cy: Principal point y\n width: Image width\n height: Image height\n distortion_params: OpenCV 6 radial distortion coefficients\n camera_type: Type of camera model. This will be an int corresponding to the CameraType enum.\n times: Timestamps for each camera\n probe_config: dict config containing the generated probe information (core and basis)\n \"\"\"\n\n camera_to_worlds: TensorType[\"num_cameras\":..., 3, 4]\n fx: TensorType[\"num_cameras\":..., 1]\n fy: TensorType[\"num_cameras\":..., 1]\n cx: TensorType[\"num_cameras\":..., 1]\n cy: TensorType[\"num_cameras\":..., 1]\n width: TensorType[\"num_cameras\":..., 1]\n height: TensorType[\"num_cameras\":..., 1]\n distortion_params: Optional[TensorType[\"num_cameras\":..., 6]]\n camera_type: TensorType[\"num_cameras\":..., 1]\n times: Optional[TensorType[\"num_cameras\":..., 1]]\n image_filenames: Optional[List[str]]\n probe_config: Optional[list]\n\n def __init__(\n self,\n camera_to_worlds: TensorType[\"batch_c2ws\":..., 3, 4],\n fx: Union[TensorType[\"batch_fxs\":..., 1], float],\n fy: Union[TensorType[\"batch_fys\":..., 1], float],\n cx: Union[TensorType[\"batch_cxs\":..., 1], float],\n cy: Union[TensorType[\"batch_cys\":..., 1], float],\n width: Optional[Union[TensorType[\"batch_ws\":..., 1], int]] = None,\n height: Optional[Union[TensorType[\"batch_hs\":..., 1], int]] = None,\n distortion_params: Optional[TensorType[\"batch_dist_params\":..., 6]] = None,\n camera_type: Optional[\n Union[\n TensorType[\"batch_cam_types\":..., 1],\n int,\n List[CameraType],\n CameraType,\n ]\n ] = CameraType.PERSPECTIVE,\n times: Optional[TensorType[\"num_cameras\"]] = None,\n image_filenames: Optional[List[str]] = None,\n probe_config: Optional[list] = None\n ):\n \"\"\"Initializes the Cameras object.\n\n Note on Input Tensor Dimensions: All of these tensors have items of dimensions TensorType[3, 4]\n (in the case of the c2w matrices), TensorType[6] (in the case of distortion params), or\n TensorType[1] (in the case of the rest of the elements). The dimensions before that are\n considered the batch dimension of that tensor (batch_c2ws, batch_fxs, etc.). We will broadcast\n all the tensors to be the same batch dimension. This means you can use any combination of the\n input types in the function signature and it won't break. Your batch size for all tensors\n must be broadcastable to the same size, and the resulting number of batch dimensions will be\n the batch dimension with the largest number of dimensions.\n \"\"\"\n\n # This will notify the tensordataclass that we have a field with more than 1 dimension\n self._field_custom_dimensions = {\"camera_to_worlds\": 2}\n\n self.camera_to_worlds = camera_to_worlds\n\n # fx fy calculation\n self.fx = self._init_get_fc_xy(fx, \"fx\") # @dataclass's post_init will take care of broadcasting\n self.fy = self._init_get_fc_xy(fy, \"fy\") # @dataclass's post_init will take care of broadcasting\n\n # cx cy calculation\n self.cx = self._init_get_fc_xy(cx, \"cx\") # @dataclass's post_init will take care of broadcasting\n self.cy = self._init_get_fc_xy(cy, \"cy\") # @dataclass's post_init will take care of broadcasting\n\n # Distortion Params Calculation:\n self.distortion_params = distortion_params # @dataclass's post_init will take care of broadcasting\n\n # @dataclass's post_init will take care of broadcasting\n self.height = self._init_get_height_width(height, self.cy)\n self.width = self._init_get_height_width(width, self.cx)\n self.camera_type = self._init_get_camera_type(camera_type)\n self.times = self._init_get_times(times)\n \n self.image_filenames = image_filenames\n self.probe_config = probe_config\n if self.probe_config is not None:\n self.probe = Probes(self.camera_to_worlds, self.probe_config)\n else:\n self.probe = None\n \n self.__post_init__() # This will do the dataclass post_init and broadcast all the tensors\n\n def _init_get_fc_xy(self, fc_xy, name):\n \"\"\"\n Parses the input focal length / principle point x or y and returns a tensor of the correct shape\n\n Only needs to make sure that we a 1 in the last dimension if it is a tensor. If it is a float, we\n just need to make it into a tensor and it will be broadcasted later in the __post_init__ function.\n\n Args:\n fc_xy: The focal length / principle point x or y\n name: The name of the variable. Used for error messages\n \"\"\"\n if isinstance(fc_xy, float):\n fc_xy = torch.Tensor([fc_xy], device=self.device)\n elif isinstance(fc_xy, torch.Tensor):\n if fc_xy.ndim == 0 or fc_xy.shape[-1] != 1:\n fc_xy = fc_xy.unsqueeze(-1)\n fc_xy = fc_xy.to(self.device)\n else:\n raise ValueError(f\"{name} must be a float or tensor, got {type(fc_xy)}\")\n return fc_xy\n\n def _init_get_camera_type(\n self,\n camera_type: Union[\n TensorType[\"batch_cam_types\":..., 1], TensorType[\"batch_cam_types\":...], int, List[CameraType], CameraType\n ],\n ) -> TensorType[\"num_cameras\":..., 1]:\n \"\"\"\n Parses the __init__() argument camera_type\n\n Camera Type Calculation:\n If CameraType, convert to int and then to tensor, then broadcast to all cameras\n If List of CameraTypes, convert to ints and then to tensor, then broadcast to all cameras\n If int, first go to tensor and then broadcast to all cameras\n If tensor, broadcast to all cameras\n\n Args:\n camera_type: camera_type argument from __init__()\n \"\"\"\n if isinstance(camera_type, CameraType):\n camera_type = torch.tensor([camera_type.value], device=self.device)\n elif isinstance(camera_type, List) and isinstance(camera_type[0], CameraType):\n camera_type = torch.tensor([[c.value] for c in camera_type], device=self.device)\n elif isinstance(camera_type, int):\n camera_type = torch.tensor([camera_type], device=self.device)\n elif isinstance(camera_type, torch.Tensor):\n assert not torch.is_floating_point(\n camera_type\n ), f\"camera_type tensor must be of type int, not: {camera_type.dtype}\"\n camera_type = camera_type.to(self.device)\n if camera_type.ndim == 0 or camera_type.shape[-1] != 1:\n camera_type = camera_type.unsqueeze(-1)\n # assert torch.all(\n # camera_type.view(-1)[0] == camera_type\n # ), \"Batched cameras of different camera_types will be allowed in the future.\"\n else:\n raise ValueError(\n 'Invalid camera_type. Must be CameraType, List[CameraType], int, or torch.Tensor[\"num_cameras\"]. \\\n Received: '\n + str(type(camera_type))\n )\n return camera_type\n\n def _init_get_height_width(\n self,\n h_w: Union[TensorType[\"batch_hws\":..., 1], TensorType[\"batch_hws\":...], int, None],\n c_x_y: TensorType[\"batch_cxys\":...],\n ) -> TensorType[\"num_cameras\":..., 1]:\n \"\"\"\n Parses the __init__() argument for height or width\n\n Height/Width Calculation:\n If int, first go to tensor and then broadcast to all cameras\n If tensor, broadcast to all cameras\n If none, use cx or cy * 2\n Else raise error\n\n Args:\n h_w: height or width argument from __init__()\n c_x_y: cx or cy for when h_w == None\n \"\"\"\n if isinstance(h_w, int):\n h_w = torch.Tensor([h_w]).to(torch.int64).to(self.device)\n elif isinstance(h_w, torch.Tensor):\n assert not torch.is_floating_point(h_w), f\"height and width tensor must be of type int, not: {h_w.dtype}\"\n h_w = h_w.to(torch.int64).to(self.device)\n if h_w.ndim == 0 or h_w.shape[-1] != 1:\n h_w = h_w.unsqueeze(-1)\n # assert torch.all(h_w == h_w.view(-1)[0]), \"Batched cameras of different h, w will be allowed in the future.\"\n elif h_w is None:\n h_w = torch.Tensor((c_x_y * 2).to(torch.int64).to(self.device))\n else:\n raise ValueError(\"Height must be an int, tensor, or None, received: \" + str(type(h_w)))\n return h_w\n\n def _init_get_times(self, times):\n if times is None:\n times = None\n elif isinstance(times, torch.Tensor):\n if times.ndim == 0 or times.shape[-1] != 1:\n times = times.unsqueeze(-1).to(self.device)\n else:\n raise ValueError(f\"times must be None or a tensor, got {type(times)}\")\n\n return times\n\n @property\n def device(self):\n \"\"\"Returns the device that the camera is on.\"\"\"\n return self.camera_to_worlds.device\n\n @property\n def image_height(self) -> TensorType[\"num_cameras\":..., 1]:\n \"\"\"Returns the height of the images.\"\"\"\n return self.height\n\n @property\n def image_width(self) -> TensorType[\"num_cameras\":..., 1]:\n \"\"\"Returns the height of the images.\"\"\"\n return self.width\n\n @property\n def is_jagged(self):\n \"\"\"\n Returns whether or not the cameras are \"jagged\" (i.e. the height and widths are different, meaning that\n you cannot concatenate the image coordinate maps together)\n \"\"\"\n h_jagged = not torch.all(self.height == self.height.view(-1)[0])\n w_jagged = not torch.all(self.width == self.width.view(-1)[0])\n return h_jagged or w_jagged\n\n def get_image_coords(\n self, pixel_offset: float = 0.5, index: Optional[Tuple] = None\n ) -> TensorType[\"height\", \"width\", 2]:\n \"\"\"This gets the image coordinates of one of the cameras in this object.\n\n If no index is specified, it will return the maximum possible sized height / width image coordinate map,\n by looking at the maximum height and width of all the cameras in this object.\n\n Args:\n pixel_offset: Offset for each pixel. Defaults to center of pixel (0.5)\n index: Tuple of indices into the batch dimensions of the camera. Defaults to None, which returns the 0th\n flattened camera\n\n Returns:\n Grid of image coordinates.\n \"\"\"\n if index is None:\n image_height = torch.max(self.image_height.view(-1))\n image_width = torch.max(self.image_width.view(-1))\n image_coords = torch.meshgrid(torch.arange(image_height), torch.arange(image_width), indexing=\"ij\")\n image_coords = torch.stack(image_coords, dim=-1) + pixel_offset # stored as (y, x) coordinates\n else:\n image_height = self.image_height[index].item()\n image_width = self.image_width[index].item()\n image_coords = torch.meshgrid(torch.arange(image_height), torch.arange(image_width), indexing=\"ij\")\n image_coords = torch.stack(image_coords, dim=-1) + pixel_offset # stored as (y, x) coordinates\n return image_coords\n\n def generate_rays( # pylint: disable=too-many-statements\n self,\n camera_indices: Union[TensorType[\"num_rays\":..., \"num_cameras_batch_dims\"], int],\n coords: Optional[TensorType[\"num_rays\":..., 2]] = None,\n camera_opt_to_camera: Optional[TensorType[\"num_rays\":..., 3, 4]] = None,\n distortion_params_delta: Optional[TensorType[\"num_rays\":..., 6]] = None,\n keep_shape: Optional[bool] = None,\n disable_distortion: bool = False,\n ) -> RayBundle:\n \"\"\"Generates rays for the given camera indices.\n\n This function will standardize the input arguments and then call the _generate_rays_from_coords function\n to generate the rays. Our goal is to parse the arguments and then get them into the right shape:\n - camera_indices: (num_rays:..., num_cameras_batch_dims)\n - coords: (num_rays:..., 2)\n - camera_opt_to_camera: (num_rays:..., 3, 4) or None\n - distortion_params_delta: (num_rays:..., 6) or None\n\n Read the docstring for _generate_rays_from_coords for more information on how we generate the rays\n after we have standardized the arguments.\n\n We are only concerned about different combinations of camera_indices and coords matrices, and the following\n are the 4 cases we have to deal with:\n 1. isinstance(camera_indices, int) and coords == None\n - In this case we broadcast our camera_indices / coords shape (h, w, 1 / 2 respectively)\n 2. isinstance(camera_indices, int) and coords != None\n - In this case, we broadcast camera_indices to the same batch dim as coords\n 3. not isinstance(camera_indices, int) and coords == None\n - In this case, we will need to set coords so that it is of shape (h, w, num_rays, 2), and broadcast\n all our other args to match the new definition of num_rays := (h, w) + num_rays\n 4. not isinstance(camera_indices, int) and coords != None\n - In this case, we have nothing to do, only check that the arguments are of the correct shape\n\n There is one more edge case we need to be careful with: when we have \"jagged cameras\" (ie: different heights\n and widths for each camera). This isn't problematic when we specify coords, since coords is already a tensor.\n When coords == None (ie: when we render out the whole image associated with this camera), we run into problems\n since there's no way to stack each coordinate map as all coordinate maps are all different shapes. In this case,\n we will need to flatten each individual coordinate map and concatenate them, giving us only one batch dimension,\n regaurdless of the number of prepended extra batch dimensions in the camera_indices tensor.\n\n\n Args:\n camera_indices: Camera indices of the flattened cameras object to generate rays for.\n coords: Coordinates of the pixels to generate rays for. If None, the full image will be rendered.\n camera_opt_to_camera: Optional transform for the camera to world matrices.\n distortion_params_delta: Optional delta for the distortion parameters.\n keep_shape: If None, then we default to the regular behavior of flattening if cameras is jagged, otherwise\n keeping dimensions. If False, we flatten at the end. If True, then we keep the shape of the\n camera_indices and coords tensors (if we can).\n disable_distortion: If True, disables distortion.\n\n Returns:\n Rays for the given camera indices and coords.\n \"\"\"\n # Check the argument types to make sure they're valid and all shaped correctly\n assert isinstance(camera_indices, (torch.Tensor, int)), \"camera_indices must be a tensor or int\"\n assert coords is None or isinstance(coords, torch.Tensor), \"coords must be a tensor or None\"\n assert camera_opt_to_camera is None or isinstance(camera_opt_to_camera, torch.Tensor)\n assert distortion_params_delta is None or isinstance(distortion_params_delta, torch.Tensor)\n if isinstance(camera_indices, torch.Tensor) and isinstance(coords, torch.Tensor):\n num_rays_shape = camera_indices.shape[:-1]\n errormsg = \"Batch dims of inputs must match when inputs are all tensors\"\n assert coords.shape[:-1] == num_rays_shape, errormsg\n assert camera_opt_to_camera is None or camera_opt_to_camera.shape[:-2] == num_rays_shape, errormsg\n assert distortion_params_delta is None or distortion_params_delta.shape[:-1] == num_rays_shape, errormsg\n\n # If zero dimensional, we need to unsqueeze to get a batch dimension and then squeeze later\n if not self.shape:\n cameras = self.reshape((1,))\n assert torch.all(\n torch.tensor(camera_indices == 0) if isinstance(camera_indices, int) else camera_indices == 0\n ), \"Can only index into single camera with no batch dimensions if index is zero\"\n else:\n cameras = self\n\n # If the camera indices are an int, then we need to make sure that the camera batch is 1D\n if isinstance(camera_indices, int):\n assert (\n len(cameras.shape) == 1\n ), \"camera_indices must be a tensor if cameras are batched with more than 1 batch dimension\"\n camera_indices = torch.tensor([camera_indices], device=cameras.device)\n\n assert camera_indices.shape[-1] == len(\n cameras.shape\n ), \"camera_indices must have shape (num_rays:..., num_cameras_batch_dims)\"\n\n # If keep_shape is True, then we need to make sure that the camera indices in question\n # are all the same height and width and can actually be batched while maintaining the image\n # shape\n if keep_shape is True:\n assert torch.all(cameras.height[camera_indices] == cameras.height[camera_indices[0]]) and torch.all(\n cameras.width[camera_indices] == cameras.width[camera_indices[0]]\n ), \"Can only keep shape if all cameras have the same height and width\"\n\n # If the cameras don't all have same height / width, if coords is not none, we will need to generate\n # a flat list of coords for each camera and then concatenate otherwise our rays will be jagged.\n # Camera indices, camera_opt, and distortion will also need to be broadcasted accordingly which is non-trivial\n if cameras.is_jagged and coords is None and (keep_shape is None or keep_shape is False):\n index_dim = camera_indices.shape[-1]\n camera_indices = camera_indices.reshape(-1, index_dim)\n _coords = [cameras.get_image_coords(index=tuple(index)).reshape(-1, 2) for index in camera_indices]\n camera_indices = torch.cat(\n [index.unsqueeze(0).repeat(coords.shape[0], 1) for index, coords in zip(camera_indices, _coords)],\n )\n coords = torch.cat(_coords, dim=0)\n assert coords.shape[0] == camera_indices.shape[0]\n # Need to get the coords of each indexed camera and flatten all coordinate maps and concatenate them\n\n # The case where we aren't jagged && keep_shape (since otherwise coords is already set) and coords\n # is None. In this case we append (h, w) to the num_rays dimensions for all tensors. In this case,\n # each image in camera_indices has to have the same shape since otherwise we would have error'd when\n # we checked keep_shape is valid or we aren't jagged.\n if coords is None:\n index_dim = camera_indices.shape[-1]\n index = camera_indices.reshape(-1, index_dim)[0]\n coords: torch.Tensor = cameras.get_image_coords(index=tuple(index)) # (h, w, 2)\n coords = coords.reshape(coords.shape[:2] + (1,) * len(camera_indices.shape[:-1]) + (2,)) # (h, w, 1..., 2)\n coords = coords.expand(coords.shape[:2] + camera_indices.shape[:-1] + (2,)) # (h, w, num_rays, 2)\n camera_opt_to_camera = ( # (h, w, num_rays, 3, 4) or None\n camera_opt_to_camera.broadcast_to(coords.shape[:-1] + (3, 4))\n if camera_opt_to_camera is not None\n else None\n )\n distortion_params_delta = ( # (h, w, num_rays, 6) or None\n distortion_params_delta.broadcast_to(coords.shape[:-1] + (6,))\n if distortion_params_delta is not None\n else None\n )\n\n # If camera indices was an int or coords was none, we need to broadcast our indices along batch dims\n camera_indices = camera_indices.broadcast_to(coords.shape[:-1] + (len(cameras.shape),)).to(torch.long)\n\n # Checking our tensors have been standardized\n assert isinstance(coords, torch.Tensor) and isinstance(camera_indices, torch.Tensor)\n assert camera_indices.shape[-1] == len(cameras.shape)\n assert camera_opt_to_camera is None or camera_opt_to_camera.shape[:-2] == coords.shape[:-1]\n assert distortion_params_delta is None or distortion_params_delta.shape[:-1] == coords.shape[:-1]\n\n # This will do the actual work of generating the rays now that we have standardized the inputs\n # raybundle.shape == (num_rays) when done\n # pylint: disable=protected-access\n raybundle = cameras._generate_rays_from_coords(\n camera_indices, coords, camera_opt_to_camera, distortion_params_delta, disable_distortion=disable_distortion\n )\n\n # If we have mandated that we don't keep the shape, then we flatten\n if keep_shape is False:\n raybundle = raybundle.flatten()\n\n # TODO: We should have to squeeze the last dimension here if we started with zero batch dims, but never have to,\n # so there might be a rogue squeeze happening somewhere, and this may cause some unintended behaviour\n # that we haven't caught yet with tests\n return raybundle\n\n # pylint: disable=too-many-statements\n def _generate_rays_from_coords(\n self,\n camera_indices: TensorType[\"num_rays\":..., \"num_cameras_batch_dims\"],\n coords: TensorType[\"num_rays\":..., 2],\n camera_opt_to_camera: Optional[TensorType[\"num_rays\":..., 3, 4]] = None,\n distortion_params_delta: Optional[TensorType[\"num_rays\":..., 6]] = None,\n disable_distortion: bool = False,\n ) -> RayBundle:\n \"\"\"Generates rays for the given camera indices and coords where self isn't jagged\n\n This is a fairly complex function, so let's break this down slowly.\n\n Shapes involved:\n - num_rays: This is your output raybundle shape. It dictates the number and shape of the rays generated\n - num_cameras_batch_dims: This is the number of dimensions of our camera\n\n Args:\n camera_indices: Camera indices of the flattened cameras object to generate rays for.\n The shape of this is such that indexing into camera_indices[\"num_rays\":...] will return the\n index into each batch dimension of the camera in order to get the correct camera specified by\n \"num_rays\".\n Example:\n >>> cameras = Cameras(...)\n >>> cameras.shape\n (2, 3, 4)\n >>> camera_indices = torch.tensor([0, 0, 0]) # We need an axis of length 3 since cameras.ndim == 3\n >>> camera_indices.shape\n (3,)\n >>> coords = torch.tensor([1,1])\n >>> coords.shape\n (2,)\n >>> out_rays = cameras.generate_rays(camera_indices=camera_indices, coords = coords)\n # This will generate a RayBundle with a single ray for the\n # camera at cameras[0,0,0] at image coordinates (1,1), so out_rays.shape == ()\n >>> out_rays.shape\n ()\n >>> camera_indices = torch.tensor([[0,0,0]])\n >>> camera_indices.shape\n (1, 3)\n >>> coords = torch.tensor([[1,1]])\n >>> coords.shape\n (1, 2)\n >>> out_rays = cameras.generate_rays(camera_indices=camera_indices, coords = coords)\n # This will generate a RayBundle with a single ray for the\n # camera at cameras[0,0,0] at point (1,1), so out_rays.shape == (1,)\n # since we added an extra dimension in front of camera_indices\n >>> out_rays.shape\n (1,)\n\n If you want more examples, check tests/cameras/test_cameras and the function check_generate_rays_shape\n\n The bottom line is that for camera_indices: (num_rays:..., num_cameras_batch_dims), num_rays is the\n output shape and if you index into the output RayBundle with some indices [i:...], if you index into\n camera_indices with camera_indices[i:...] as well, you will get a 1D tensor containing the batch\n indices into the original cameras object corresponding to that ray (ie: you will get the camera\n from our batched cameras corresponding to the ray at RayBundle[i:...]).\n\n coords: Coordinates of the pixels to generate rays for. If None, the full image will be rendered, meaning\n height and width get prepended to the num_rays dimensions. Indexing into coords with [i:...] will\n get you the image coordinates [x, y] of that specific ray located at output RayBundle[i:...].\n\n camera_opt_to_camera: Optional transform for the camera to world matrices.\n In terms of shape, it follows the same rules as coords, but indexing into it with [i:...] gets you\n the 2D camera to world transform matrix for the camera optimization at RayBundle[i:...].\n\n distortion_params_delta: Optional delta for the distortion parameters.\n In terms of shape, it follows the same rules as coords, but indexing into it with [i:...] gets you\n the 1D tensor with the 6 distortion parameters for the camera optimization at RayBundle[i:...].\n\n disable_distortion: If True, disables distortion.\n\n Returns:\n Rays for the given camera indices and coords. RayBundle.shape == num_rays\n \"\"\"\n # Make sure we're on the right devices\n camera_indices = camera_indices.to(self.device)\n coords = coords.to(self.device)\n\n # Checking to make sure everything is of the right shape and type\n num_rays_shape = camera_indices.shape[:-1]\n assert camera_indices.shape == num_rays_shape + (self.ndim,)\n assert coords.shape == num_rays_shape + (2,)\n assert coords.shape[-1] == 2\n assert camera_opt_to_camera is None or camera_opt_to_camera.shape == num_rays_shape + (3, 4)\n assert distortion_params_delta is None or distortion_params_delta.shape == num_rays_shape + (6,)\n\n # Here, we've broken our indices down along the num_cameras_batch_dims dimension allowing us to index by all\n # of our output rays at each dimension of our cameras object\n true_indices = [camera_indices[..., i] for i in range(camera_indices.shape[-1])]\n\n # Get all our focal lengths, principal points and make sure they are the right shapes\n y = coords[..., 0] # (num_rays,) get rid of the last dimension\n x = coords[..., 1] # (num_rays,) get rid of the last dimension\n fx, fy = self.fx[true_indices].squeeze(-1), self.fy[true_indices].squeeze(-1) # (num_rays,)\n cx, cy = self.cx[true_indices].squeeze(-1), self.cy[true_indices].squeeze(-1) # (num_rays,)\n assert (\n y.shape == num_rays_shape\n and x.shape == num_rays_shape\n and fx.shape == num_rays_shape\n and fy.shape == num_rays_shape\n and cx.shape == num_rays_shape\n and cy.shape == num_rays_shape\n ), (\n str(num_rays_shape)\n + str(y.shape)\n + str(x.shape)\n + str(fx.shape)\n + str(fy.shape)\n + str(cx.shape)\n + str(cy.shape)\n )\n\n # Get our image coordinates and image coordinates offset by 1 (offsets used for dx, dy calculations)\n # Also make sure the shapes are correct\n coord = torch.stack([(x - cx) / fx, -(y - cy) / fy], -1) # (num_rays, 2)\n coord_x_offset = torch.stack([(x - cx + 1) / fx, -(y - cy) / fy], -1) # (num_rays, 2)\n coord_y_offset = torch.stack([(x - cx) / fx, -(y - cy + 1) / fy], -1) # (num_rays, 2)\n assert (\n coord.shape == num_rays_shape + (2,)\n and coord_x_offset.shape == num_rays_shape + (2,)\n and coord_y_offset.shape == num_rays_shape + (2,)\n )\n\n # Stack image coordinates and image coordinates offset by 1, check shapes too\n coord_stack = torch.stack([coord, coord_x_offset, coord_y_offset], dim=0) # (3, num_rays, 2)\n assert coord_stack.shape == (3,) + num_rays_shape + (2,)\n\n # Undistorts our images according to our distortion parameters\n if not disable_distortion:\n distortion_params = None\n if self.distortion_params is not None:\n distortion_params = self.distortion_params[true_indices]\n if distortion_params_delta is not None:\n distortion_params = distortion_params + distortion_params_delta\n elif distortion_params_delta is not None:\n distortion_params = distortion_params_delta\n\n # Do not apply distortion for equirectangular images\n if distortion_params is not None:\n mask = (self.camera_type[true_indices] != CameraType.EQUIRECTANGULAR.value).squeeze(-1) # (num_rays)\n coord_mask = torch.stack([mask, mask, mask], dim=0)\n if mask.any():\n coord_stack[coord_mask, :] = camera_utils.radial_and_tangential_undistort(\n coord_stack[coord_mask, :].reshape(3, -1, 2),\n distortion_params[mask, :],\n ).reshape(-1, 2)\n\n # Make sure after we have undistorted our images, the shapes are still correct\n assert coord_stack.shape == (3,) + num_rays_shape + (2,)\n\n # Gets our directions for all our rays in camera coordinates and checks shapes at the end\n # Here, directions_stack is of shape (3, num_rays, 3)\n # directions_stack[0] is the direction for ray in camera coordinates\n # directions_stack[1] is the direction for ray in camera coordinates offset by 1 in x\n # directions_stack[2] is the direction for ray in camera coordinates offset by 1 in y\n cam_types = torch.unique(self.camera_type, sorted=False)\n directions_stack = torch.empty((3,) + num_rays_shape + (3,), device=self.device)\n if CameraType.PERSPECTIVE.value in cam_types:\n mask = (self.camera_type[true_indices] == CameraType.PERSPECTIVE.value).squeeze(-1) # (num_rays)\n mask = torch.stack([mask, mask, mask], dim=0)\n directions_stack[..., 0][mask] = torch.masked_select(coord_stack[..., 0], mask).float()\n directions_stack[..., 1][mask] = torch.masked_select(coord_stack[..., 1], mask).float()\n directions_stack[..., 2][mask] = -1.0\n\n if CameraType.FISHEYE.value in cam_types:\n mask = (self.camera_type[true_indices] == CameraType.FISHEYE.value).squeeze(-1) # (num_rays)\n mask = torch.stack([mask, mask, mask], dim=0)\n\n theta = torch.sqrt(torch.sum(coord_stack**2, dim=-1))\n theta = torch.clip(theta, 0.0, math.pi)\n\n sin_theta = torch.sin(theta)\n\n directions_stack[..., 0][mask] = torch.masked_select(coord_stack[..., 0] * sin_theta / theta, mask).float()\n directions_stack[..., 1][mask] = torch.masked_select(coord_stack[..., 1] * sin_theta / theta, mask).float()\n directions_stack[..., 2][mask] = -torch.masked_select(torch.cos(theta), mask)\n\n if CameraType.EQUIRECTANGULAR.value in cam_types:\n mask = (self.camera_type[true_indices] == CameraType.EQUIRECTANGULAR.value).squeeze(-1) # (num_rays)\n mask = torch.stack([mask, mask, mask], dim=0)\n\n # For equirect, fx = fy = height = width/2\n # Then coord[..., 0] goes from -1 to 1 and coord[..., 1] goes from -1/2 to 1/2\n theta = -torch.pi * coord_stack[..., 0] # minus sign for right-handed\n phi = torch.pi * (0.5 - coord_stack[..., 1])\n # use spherical in local camera coordinates (+y up, x=0 and z<0 is theta=0)\n directions_stack[..., 0][mask] = torch.masked_select(-torch.sin(theta) * torch.sin(phi), mask).float()\n directions_stack[..., 1][mask] = torch.masked_select(torch.cos(phi), mask).float()\n directions_stack[..., 2][mask] = torch.masked_select(-torch.cos(theta) * torch.sin(phi), mask).float()\n\n for value in cam_types:\n if value not in [CameraType.PERSPECTIVE.value, CameraType.FISHEYE.value, CameraType.EQUIRECTANGULAR.value]:\n raise ValueError(f\"Camera type {value} not supported.\")\n\n assert directions_stack.shape == (3,) + num_rays_shape + (3,)\n\n c2w = self.camera_to_worlds[true_indices]\n assert c2w.shape == num_rays_shape + (3, 4)\n\n if camera_opt_to_camera is not None:\n c2w = pose_utils.multiply(c2w, camera_opt_to_camera)\n rotation = c2w[..., :3, :3] # (..., 3, 3)\n assert rotation.shape == num_rays_shape + (3, 3)\n\n directions_stack = torch.sum(\n directions_stack[..., None, :] * rotation, dim=-1\n ) # (..., 1, 3) * (..., 3, 3) -> (..., 3)\n\n directions_norm = torch.norm(directions_stack, dim=-1, keepdim=True)\n directions_norm = directions_norm[0]\n\n directions_stack = normalize(directions_stack, dim=-1)\n assert directions_stack.shape == (3,) + num_rays_shape + (3,)\n\n origins = c2w[..., :3, 3] # (..., 3)\n assert origins.shape == num_rays_shape + (3,)\n\n directions = directions_stack[0]\n assert directions.shape == num_rays_shape + (3,)\n\n # norms of the vector going between adjacent coords, giving us dx and dy per output ray\n dx = torch.sqrt(torch.sum((directions - directions_stack[1]) ** 2, dim=-1)) # (\"num_rays\":...,)\n dy = torch.sqrt(torch.sum((directions - directions_stack[2]) ** 2, dim=-1)) # (\"num_rays\":...,)\n assert dx.shape == num_rays_shape and dy.shape == num_rays_shape\n\n pixel_area = (dx * dy)[..., None] # (\"num_rays\":..., 1)\n assert pixel_area.shape == num_rays_shape + (1,)\n\n times = self.times[camera_indices, 0] if self.times is not None else None\n\n\n return RayBundle(\n origins=origins,\n directions=directions,\n pixel_area=pixel_area,\n camera_indices=camera_indices,\n directions_norm=directions_norm,\n times=times,\n probes=self.probe,\n )\n\n def to_json(\n self, camera_idx: int, image: Optional[TensorType[\"height\", \"width\", 2]] = None, max_size: Optional[int] = None\n ) -> Dict:\n \"\"\"Convert a camera to a json dictionary.\n\n Args:\n camera_idx: Index of the camera to convert.\n image: An image in range [0, 1] that is encoded to a base64 string.\n max_size: Max size to resize the image to if present.\n\n Returns:\n A JSON representation of the camera\n \"\"\"\n flattened = self.flatten()\n json_ = {\n \"type\": \"PinholeCamera\",\n \"cx\": flattened[camera_idx].cx.item(),\n \"cy\": flattened[camera_idx].cy.item(),\n \"fx\": flattened[camera_idx].fx.item(),\n \"fy\": flattened[camera_idx].fy.item(),\n \"camera_to_world\": self.camera_to_worlds[camera_idx].tolist(),\n \"camera_index\": camera_idx,\n \"times\": flattened[camera_idx].times.item() if self.times is not None else None,\n }\n if image is not None:\n image_uint8 = (image * 255).detach().type(torch.uint8)\n if max_size is not None:\n image_uint8 = image_uint8.permute(2, 0, 1)\n image_uint8 = torchvision.transforms.functional.resize(image_uint8, max_size) # type: ignore\n image_uint8 = image_uint8.permute(1, 2, 0)\n image_uint8 = image_uint8.cpu().numpy()\n data = cv2.imencode(\".jpg\", image_uint8)[1].tobytes()\n json_[\"image\"] = str(\"data:image/jpeg;base64,\" + base64.b64encode(data).decode(\"ascii\"))\n return json_\n\n def get_intrinsics_matrices(self) -> TensorType[\"num_cameras\":..., 3, 3]:\n \"\"\"Returns the intrinsic matrices for each camera.\n\n Returns:\n Pinhole camera intrinsics matrices\n \"\"\"\n K = torch.zeros((*self.shape, 3, 3), dtype=torch.float32)\n K[..., 0, 0] = self.fx.squeeze(-1)\n K[..., 1, 1] = self.fy.squeeze(-1)\n K[..., 0, 2] = self.cx.squeeze(-1)\n K[..., 1, 2] = self.cy.squeeze(-1)\n K[..., 2, 2] = 1.0\n return K\n\n def rescale_output_resolution(\n self,\n scaling_factor: Union[TensorType[\"num_cameras\":...], TensorType[\"num_cameras\":..., 1], float, int],\n round_hw=False,\n ) -> None:\n \"\"\"Rescale the output resolution of the cameras.\n\n Args:\n scaling_factor: Scaling factor to apply to the output resolution.\n round_hw: Whether to round the height and width to the nearest integer.\n \"\"\"\n if isinstance(scaling_factor, (float, int)):\n scaling_factor = torch.tensor([scaling_factor]).to(self.device).broadcast_to((self.cx.shape))\n elif isinstance(scaling_factor, torch.Tensor) and scaling_factor.shape == self.shape:\n scaling_factor = scaling_factor.unsqueeze(-1)\n elif isinstance(scaling_factor, torch.Tensor) and scaling_factor.shape == (*self.shape, 1):\n pass\n else:\n raise ValueError(\n f\"Scaling factor must be a float, int, or a tensor of shape {self.shape} or {(*self.shape, 1)}.\"\n )\n\n self.fx = self.fx * scaling_factor\n self.fy = self.fy * scaling_factor\n self.cx = self.cx * scaling_factor\n self.cy = self.cy * scaling_factor\n if not round_hw:\n self.height = (self.height * scaling_factor).to(torch.int64)\n self.width = (self.width * scaling_factor).to(torch.int64)\n else:\n self.height = torch.floor(self.height * scaling_factor + 0.5).to(torch.int64)\n self.width = torch.floor(self.width * scaling_factor + 0.5).to(torch.int64)\n\n def get_plotly(self, camera_group):\n\n # define local necssary coordinates for plotting\n num_cameras = self.camera_to_worlds.shape[0]\n _cam_center_c = np.array([[.0, .0, .0]]).repeat(num_cameras, axis=0)\n _cam_forward_c = np.array([[.0, .0, -1.0]]).repeat(num_cameras, axis=0)\n _cam_up_c = np.array([[.0, 1.0, .0]]).repeat(num_cameras, axis=0)\n _cam_right_c = np.array([[1.0, .0, .0]]).repeat(num_cameras, axis=0)\n\n _pyramid_width = self.width.cpu().numpy() / self.fx.cpu().numpy()\n _pyramid_height = self.height.cpu().numpy() / self.fy.cpu().numpy()\n\n _cam_pyramid_ur = np.concatenate([_pyramid_width/2, _pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\n _cam_pyramid_dr = np.concatenate([_pyramid_width/2, -_pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\n _cam_pyramid_ul = np.concatenate([-_pyramid_width/2, _pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\n _cam_pyramid_dl = np.concatenate([-_pyramid_width/2, -_pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\n\n _local_coordinates = {\n 'center': _cam_center_c, \n 'forward': _cam_forward_c, \n 'up': _cam_up_c, \n 'right': _cam_right_c, \n 'pyramid_ur': _cam_pyramid_ur, \n 'pyramid_dr': _cam_pyramid_dr, \n 'pyramid_ul': _cam_pyramid_ul, \n 'pyramid_dl': _cam_pyramid_dl, \n }\n\n # transform it into world coordinates\n data = {}\n for k in _local_coordinates.keys():\n _local_coor_homo = np.concatenate([_local_coordinates[k].reshape(-1, 3) * plotly_camera_scale, np.ones((num_cameras, 1))], axis=-1) # num_cam, 4\n _cw = self.camera_to_worlds.cpu().numpy() # num_cam, 3, 4\n\n _homo = np.einsum('ijk,ik->ij', _cw, _local_coor_homo) # num_cam, 3\n data[k] = _homo[:, :3]\n\n plot_data = plot_camera_components(data, image_list=self.image_filenames, camera_group=camera_group)\n \n if isinstance(plot_data, list):\n return plot_data\n else:\n return [plot_data]"},{"identifier":"RayBundle","path":"nerfstudio/cameras/rays.py","snippet":"class RayBundle(TensorDataclass):\n \"\"\"A bundle of ray parameters.\"\"\"\n\n # TODO(ethan): make sure the sizes with ... are correct\n origins: TensorType[..., 3]\n \"\"\"Ray origins (XYZ)\"\"\"\n directions: TensorType[..., 3]\n \"\"\"Unit ray direction vector\"\"\"\n pixel_area: TensorType[..., 1]\n \"\"\"Projected area of pixel a distance 1 away from origin\"\"\"\n directions_norm: Optional[TensorType[..., 1]] = None\n \"\"\"Norm of ray direction vector before normalization\"\"\"\n camera_indices: Optional[TensorType[..., 1]] = None\n \"\"\"Camera indices\"\"\"\n nears: Optional[TensorType[..., 1]] = None\n \"\"\"Distance along ray to start sampling\"\"\"\n fars: Optional[TensorType[..., 1]] = None\n \"\"\"Rays Distance along ray to stop sampling\"\"\"\n metadata: Optional[Dict[str, TensorType[\"num_rays\", \"latent_dims\"]]] = None\n \"\"\"Additional metadata or data needed for interpolation, will mimic shape of rays\"\"\"\n times: Optional[TensorType[..., 1]] = None\n \"\"\"Times at which rays are sampled\"\"\"\n probes: Optional[Probes] = None\n \"\"\"Probe Cameras Object. This object doesn't follow the same shape pattern as the other fields. \n Lazy broadcasting is used for preventing CUDA memory overflow. \"\"\"\n\n def set_camera_indices(self, camera_index: int) -> None:\n \"\"\"Sets all of the the camera indices to a specific camera index.\n\n Args:\n camera_index: Camera index.\n \"\"\"\n self.camera_indices = torch.ones_like(self.origins[..., 0:1]).long() * camera_index\n\n def __len__(self):\n num_rays = torch.numel(self.origins) // self.origins.shape[-1]\n return num_rays\n\n def sample(self, num_rays: int) -> \"RayBundle\":\n \"\"\"Returns a RayBundle as a subset of rays.\n\n Args:\n num_rays: Number of rays in output RayBundle\n\n Returns:\n RayBundle with subset of rays.\n \"\"\"\n assert num_rays <= len(self)\n indices = random.sample(range(len(self)), k=num_rays)\n return self[indices]\n\n def get_row_major_sliced_ray_bundle(self, start_idx: int, end_idx: int) -> \"RayBundle\":\n \"\"\"Flattens RayBundle and extracts chunk given start and end indicies.\n\n Args:\n start_idx: Start index of RayBundle chunk.\n end_idx: End index of RayBundle chunk.\n\n Returns:\n Flattened RayBundle with end_idx-start_idx rays.\n\n \"\"\"\n return self.flatten()[start_idx:end_idx]\n\n def get_ray_samples(\n self,\n bin_starts: TensorType[\"bs\":..., \"num_samples\", 1],\n bin_ends: TensorType[\"bs\":..., \"num_samples\", 1],\n spacing_starts: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None,\n spacing_ends: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None,\n spacing_to_euclidean_fn: Optional[Callable] = None,\n ) -> RaySamples:\n \"\"\"Produces samples for each ray by projection points along the ray direction. Currently samples uniformly.\n\n Args:\n bin_starts: Distance from origin to start of bin. (in Euclidean space)\n bin_ends: Distance from origin to end of bin. (in Euclidean space)\n spacing_starts: start point in normalized space. [0, 1]\n spacing_ends: end point in normalized space. [0, 1]\n\n Returns:\n Samples projected along ray.\n \"\"\"\n deltas = bin_ends - bin_starts\n if self.camera_indices is not None:\n camera_indices = self.camera_indices[..., None]\n else:\n camera_indices = None\n\n shaped_raybundle_fields = self[..., None]\n\n frustums = Frustums(\n origins=shaped_raybundle_fields.origins, # [..., 1, 3]\n directions=shaped_raybundle_fields.directions, # [..., 1, 3]\n starts=bin_starts, # [..., num_samples, 1]\n ends=bin_ends, # [..., num_samples, 1]\n pixel_area=shaped_raybundle_fields.pixel_area, # [..., 1, 1]\n )\n\n ray_samples = RaySamples(\n frustums=frustums,\n camera_indices=camera_indices, # [..., 1, 1]\n deltas=deltas, # [..., num_samples, 1]\n spacing_starts=spacing_starts, # [..., num_samples, 1]\n spacing_ends=spacing_ends, # [..., num_samples, 1]\n spacing_to_euclidean_fn=spacing_to_euclidean_fn,\n metadata=shaped_raybundle_fields.metadata,\n times=None if self.times is None else self.times[..., None], # [..., 1, 1]\n probes=self.probes, # special class, not following the same shape pattern\n )\n\n return ray_samples"},{"identifier":"base_config","path":"nerfstudio/configs/base_config.py","snippet":"CONSOLE = Console(width=120)\nclass PrintableConfig: # pylint: disable=too-few-public-methods\nclass InstantiateConfig(PrintableConfig): # pylint: disable=too-few-public-methods\nclass MachineConfig(PrintableConfig):\nclass LocalWriterConfig(InstantiateConfig):\nclass LoggingConfig(PrintableConfig):\nclass TrainerConfig(PrintableConfig):\nclass ViewerConfig(PrintableConfig):\nclass Config(PrintableConfig):\n def __str__(self):\n def setup(self, **kwargs) -> Any:\n def setup(self, banner_messages: Optional[List[str]] = None, **kwargs) -> Any:\n def is_viewer_enabled(self) -> bool:\n def is_wandb_enabled(self) -> bool:\n def is_tensorboard_enabled(self) -> bool:\n def set_timestamp(self) -> None:\n def set_experiment_name(self) -> None:\n def get_base_dir(self) -> Path:\n def get_checkpoint_dir(self) -> Path:\n def print_to_terminal(self) -> None:\n def save_config(self) -> None:"},{"identifier":"InputDataset","path":"nerfstudio/data/datasets/base_dataset.py","snippet":"class InputDataset(Dataset):\n \"\"\"Dataset that returns images.\n\n Args:\n dataparser_outputs: description of where and how to read input images.\n scale_factor: The scaling factor for the dataparser outputs\n \"\"\"\n\n def __init__(self, dataparser_outputs: DataparserOutputs, scale_factor: float = 1.0):\n super().__init__()\n self._dataparser_outputs = dataparser_outputs\n self.has_masks = dataparser_outputs.mask_filenames is not None\n self.scale_factor = scale_factor\n self.scene_box = deepcopy(dataparser_outputs.scene_box)\n self.metadata = deepcopy(dataparser_outputs.metadata)\n self.cameras = deepcopy(dataparser_outputs.cameras)\n self.cameras.rescale_output_resolution(scaling_factor=scale_factor)\n self.image_cache = {}\n\n def __len__(self):\n return len(self._dataparser_outputs.image_filenames)\n\n def get_numpy_image(self, image_idx: int) -> npt.NDArray[np.uint8]:\n \"\"\"Returns the image of shape (H, W, 3 or 4).\n\n Args:\n image_idx: The image index in the dataset.\n \"\"\"\n image_filename = self._dataparser_outputs.image_filenames[image_idx]\n pil_image = Image.open(image_filename)\n if self.scale_factor != 1.0:\n width, height = pil_image.size\n newsize = (int(width * self.scale_factor), int(height * self.scale_factor))\n pil_image = pil_image.resize(newsize, resample=Image.BILINEAR)\n image = np.array(pil_image, dtype=\"uint8\") # shape is (h, w, 3 or 4)\n # mask_filename = str(image_filename).replace(\"dense/images\", \"masks\").replace(\".jpg\", \".npy\")\n # mask = np.load(mask_filename)\n # image = image * mask[..., None]\n\n assert len(image.shape) == 3\n assert image.dtype == np.uint8\n assert image.shape[2] in [3, 4], f\"Image shape of {image.shape} is in correct.\"\n return image\n\n def get_image(self, image_idx: int) -> TensorType[\"image_height\", \"image_width\", \"num_channels\"]:\n \"\"\"Returns a 3 channel image.\n\n Args:\n image_idx: The image index in the dataset.\n \"\"\"\n image = torch.from_numpy(self.get_numpy_image(image_idx).astype(\"float32\") / 255.0)\n if self._dataparser_outputs.alpha_color is not None and image.shape[-1] == 4:\n assert image.shape[-1] == 4\n image = image[:, :, :3] * image[:, :, -1:] + self._dataparser_outputs.alpha_color * (1.0 - image[:, :, -1:])\n else:\n image = image[:, :, :3]\n return image\n\n def get_data(self, image_idx: int) -> Dict:\n \"\"\"Returns the ImageDataset data as a dictionary.\n\n Args:\n image_idx: The image index in the dataset.\n \"\"\"\n if image_idx in self.image_cache:\n image = self.image_cache[image_idx]\n else:\n image = self.get_image(image_idx)\n self.image_cache[image_idx] = image\n\n data = {\"image_idx\": image_idx, 'image_filename': self._dataparser_outputs.image_filenames[image_idx].name}\n data[\"image\"] = image\n for _, data_func_dict in self._dataparser_outputs.additional_inputs.items():\n assert \"func\" in data_func_dict, \"Missing function to process data: specify `func` in `additional_inputs`\"\n func = data_func_dict[\"func\"]\n assert \"kwargs\" in data_func_dict, \"No data to process: specify `kwargs` in `additional_inputs`\"\n data.update(func(image_idx, **data_func_dict[\"kwargs\"]))\n if self.has_masks:\n mask_filepath = self._dataparser_outputs.mask_filenames[image_idx]\n data[\"mask\"] = get_image_mask_tensor_from_path(filepath=mask_filepath, scale_factor=self.scale_factor)\n metadata = self.get_metadata(data)\n data.update(metadata)\n return data\n\n # pylint: disable=no-self-use\n def get_metadata(self, data: Dict) -> Dict:\n \"\"\"Method that can be used to process any additional metadata that may be part of the model inputs.\n\n Args:\n image_idx: The image index in the dataset.\n \"\"\"\n del data\n return {}\n\n def __getitem__(self, image_idx: int) -> Dict:\n data = self.get_data(image_idx)\n return data"},{"identifier":"Model","path":"nerfstudio/models/base_model.py","snippet":"class Model(nn.Module):\n \"\"\"Model class\n Where everything (Fields, Optimizers, Samplers, Visualization, etc) is linked together. This should be\n subclassed for custom NeRF model.\n\n Args:\n config: configuration for instantiating model\n scene_box: dataset scene box\n \"\"\"\n\n config: ModelConfig\n\n def __init__(\n self,\n config: ModelConfig,\n scene_box: SceneBox,\n num_train_data: int,\n world_size: int = 1,\n local_rank: int = 0,\n load_step: int = None, \n **kwargs,\n ) -> None:\n super().__init__()\n self.config = config\n self.scene_box = scene_box\n self.num_train_data = num_train_data\n self.kwargs = kwargs\n self.collider = None\n self.world_size = world_size\n self.local_rank = local_rank\n self.load_step = load_step\n\n self.populate_modules() # populate the modules\n self.callbacks = None\n # to keep track of which device the nn.Module is on\n self.device_indicator_param = nn.Parameter(torch.empty(0))\n\n @property\n def device(self):\n \"\"\"Returns the device that the model is on.\"\"\"\n return self.device_indicator_param.device\n\n def get_training_callbacks( # pylint:disable=no-self-use\n self, training_callback_attributes: TrainingCallbackAttributes # pylint: disable=unused-argument\n ) -> List[TrainingCallback]:\n \"\"\"Returns a list of callbacks that run functions at the specified training iterations.\"\"\"\n return []\n\n def populate_modules(self):\n \"\"\"Set the necessary modules to get the network working.\"\"\"\n # default instantiates optional modules that are common among many networks\n # NOTE: call `super().populate_modules()` in subclasses\n\n if self.config.enable_collider:\n self.collider = NearFarCollider(\n near_plane=self.config.collider_params[\"near_plane\"], far_plane=self.config.collider_params[\"far_plane\"]\n )\n\n @abstractmethod\n def get_param_groups(self) -> Dict[str, List[Parameter]]:\n \"\"\"Obtain the parameter groups for the optimizers\n\n Returns:\n Mapping of different parameter groups\n \"\"\"\n\n @abstractmethod\n def get_outputs(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\n \"\"\"Takes in a Ray Bundle and returns a dictionary of outputs.\n\n Args:\n ray_bundle: Input bundle of rays. This raybundle should have all the\n needed information to compute the outputs.\n\n Returns:\n Outputs of model. (ie. rendered colors)\n \"\"\"\n\n def forward(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\n \"\"\"Run forward starting with a ray bundle. This outputs different things depending on the configuration\n of the model and whether or not the batch is provided (whether or not we are training basically)\n\n Args:\n ray_bundle: containing all the information needed to render that ray latents included\n \"\"\"\n\n if self.collider is not None:\n ray_bundle = self.collider(ray_bundle)\n\n return self.get_outputs(ray_bundle)\n\n def get_metrics_dict(self, outputs, batch) -> Dict[str, torch.Tensor]:\n \"\"\"Compute and returns metrics.\n\n Args:\n outputs: the output to compute loss dict to\n batch: ground truth batch corresponding to outputs\n \"\"\"\n # pylint: disable=unused-argument\n # pylint: disable=no-self-use\n return {}\n \n\n @abstractmethod\n def get_loss_dict(self, outputs, batch, metrics_dict=None) -> Dict[str, torch.Tensor]:\n \"\"\"Computes and returns the losses dict.\n\n Args:\n outputs: the output to compute loss dict to\n batch: ground truth batch corresponding to outputs\n metrics_dict: dictionary of metrics, some of which we can use for loss\n \"\"\"\n \n def n_parameters(self):\n return -1.0\n\n @torch.no_grad()\n def get_outputs_for_camera_ray_bundle(self, camera_ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\n \"\"\"Takes in camera parameters and computes the output of the model.\n\n Args:\n camera_ray_bundle: ray bundle to calculate outputs over\n \"\"\"\n num_rays_per_chunk = self.config.eval_num_rays_per_chunk\n image_height, image_width = camera_ray_bundle.origins.shape[:2]\n num_rays = len(camera_ray_bundle)\n outputs_lists = defaultdict(list)\n for i in range(0, num_rays, num_rays_per_chunk):\n start_idx = i\n end_idx = i + num_rays_per_chunk\n ray_bundle = camera_ray_bundle.get_row_major_sliced_ray_bundle(start_idx, end_idx)\n outputs = self.forward(ray_bundle=ray_bundle)\n for output_name, output in outputs.items(): # type: ignore\n outputs_lists[output_name].append(output)\n outputs = {}\n for output_name, outputs_list in outputs_lists.items():\n if not torch.is_tensor(outputs_list[0]):\n # TODO: handle lists of tensors as well\n continue\n outputs[output_name] = torch.cat(outputs_list).view(image_height, image_width, -1) # type: ignore\n return outputs\n\n @abstractmethod\n def get_image_metrics_and_images(\n self, outputs: Dict[str, torch.Tensor], batch: Dict[str, torch.Tensor]\n ) -> Tuple[Dict[str, float], Dict[str, torch.Tensor]]:\n \"\"\"Writes the test image outputs.\n TODO: This shouldn't return a loss\n\n Args:\n image_idx: Index of the image.\n step: Current step.\n batch: Batch of data.\n outputs: Outputs of the model.\n\n Returns:\n A dictionary of metrics.\n \"\"\"\n\n def load_model(self, loaded_state: Dict[str, Any]) -> None:\n \"\"\"Load the checkpoint from the given path\n\n Args:\n loaded_state: dictionary of pre-trained model states\n \"\"\"\n state = {key.replace(\"module.\", \"\"): value for key, value in loaded_state[\"model\"].items()}\n self.load_state_dict(state) # type: ignore\n \n def customized_save(self, step: int, checkpoint_dir) -> None:\n \"\"\"Call the model's customized save function.\n\n Args:\n step: Current step.\n checkpoint_dir: directory of checkpoint\n \"\"\"\n pass\n\n def customized_load(self, load_step: int, checkpoint_dir) -> None:\n \"\"\"Call the model's customized load function.\n\n Args:\n checkpoint_dir: directory of checkpoint\n \"\"\"\n pass"},{"identifier":"colormaps","path":"nerfstudio/utils/colormaps.py","snippet":"def apply_colormap(image: TensorType[\"bs\":..., 1], cmap=\"viridis\") -> TensorType[\"bs\":..., \"rgb\":3]:\ndef apply_depth_colormap(\n depth: TensorType[\"bs\":..., 1],\n accumulation: Optional[TensorType[\"bs\":..., 1]] = None,\n near_plane: Optional[float] = None,\n far_plane: Optional[float] = None,\n cmap=\"turbo\",\n) -> TensorType[\"bs\":..., \"rgb\":3]:\ndef apply_boolean_colormap(\n image: TensorType[\"bs\":..., 1, bool],\n true_color: TensorType[\"bs\":..., \"rgb\":3] = colors.WHITE,\n false_color: TensorType[\"bs\":..., \"rgb\":3] = colors.BLACK,\n) -> TensorType[\"bs\":..., \"rgb\":3]:"},{"identifier":"profiler","path":"nerfstudio/utils/profiler.py","snippet":"CONSOLE = Console(width=120)\nPROFILER = []\ndef time_function(func: Callable) -> Callable:\n def wrapper(*args, **kwargs):\ndef flush_profiler(config: cfg.LoggingConfig):\ndef setup_profiler(config: cfg.LoggingConfig):\n def __init__(self, config: cfg.LoggingConfig):\n def update_time(self, func_name: str, start_time: float, end_time: float):\n def print_profile(self):\nclass Profiler:"},{"identifier":"writer","path":"nerfstudio/utils/writer.py","snippet":"CONSOLE = Console(width=120)\nEVENT_WRITERS = []\nEVENT_STORAGE = []\nGLOBAL_BUFFER = {}\n ITER_TRAIN_TIME = \"Train Iter (time)\"\n TOTAL_TRAIN_TIME = \"Train Total (time)\"\n ITER_VIS_TIME = \"Viewer Rendering (time)\"\n ETA = \"ETA (time)\"\n TRAIN_RAYS_PER_SEC = \"Train Rays / Sec\"\n TEST_RAYS_PER_SEC = \"Test Rays / Sec\"\n VIS_RAYS_PER_SEC = \"Vis Rays / Sec\"\n CURR_TEST_PSNR = \"Test PSNR\"\n IMAGE = \"write_image\"\n PLOTLY = \"write_plotly\"\n SCALAR = \"write_scalar\"\n DICT = \"write_scalar_dict\"\n CONFIG = \"write_config\"\nclass EventName(enum.Enum):\nclass EventType(enum.Enum):\nclass Writer:\nclass TimeWriter:\nclass WandbWriter(Writer):\nclass TensorboardWriter(Writer):\nclass LocalWriter:\ndef put_image(name, image: TensorType[\"H\", \"W\", \"C\"], step: int):\ndef put_plotly(name: str, figure: Any, step: int = 0):\ndef put_scalar(name: str, scalar: Any, step: int):\ndef put_dict(name: str, scalar_dict: Dict[str, Any], step: int):\ndef put_config(name: str, config_dict: Dict[str, Any], step: int):\ndef put_time(name: str, duration: float, step: int, avg_over_steps: bool = True, update_eta: bool = False):\ndef write_out_storage():\ndef setup_local_writer(config: cfg.LoggingConfig, max_iter: int, banner_messages: Optional[List[str]] = None) -> None:\ndef setup_event_writer(config: cfg.Config, log_dir: Path) -> None:\n def write_image(self, name: str, image: TensorType[\"H\", \"W\", \"C\"], step: int) -> None:\n def write_plotly(self, name: str, figure: Any, step: int) -> None:\n def write_scalar(self, name: str, scalar: Union[float, torch.Tensor], step: int) -> None:\n def write_scalar_dict(self, name: str, scalar_dict: Dict[str, Any], step: int) -> None:\n def __init__(self, writer, name, step=None, write=True):\n def __enter__(self):\n def __exit__(self, *args):\n def __init__(self, log_dir: Path, experiment_name: str):\n def write_image(self, name: str, image: TensorType[\"H\", \"W\", \"C\"], step: int) -> None:\n def write_plotly(self, name: str, figure: Any, step: int) -> None:\n def write_scalar(self, name: str, scalar: Union[float, torch.Tensor], step: int) -> None:\n def write_config(self, name: str, config_dict: Dict[str, Any], step: int):\n def __init__(self, log_dir: Path):\n def write_image(self, name: str, image: TensorType[\"H\", \"W\", \"C\"], step: int) -> None:\n def write_plotly(self, name: str, figure: Any, step: int) -> None:\n def write_scalar(self, name: str, scalar: Union[float, torch.Tensor], step: int) -> None:\n def write_config(self, name: str, config_dict: Dict[str, Any], step: int): # pylint: disable=unused-argument\ndef _cursorup(x: int):\ndef _format_time(seconds):\n def __init__(self, config: cfg.LocalWriterConfig, banner_messages: Optional[List[str]] = None):\n def write_stats_log(self, step: int) -> None:\n def write_config(self, name: str, config_dict: Dict[str, Any], step: int):\n def _consolidate_events(self):\n def _update_header(self, latest_map, new_key):\n def _print_stats(self, latest_map, padding=\" \"):"},{"identifier":"check_main_thread","path":"nerfstudio/utils/decorators.py","snippet":"def check_main_thread(func: Callable) -> Callable:\n \"\"\"Decorator: check if you are on main thread\"\"\"\n\n def wrapper(*args, **kwargs):\n ret = None\n if comms.is_main_process():\n ret = func(*args, **kwargs)\n return ret\n\n return wrapper"},{"identifier":"decorate_all","path":"nerfstudio/utils/decorators.py","snippet":"def decorate_all(decorators: List[Callable]) -> Callable:\n \"\"\"A decorator to decorate all member functions of a class\n\n Args:\n decorators: list of decorators to add to all functions in the class\n \"\"\"\n\n def decorate(cls):\n for attr in cls.__dict__:\n if callable(getattr(cls, attr)) and attr != \"__init__\":\n for decorator in decorators:\n setattr(cls, attr, decorator(getattr(cls, attr)))\n return cls\n\n return decorate"},{"identifier":"BasicImages","path":"nerfstudio/utils/images.py","snippet":"class BasicImages:\n \"\"\"This is a very primitive struct for holding images, especially for when these images\n are of different heights / widths.\n\n The purpose of this is to have a special struct wrapping around a list so that the\n nerfstudio_collate fn and other parts of the code recognise this as a struct to leave alone\n instead of reshaping or concatenating into a single tensor (since this will likely be used\n for cases where we have images of different sizes and shapes).\n\n This only has one batch dimension and will likely be replaced down the line with some\n TensorDataclass alternative that supports arbitrary batches.\n \"\"\"\n\n def __init__(self, images: List):\n assert isinstance(images, List)\n assert not images or isinstance(\n images[0], torch.Tensor\n ), f\"Input should be a list of tensors, not {type(images[0]) if isinstance(images, List) else type(images)}\"\n self.images = images\n\n def to(self, device):\n \"\"\"Move the images to the given device.\"\"\"\n assert isinstance(device, torch.device)\n return BasicImages([image.to(device) for image in self.images])"},{"identifier":"load_from_json","path":"nerfstudio/utils/io.py","snippet":"def load_from_json(filename: Path):\n \"\"\"Load a dictionary from a JSON filename.\n\n Args:\n filename: The filename to load from.\n \"\"\"\n assert filename.suffix == \".json\"\n with open(filename, encoding=\"UTF-8\") as file:\n return json.load(file)"},{"identifier":"write_to_json","path":"nerfstudio/utils/io.py","snippet":"def write_to_json(filename: Path, content: dict):\n \"\"\"Write data to a JSON file.\n\n Args:\n filename: The filename to write to.\n content: The dictionary data to write.\n \"\"\"\n assert filename.suffix == \".json\", \"Filename must have .json extension but got {}\".format(filename)\n with open(filename, \"w\", encoding=\"UTF-8\") as file:\n json.dump(content, file)"},{"identifier":"GLOBAL_BUFFER","path":"nerfstudio/utils/writer.py","snippet":"GLOBAL_BUFFER = {}"},{"identifier":"EventName","path":"nerfstudio/utils/writer.py","snippet":"class EventName(enum.Enum):\n \"\"\"Names of possible events that can be logged via Local Writer for convenience.\n see config/logging/default_logging.yaml\"\"\"\n\n ITER_TRAIN_TIME = \"Train Iter (time)\"\n TOTAL_TRAIN_TIME = \"Train Total (time)\"\n ITER_VIS_TIME = \"Viewer Rendering (time)\"\n ETA = \"ETA (time)\"\n TRAIN_RAYS_PER_SEC = \"Train Rays / Sec\"\n TEST_RAYS_PER_SEC = \"Test Rays / Sec\"\n VIS_RAYS_PER_SEC = \"Vis Rays / Sec\"\n CURR_TEST_PSNR = \"Test PSNR\""},{"identifier":"TimeWriter","path":"nerfstudio/utils/writer.py","snippet":"class TimeWriter:\n \"\"\"Timer context manager that calculates duration around wrapped functions\"\"\"\n\n def __init__(self, writer, name, step=None, write=True):\n self.writer = writer\n self.name = name\n self.step = step\n self.write = write\n\n self.start: float = 0.0\n self.duration: float = 0.0\n\n def __enter__(self):\n torch.cuda.synchronize()\n self.start = time()\n return self\n\n def __exit__(self, *args):\n torch.cuda.synchronize()\n self.duration = time() - self.start\n update_step = self.step is not None\n if self.write:\n self.writer.put_time(\n name=self.name,\n duration=self.duration,\n step=self.step if update_step else GLOBAL_BUFFER[\"max_iter\"],\n avg_over_steps=update_step,\n update_eta=self.name == EventName.ITER_TRAIN_TIME,\n )"},{"identifier":"run_viewer_bridge_server_as_subprocess","path":"nerfstudio/viewer/server/subprocess.py","snippet":"def run_viewer_bridge_server_as_subprocess(\n websocket_port: int,\n zmq_port: Optional[int] = None,\n ip_address: str = \"127.0.0.1\",\n log_filename: Union[str, None] = None,\n):\n \"\"\"Runs the viewer bridge server as a subprocess.\n\n Args:\n zmq_port: Port to use for the ZMQ server.\n websocket_port: Port to use for the websocket server.\n ip_address: host to connect to\n log_filename: Filename to use for the log file. If None, no log file is created.\n\n Returns:\n None\n \"\"\"\n args = [sys.executable, \"-u\", \"-m\", server.__name__]\n\n # find an available port for zmq\n if zmq_port is None:\n sock = socket.socket()\n sock.bind((\"\", 0))\n zmq_port = sock.getsockname()[1]\n string = f\"Using ZMQ port: {zmq_port}\"\n CONSOLE.print(f\"[bold yellow]{string}\")\n\n args.append(\"--zmq-port\")\n args.append(str(zmq_port))\n args.append(\"--websocket-port\")\n args.append(str(websocket_port))\n args.append(\"--ip-address\")\n args.append(str(ip_address))\n # supress output if no log filename is specified\n logfile = open( # pylint: disable=consider-using-with\n log_filename if log_filename else os.devnull, \"w\", encoding=\"utf8\"\n )\n process = subprocess.Popen( # pylint: disable=consider-using-with\n args, stdout=logfile, stderr=logfile, start_new_session=True\n )\n\n def cleanup(process):\n process.kill()\n process.wait()\n\n def poll_process():\n \"\"\"\n Continually check to see if the viewer bridge server process is still running and has not failed.\n If it fails, alert the user and exit the entire program.\n \"\"\"\n while process.poll() is None:\n time.sleep(0.5)\n string = f\"\\nThe viewer bridge server subprocess failed. Please check the log file {log_filename}.\\n\"\n string += (\n \"You likely have to modify --viewer.zmq-port and/or --viewer.websocket-port in the \"\n \"config to avoid conflicting ports.\\n\"\n )\n string += \"Try modifying --viewer.websocket-port 7007\\n\"\n CONSOLE.print(f\"[bold red]{string}\")\n cleanup(process)\n # This exists the entire program. sys.exit() will only kill the thread that this runs in.\n os.kill(os.getpid(), signal.SIGKILL)\n\n # continually check to see if the process stopped\n t1 = threading.Thread(target=poll_process)\n t1.daemon = True\n t1.start()\n atexit.register(cleanup, process)\n return zmq_port"},{"identifier":"get_intrinsics_matrix_and_camera_to_world_h","path":"nerfstudio/viewer/server/utils.py","snippet":"def get_intrinsics_matrix_and_camera_to_world_h(\n camera_object: Dict[str, Any], image_height: int\n) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\"Returns the camera intrinsics matrix and the camera to world homogeneous matrix.\n\n Args:\n camera_object: a Camera object.\n image_size: the size of the image (height, width)\n \"\"\"\n # intrinsics\n fov = camera_object[\"fov\"]\n aspect = camera_object[\"aspect\"]\n image_width = aspect * image_height\n pp_w = image_width / 2.0\n pp_h = image_height / 2.0\n focal_length = three_js_perspective_camera_focal_length(fov, image_height)\n intrinsics_matrix = torch.tensor([[focal_length, 0, pp_w], [0, focal_length, pp_h], [0, 0, 1]]).float()\n\n # extrinsics\n camera_to_world_h = torch.tensor(get_chunks(camera_object[\"matrix\"], size_of_chunk=4)).T.float()\n camera_to_world_h = torch.stack(\n [\n camera_to_world_h[0, :],\n camera_to_world_h[2, :],\n camera_to_world_h[1, :],\n camera_to_world_h[3, :],\n ],\n dim=0,\n )\n\n return intrinsics_matrix, camera_to_world_h"},{"identifier":"Viewer","path":"nerfstudio/viewer/server/visualizer.py","snippet":"class Viewer:\n \"\"\"Viewer class for connecting to the bridge server.\n\n Args:\n zmq_port: Where to connect with ZMQ.\n window: An already existing ViewerWindow.\n ip_address: The ip address of the bridge server.\n \"\"\"\n\n def __init__(\n self, zmq_port: Optional[int] = None, window: Optional[ViewerWindow] = None, ip_address: str = \"127.0.0.1\"\n ):\n if zmq_port is None and window is None:\n raise ValueError(\"Must specify either zmq_port or window.\")\n if window is None:\n self.window = ViewerWindow(zmq_port=zmq_port, ip_address=ip_address)\n else:\n self.window = window\n self.path = Path(())\n\n @staticmethod\n def view_into(window: ViewerWindow, path: Path):\n \"\"\"Returns a new Viewer but keeping the same ViewerWindow.\"\"\"\n vis = Viewer(window=window)\n vis.path = path\n return vis\n\n def __getitem__(self, path):\n return Viewer.view_into(self.window, self.path.append(path))\n\n def __repr__(self):\n return f\"<Viewer using: {self.window} at path: {self.path}>\"\n\n def write(self, data: Union[Dict, str, None] = None):\n \"\"\"Write data.\"\"\"\n path = self.path.lower()\n return self.window.send({\"type\": \"write\", \"path\": path, \"data\": data})\n\n def read(self):\n \"\"\"Read data.\"\"\"\n path = self.path.lower()\n return self.window.send({\"type\": \"read\", \"path\": path})\n\n def delete(self):\n \"\"\"Delete data.\"\"\"\n return self.write(data=None)"}],"string":"[\n {\n \"identifier\": \"Cameras\",\n \"path\": \"nerfstudio/cameras/cameras.py\",\n \"snippet\": \"class Cameras(TensorDataclass):\\n \\\"\\\"\\\"Dataparser outputs for the image dataset and the ray generator.\\n\\n Note: currently only supports cameras with the same principal points and types. The reason we type\\n the focal lengths, principal points, and image sizes as tensors is to allow for batched cameras\\n down the line in cases where your batches of camera data don't come from the same cameras.\\n\\n If a single value is provided, it is broadcasted to all cameras.\\n\\n Args:\\n camera_to_worlds: Camera to world matrices. Tensor of per-image c2w matrices, in [R | t] format\\n fx: Focal length x\\n fy: Focal length y\\n cx: Principal point x\\n cy: Principal point y\\n width: Image width\\n height: Image height\\n distortion_params: OpenCV 6 radial distortion coefficients\\n camera_type: Type of camera model. This will be an int corresponding to the CameraType enum.\\n times: Timestamps for each camera\\n probe_config: dict config containing the generated probe information (core and basis)\\n \\\"\\\"\\\"\\n\\n camera_to_worlds: TensorType[\\\"num_cameras\\\":..., 3, 4]\\n fx: TensorType[\\\"num_cameras\\\":..., 1]\\n fy: TensorType[\\\"num_cameras\\\":..., 1]\\n cx: TensorType[\\\"num_cameras\\\":..., 1]\\n cy: TensorType[\\\"num_cameras\\\":..., 1]\\n width: TensorType[\\\"num_cameras\\\":..., 1]\\n height: TensorType[\\\"num_cameras\\\":..., 1]\\n distortion_params: Optional[TensorType[\\\"num_cameras\\\":..., 6]]\\n camera_type: TensorType[\\\"num_cameras\\\":..., 1]\\n times: Optional[TensorType[\\\"num_cameras\\\":..., 1]]\\n image_filenames: Optional[List[str]]\\n probe_config: Optional[list]\\n\\n def __init__(\\n self,\\n camera_to_worlds: TensorType[\\\"batch_c2ws\\\":..., 3, 4],\\n fx: Union[TensorType[\\\"batch_fxs\\\":..., 1], float],\\n fy: Union[TensorType[\\\"batch_fys\\\":..., 1], float],\\n cx: Union[TensorType[\\\"batch_cxs\\\":..., 1], float],\\n cy: Union[TensorType[\\\"batch_cys\\\":..., 1], float],\\n width: Optional[Union[TensorType[\\\"batch_ws\\\":..., 1], int]] = None,\\n height: Optional[Union[TensorType[\\\"batch_hs\\\":..., 1], int]] = None,\\n distortion_params: Optional[TensorType[\\\"batch_dist_params\\\":..., 6]] = None,\\n camera_type: Optional[\\n Union[\\n TensorType[\\\"batch_cam_types\\\":..., 1],\\n int,\\n List[CameraType],\\n CameraType,\\n ]\\n ] = CameraType.PERSPECTIVE,\\n times: Optional[TensorType[\\\"num_cameras\\\"]] = None,\\n image_filenames: Optional[List[str]] = None,\\n probe_config: Optional[list] = None\\n ):\\n \\\"\\\"\\\"Initializes the Cameras object.\\n\\n Note on Input Tensor Dimensions: All of these tensors have items of dimensions TensorType[3, 4]\\n (in the case of the c2w matrices), TensorType[6] (in the case of distortion params), or\\n TensorType[1] (in the case of the rest of the elements). The dimensions before that are\\n considered the batch dimension of that tensor (batch_c2ws, batch_fxs, etc.). We will broadcast\\n all the tensors to be the same batch dimension. This means you can use any combination of the\\n input types in the function signature and it won't break. Your batch size for all tensors\\n must be broadcastable to the same size, and the resulting number of batch dimensions will be\\n the batch dimension with the largest number of dimensions.\\n \\\"\\\"\\\"\\n\\n # This will notify the tensordataclass that we have a field with more than 1 dimension\\n self._field_custom_dimensions = {\\\"camera_to_worlds\\\": 2}\\n\\n self.camera_to_worlds = camera_to_worlds\\n\\n # fx fy calculation\\n self.fx = self._init_get_fc_xy(fx, \\\"fx\\\") # @dataclass's post_init will take care of broadcasting\\n self.fy = self._init_get_fc_xy(fy, \\\"fy\\\") # @dataclass's post_init will take care of broadcasting\\n\\n # cx cy calculation\\n self.cx = self._init_get_fc_xy(cx, \\\"cx\\\") # @dataclass's post_init will take care of broadcasting\\n self.cy = self._init_get_fc_xy(cy, \\\"cy\\\") # @dataclass's post_init will take care of broadcasting\\n\\n # Distortion Params Calculation:\\n self.distortion_params = distortion_params # @dataclass's post_init will take care of broadcasting\\n\\n # @dataclass's post_init will take care of broadcasting\\n self.height = self._init_get_height_width(height, self.cy)\\n self.width = self._init_get_height_width(width, self.cx)\\n self.camera_type = self._init_get_camera_type(camera_type)\\n self.times = self._init_get_times(times)\\n \\n self.image_filenames = image_filenames\\n self.probe_config = probe_config\\n if self.probe_config is not None:\\n self.probe = Probes(self.camera_to_worlds, self.probe_config)\\n else:\\n self.probe = None\\n \\n self.__post_init__() # This will do the dataclass post_init and broadcast all the tensors\\n\\n def _init_get_fc_xy(self, fc_xy, name):\\n \\\"\\\"\\\"\\n Parses the input focal length / principle point x or y and returns a tensor of the correct shape\\n\\n Only needs to make sure that we a 1 in the last dimension if it is a tensor. If it is a float, we\\n just need to make it into a tensor and it will be broadcasted later in the __post_init__ function.\\n\\n Args:\\n fc_xy: The focal length / principle point x or y\\n name: The name of the variable. Used for error messages\\n \\\"\\\"\\\"\\n if isinstance(fc_xy, float):\\n fc_xy = torch.Tensor([fc_xy], device=self.device)\\n elif isinstance(fc_xy, torch.Tensor):\\n if fc_xy.ndim == 0 or fc_xy.shape[-1] != 1:\\n fc_xy = fc_xy.unsqueeze(-1)\\n fc_xy = fc_xy.to(self.device)\\n else:\\n raise ValueError(f\\\"{name} must be a float or tensor, got {type(fc_xy)}\\\")\\n return fc_xy\\n\\n def _init_get_camera_type(\\n self,\\n camera_type: Union[\\n TensorType[\\\"batch_cam_types\\\":..., 1], TensorType[\\\"batch_cam_types\\\":...], int, List[CameraType], CameraType\\n ],\\n ) -> TensorType[\\\"num_cameras\\\":..., 1]:\\n \\\"\\\"\\\"\\n Parses the __init__() argument camera_type\\n\\n Camera Type Calculation:\\n If CameraType, convert to int and then to tensor, then broadcast to all cameras\\n If List of CameraTypes, convert to ints and then to tensor, then broadcast to all cameras\\n If int, first go to tensor and then broadcast to all cameras\\n If tensor, broadcast to all cameras\\n\\n Args:\\n camera_type: camera_type argument from __init__()\\n \\\"\\\"\\\"\\n if isinstance(camera_type, CameraType):\\n camera_type = torch.tensor([camera_type.value], device=self.device)\\n elif isinstance(camera_type, List) and isinstance(camera_type[0], CameraType):\\n camera_type = torch.tensor([[c.value] for c in camera_type], device=self.device)\\n elif isinstance(camera_type, int):\\n camera_type = torch.tensor([camera_type], device=self.device)\\n elif isinstance(camera_type, torch.Tensor):\\n assert not torch.is_floating_point(\\n camera_type\\n ), f\\\"camera_type tensor must be of type int, not: {camera_type.dtype}\\\"\\n camera_type = camera_type.to(self.device)\\n if camera_type.ndim == 0 or camera_type.shape[-1] != 1:\\n camera_type = camera_type.unsqueeze(-1)\\n # assert torch.all(\\n # camera_type.view(-1)[0] == camera_type\\n # ), \\\"Batched cameras of different camera_types will be allowed in the future.\\\"\\n else:\\n raise ValueError(\\n 'Invalid camera_type. Must be CameraType, List[CameraType], int, or torch.Tensor[\\\"num_cameras\\\"]. \\\\\\n Received: '\\n + str(type(camera_type))\\n )\\n return camera_type\\n\\n def _init_get_height_width(\\n self,\\n h_w: Union[TensorType[\\\"batch_hws\\\":..., 1], TensorType[\\\"batch_hws\\\":...], int, None],\\n c_x_y: TensorType[\\\"batch_cxys\\\":...],\\n ) -> TensorType[\\\"num_cameras\\\":..., 1]:\\n \\\"\\\"\\\"\\n Parses the __init__() argument for height or width\\n\\n Height/Width Calculation:\\n If int, first go to tensor and then broadcast to all cameras\\n If tensor, broadcast to all cameras\\n If none, use cx or cy * 2\\n Else raise error\\n\\n Args:\\n h_w: height or width argument from __init__()\\n c_x_y: cx or cy for when h_w == None\\n \\\"\\\"\\\"\\n if isinstance(h_w, int):\\n h_w = torch.Tensor([h_w]).to(torch.int64).to(self.device)\\n elif isinstance(h_w, torch.Tensor):\\n assert not torch.is_floating_point(h_w), f\\\"height and width tensor must be of type int, not: {h_w.dtype}\\\"\\n h_w = h_w.to(torch.int64).to(self.device)\\n if h_w.ndim == 0 or h_w.shape[-1] != 1:\\n h_w = h_w.unsqueeze(-1)\\n # assert torch.all(h_w == h_w.view(-1)[0]), \\\"Batched cameras of different h, w will be allowed in the future.\\\"\\n elif h_w is None:\\n h_w = torch.Tensor((c_x_y * 2).to(torch.int64).to(self.device))\\n else:\\n raise ValueError(\\\"Height must be an int, tensor, or None, received: \\\" + str(type(h_w)))\\n return h_w\\n\\n def _init_get_times(self, times):\\n if times is None:\\n times = None\\n elif isinstance(times, torch.Tensor):\\n if times.ndim == 0 or times.shape[-1] != 1:\\n times = times.unsqueeze(-1).to(self.device)\\n else:\\n raise ValueError(f\\\"times must be None or a tensor, got {type(times)}\\\")\\n\\n return times\\n\\n @property\\n def device(self):\\n \\\"\\\"\\\"Returns the device that the camera is on.\\\"\\\"\\\"\\n return self.camera_to_worlds.device\\n\\n @property\\n def image_height(self) -> TensorType[\\\"num_cameras\\\":..., 1]:\\n \\\"\\\"\\\"Returns the height of the images.\\\"\\\"\\\"\\n return self.height\\n\\n @property\\n def image_width(self) -> TensorType[\\\"num_cameras\\\":..., 1]:\\n \\\"\\\"\\\"Returns the height of the images.\\\"\\\"\\\"\\n return self.width\\n\\n @property\\n def is_jagged(self):\\n \\\"\\\"\\\"\\n Returns whether or not the cameras are \\\"jagged\\\" (i.e. the height and widths are different, meaning that\\n you cannot concatenate the image coordinate maps together)\\n \\\"\\\"\\\"\\n h_jagged = not torch.all(self.height == self.height.view(-1)[0])\\n w_jagged = not torch.all(self.width == self.width.view(-1)[0])\\n return h_jagged or w_jagged\\n\\n def get_image_coords(\\n self, pixel_offset: float = 0.5, index: Optional[Tuple] = None\\n ) -> TensorType[\\\"height\\\", \\\"width\\\", 2]:\\n \\\"\\\"\\\"This gets the image coordinates of one of the cameras in this object.\\n\\n If no index is specified, it will return the maximum possible sized height / width image coordinate map,\\n by looking at the maximum height and width of all the cameras in this object.\\n\\n Args:\\n pixel_offset: Offset for each pixel. Defaults to center of pixel (0.5)\\n index: Tuple of indices into the batch dimensions of the camera. Defaults to None, which returns the 0th\\n flattened camera\\n\\n Returns:\\n Grid of image coordinates.\\n \\\"\\\"\\\"\\n if index is None:\\n image_height = torch.max(self.image_height.view(-1))\\n image_width = torch.max(self.image_width.view(-1))\\n image_coords = torch.meshgrid(torch.arange(image_height), torch.arange(image_width), indexing=\\\"ij\\\")\\n image_coords = torch.stack(image_coords, dim=-1) + pixel_offset # stored as (y, x) coordinates\\n else:\\n image_height = self.image_height[index].item()\\n image_width = self.image_width[index].item()\\n image_coords = torch.meshgrid(torch.arange(image_height), torch.arange(image_width), indexing=\\\"ij\\\")\\n image_coords = torch.stack(image_coords, dim=-1) + pixel_offset # stored as (y, x) coordinates\\n return image_coords\\n\\n def generate_rays( # pylint: disable=too-many-statements\\n self,\\n camera_indices: Union[TensorType[\\\"num_rays\\\":..., \\\"num_cameras_batch_dims\\\"], int],\\n coords: Optional[TensorType[\\\"num_rays\\\":..., 2]] = None,\\n camera_opt_to_camera: Optional[TensorType[\\\"num_rays\\\":..., 3, 4]] = None,\\n distortion_params_delta: Optional[TensorType[\\\"num_rays\\\":..., 6]] = None,\\n keep_shape: Optional[bool] = None,\\n disable_distortion: bool = False,\\n ) -> RayBundle:\\n \\\"\\\"\\\"Generates rays for the given camera indices.\\n\\n This function will standardize the input arguments and then call the _generate_rays_from_coords function\\n to generate the rays. Our goal is to parse the arguments and then get them into the right shape:\\n - camera_indices: (num_rays:..., num_cameras_batch_dims)\\n - coords: (num_rays:..., 2)\\n - camera_opt_to_camera: (num_rays:..., 3, 4) or None\\n - distortion_params_delta: (num_rays:..., 6) or None\\n\\n Read the docstring for _generate_rays_from_coords for more information on how we generate the rays\\n after we have standardized the arguments.\\n\\n We are only concerned about different combinations of camera_indices and coords matrices, and the following\\n are the 4 cases we have to deal with:\\n 1. isinstance(camera_indices, int) and coords == None\\n - In this case we broadcast our camera_indices / coords shape (h, w, 1 / 2 respectively)\\n 2. isinstance(camera_indices, int) and coords != None\\n - In this case, we broadcast camera_indices to the same batch dim as coords\\n 3. not isinstance(camera_indices, int) and coords == None\\n - In this case, we will need to set coords so that it is of shape (h, w, num_rays, 2), and broadcast\\n all our other args to match the new definition of num_rays := (h, w) + num_rays\\n 4. not isinstance(camera_indices, int) and coords != None\\n - In this case, we have nothing to do, only check that the arguments are of the correct shape\\n\\n There is one more edge case we need to be careful with: when we have \\\"jagged cameras\\\" (ie: different heights\\n and widths for each camera). This isn't problematic when we specify coords, since coords is already a tensor.\\n When coords == None (ie: when we render out the whole image associated with this camera), we run into problems\\n since there's no way to stack each coordinate map as all coordinate maps are all different shapes. In this case,\\n we will need to flatten each individual coordinate map and concatenate them, giving us only one batch dimension,\\n regaurdless of the number of prepended extra batch dimensions in the camera_indices tensor.\\n\\n\\n Args:\\n camera_indices: Camera indices of the flattened cameras object to generate rays for.\\n coords: Coordinates of the pixels to generate rays for. If None, the full image will be rendered.\\n camera_opt_to_camera: Optional transform for the camera to world matrices.\\n distortion_params_delta: Optional delta for the distortion parameters.\\n keep_shape: If None, then we default to the regular behavior of flattening if cameras is jagged, otherwise\\n keeping dimensions. If False, we flatten at the end. If True, then we keep the shape of the\\n camera_indices and coords tensors (if we can).\\n disable_distortion: If True, disables distortion.\\n\\n Returns:\\n Rays for the given camera indices and coords.\\n \\\"\\\"\\\"\\n # Check the argument types to make sure they're valid and all shaped correctly\\n assert isinstance(camera_indices, (torch.Tensor, int)), \\\"camera_indices must be a tensor or int\\\"\\n assert coords is None or isinstance(coords, torch.Tensor), \\\"coords must be a tensor or None\\\"\\n assert camera_opt_to_camera is None or isinstance(camera_opt_to_camera, torch.Tensor)\\n assert distortion_params_delta is None or isinstance(distortion_params_delta, torch.Tensor)\\n if isinstance(camera_indices, torch.Tensor) and isinstance(coords, torch.Tensor):\\n num_rays_shape = camera_indices.shape[:-1]\\n errormsg = \\\"Batch dims of inputs must match when inputs are all tensors\\\"\\n assert coords.shape[:-1] == num_rays_shape, errormsg\\n assert camera_opt_to_camera is None or camera_opt_to_camera.shape[:-2] == num_rays_shape, errormsg\\n assert distortion_params_delta is None or distortion_params_delta.shape[:-1] == num_rays_shape, errormsg\\n\\n # If zero dimensional, we need to unsqueeze to get a batch dimension and then squeeze later\\n if not self.shape:\\n cameras = self.reshape((1,))\\n assert torch.all(\\n torch.tensor(camera_indices == 0) if isinstance(camera_indices, int) else camera_indices == 0\\n ), \\\"Can only index into single camera with no batch dimensions if index is zero\\\"\\n else:\\n cameras = self\\n\\n # If the camera indices are an int, then we need to make sure that the camera batch is 1D\\n if isinstance(camera_indices, int):\\n assert (\\n len(cameras.shape) == 1\\n ), \\\"camera_indices must be a tensor if cameras are batched with more than 1 batch dimension\\\"\\n camera_indices = torch.tensor([camera_indices], device=cameras.device)\\n\\n assert camera_indices.shape[-1] == len(\\n cameras.shape\\n ), \\\"camera_indices must have shape (num_rays:..., num_cameras_batch_dims)\\\"\\n\\n # If keep_shape is True, then we need to make sure that the camera indices in question\\n # are all the same height and width and can actually be batched while maintaining the image\\n # shape\\n if keep_shape is True:\\n assert torch.all(cameras.height[camera_indices] == cameras.height[camera_indices[0]]) and torch.all(\\n cameras.width[camera_indices] == cameras.width[camera_indices[0]]\\n ), \\\"Can only keep shape if all cameras have the same height and width\\\"\\n\\n # If the cameras don't all have same height / width, if coords is not none, we will need to generate\\n # a flat list of coords for each camera and then concatenate otherwise our rays will be jagged.\\n # Camera indices, camera_opt, and distortion will also need to be broadcasted accordingly which is non-trivial\\n if cameras.is_jagged and coords is None and (keep_shape is None or keep_shape is False):\\n index_dim = camera_indices.shape[-1]\\n camera_indices = camera_indices.reshape(-1, index_dim)\\n _coords = [cameras.get_image_coords(index=tuple(index)).reshape(-1, 2) for index in camera_indices]\\n camera_indices = torch.cat(\\n [index.unsqueeze(0).repeat(coords.shape[0], 1) for index, coords in zip(camera_indices, _coords)],\\n )\\n coords = torch.cat(_coords, dim=0)\\n assert coords.shape[0] == camera_indices.shape[0]\\n # Need to get the coords of each indexed camera and flatten all coordinate maps and concatenate them\\n\\n # The case where we aren't jagged && keep_shape (since otherwise coords is already set) and coords\\n # is None. In this case we append (h, w) to the num_rays dimensions for all tensors. In this case,\\n # each image in camera_indices has to have the same shape since otherwise we would have error'd when\\n # we checked keep_shape is valid or we aren't jagged.\\n if coords is None:\\n index_dim = camera_indices.shape[-1]\\n index = camera_indices.reshape(-1, index_dim)[0]\\n coords: torch.Tensor = cameras.get_image_coords(index=tuple(index)) # (h, w, 2)\\n coords = coords.reshape(coords.shape[:2] + (1,) * len(camera_indices.shape[:-1]) + (2,)) # (h, w, 1..., 2)\\n coords = coords.expand(coords.shape[:2] + camera_indices.shape[:-1] + (2,)) # (h, w, num_rays, 2)\\n camera_opt_to_camera = ( # (h, w, num_rays, 3, 4) or None\\n camera_opt_to_camera.broadcast_to(coords.shape[:-1] + (3, 4))\\n if camera_opt_to_camera is not None\\n else None\\n )\\n distortion_params_delta = ( # (h, w, num_rays, 6) or None\\n distortion_params_delta.broadcast_to(coords.shape[:-1] + (6,))\\n if distortion_params_delta is not None\\n else None\\n )\\n\\n # If camera indices was an int or coords was none, we need to broadcast our indices along batch dims\\n camera_indices = camera_indices.broadcast_to(coords.shape[:-1] + (len(cameras.shape),)).to(torch.long)\\n\\n # Checking our tensors have been standardized\\n assert isinstance(coords, torch.Tensor) and isinstance(camera_indices, torch.Tensor)\\n assert camera_indices.shape[-1] == len(cameras.shape)\\n assert camera_opt_to_camera is None or camera_opt_to_camera.shape[:-2] == coords.shape[:-1]\\n assert distortion_params_delta is None or distortion_params_delta.shape[:-1] == coords.shape[:-1]\\n\\n # This will do the actual work of generating the rays now that we have standardized the inputs\\n # raybundle.shape == (num_rays) when done\\n # pylint: disable=protected-access\\n raybundle = cameras._generate_rays_from_coords(\\n camera_indices, coords, camera_opt_to_camera, distortion_params_delta, disable_distortion=disable_distortion\\n )\\n\\n # If we have mandated that we don't keep the shape, then we flatten\\n if keep_shape is False:\\n raybundle = raybundle.flatten()\\n\\n # TODO: We should have to squeeze the last dimension here if we started with zero batch dims, but never have to,\\n # so there might be a rogue squeeze happening somewhere, and this may cause some unintended behaviour\\n # that we haven't caught yet with tests\\n return raybundle\\n\\n # pylint: disable=too-many-statements\\n def _generate_rays_from_coords(\\n self,\\n camera_indices: TensorType[\\\"num_rays\\\":..., \\\"num_cameras_batch_dims\\\"],\\n coords: TensorType[\\\"num_rays\\\":..., 2],\\n camera_opt_to_camera: Optional[TensorType[\\\"num_rays\\\":..., 3, 4]] = None,\\n distortion_params_delta: Optional[TensorType[\\\"num_rays\\\":..., 6]] = None,\\n disable_distortion: bool = False,\\n ) -> RayBundle:\\n \\\"\\\"\\\"Generates rays for the given camera indices and coords where self isn't jagged\\n\\n This is a fairly complex function, so let's break this down slowly.\\n\\n Shapes involved:\\n - num_rays: This is your output raybundle shape. It dictates the number and shape of the rays generated\\n - num_cameras_batch_dims: This is the number of dimensions of our camera\\n\\n Args:\\n camera_indices: Camera indices of the flattened cameras object to generate rays for.\\n The shape of this is such that indexing into camera_indices[\\\"num_rays\\\":...] will return the\\n index into each batch dimension of the camera in order to get the correct camera specified by\\n \\\"num_rays\\\".\\n Example:\\n >>> cameras = Cameras(...)\\n >>> cameras.shape\\n (2, 3, 4)\\n >>> camera_indices = torch.tensor([0, 0, 0]) # We need an axis of length 3 since cameras.ndim == 3\\n >>> camera_indices.shape\\n (3,)\\n >>> coords = torch.tensor([1,1])\\n >>> coords.shape\\n (2,)\\n >>> out_rays = cameras.generate_rays(camera_indices=camera_indices, coords = coords)\\n # This will generate a RayBundle with a single ray for the\\n # camera at cameras[0,0,0] at image coordinates (1,1), so out_rays.shape == ()\\n >>> out_rays.shape\\n ()\\n >>> camera_indices = torch.tensor([[0,0,0]])\\n >>> camera_indices.shape\\n (1, 3)\\n >>> coords = torch.tensor([[1,1]])\\n >>> coords.shape\\n (1, 2)\\n >>> out_rays = cameras.generate_rays(camera_indices=camera_indices, coords = coords)\\n # This will generate a RayBundle with a single ray for the\\n # camera at cameras[0,0,0] at point (1,1), so out_rays.shape == (1,)\\n # since we added an extra dimension in front of camera_indices\\n >>> out_rays.shape\\n (1,)\\n\\n If you want more examples, check tests/cameras/test_cameras and the function check_generate_rays_shape\\n\\n The bottom line is that for camera_indices: (num_rays:..., num_cameras_batch_dims), num_rays is the\\n output shape and if you index into the output RayBundle with some indices [i:...], if you index into\\n camera_indices with camera_indices[i:...] as well, you will get a 1D tensor containing the batch\\n indices into the original cameras object corresponding to that ray (ie: you will get the camera\\n from our batched cameras corresponding to the ray at RayBundle[i:...]).\\n\\n coords: Coordinates of the pixels to generate rays for. If None, the full image will be rendered, meaning\\n height and width get prepended to the num_rays dimensions. Indexing into coords with [i:...] will\\n get you the image coordinates [x, y] of that specific ray located at output RayBundle[i:...].\\n\\n camera_opt_to_camera: Optional transform for the camera to world matrices.\\n In terms of shape, it follows the same rules as coords, but indexing into it with [i:...] gets you\\n the 2D camera to world transform matrix for the camera optimization at RayBundle[i:...].\\n\\n distortion_params_delta: Optional delta for the distortion parameters.\\n In terms of shape, it follows the same rules as coords, but indexing into it with [i:...] gets you\\n the 1D tensor with the 6 distortion parameters for the camera optimization at RayBundle[i:...].\\n\\n disable_distortion: If True, disables distortion.\\n\\n Returns:\\n Rays for the given camera indices and coords. RayBundle.shape == num_rays\\n \\\"\\\"\\\"\\n # Make sure we're on the right devices\\n camera_indices = camera_indices.to(self.device)\\n coords = coords.to(self.device)\\n\\n # Checking to make sure everything is of the right shape and type\\n num_rays_shape = camera_indices.shape[:-1]\\n assert camera_indices.shape == num_rays_shape + (self.ndim,)\\n assert coords.shape == num_rays_shape + (2,)\\n assert coords.shape[-1] == 2\\n assert camera_opt_to_camera is None or camera_opt_to_camera.shape == num_rays_shape + (3, 4)\\n assert distortion_params_delta is None or distortion_params_delta.shape == num_rays_shape + (6,)\\n\\n # Here, we've broken our indices down along the num_cameras_batch_dims dimension allowing us to index by all\\n # of our output rays at each dimension of our cameras object\\n true_indices = [camera_indices[..., i] for i in range(camera_indices.shape[-1])]\\n\\n # Get all our focal lengths, principal points and make sure they are the right shapes\\n y = coords[..., 0] # (num_rays,) get rid of the last dimension\\n x = coords[..., 1] # (num_rays,) get rid of the last dimension\\n fx, fy = self.fx[true_indices].squeeze(-1), self.fy[true_indices].squeeze(-1) # (num_rays,)\\n cx, cy = self.cx[true_indices].squeeze(-1), self.cy[true_indices].squeeze(-1) # (num_rays,)\\n assert (\\n y.shape == num_rays_shape\\n and x.shape == num_rays_shape\\n and fx.shape == num_rays_shape\\n and fy.shape == num_rays_shape\\n and cx.shape == num_rays_shape\\n and cy.shape == num_rays_shape\\n ), (\\n str(num_rays_shape)\\n + str(y.shape)\\n + str(x.shape)\\n + str(fx.shape)\\n + str(fy.shape)\\n + str(cx.shape)\\n + str(cy.shape)\\n )\\n\\n # Get our image coordinates and image coordinates offset by 1 (offsets used for dx, dy calculations)\\n # Also make sure the shapes are correct\\n coord = torch.stack([(x - cx) / fx, -(y - cy) / fy], -1) # (num_rays, 2)\\n coord_x_offset = torch.stack([(x - cx + 1) / fx, -(y - cy) / fy], -1) # (num_rays, 2)\\n coord_y_offset = torch.stack([(x - cx) / fx, -(y - cy + 1) / fy], -1) # (num_rays, 2)\\n assert (\\n coord.shape == num_rays_shape + (2,)\\n and coord_x_offset.shape == num_rays_shape + (2,)\\n and coord_y_offset.shape == num_rays_shape + (2,)\\n )\\n\\n # Stack image coordinates and image coordinates offset by 1, check shapes too\\n coord_stack = torch.stack([coord, coord_x_offset, coord_y_offset], dim=0) # (3, num_rays, 2)\\n assert coord_stack.shape == (3,) + num_rays_shape + (2,)\\n\\n # Undistorts our images according to our distortion parameters\\n if not disable_distortion:\\n distortion_params = None\\n if self.distortion_params is not None:\\n distortion_params = self.distortion_params[true_indices]\\n if distortion_params_delta is not None:\\n distortion_params = distortion_params + distortion_params_delta\\n elif distortion_params_delta is not None:\\n distortion_params = distortion_params_delta\\n\\n # Do not apply distortion for equirectangular images\\n if distortion_params is not None:\\n mask = (self.camera_type[true_indices] != CameraType.EQUIRECTANGULAR.value).squeeze(-1) # (num_rays)\\n coord_mask = torch.stack([mask, mask, mask], dim=0)\\n if mask.any():\\n coord_stack[coord_mask, :] = camera_utils.radial_and_tangential_undistort(\\n coord_stack[coord_mask, :].reshape(3, -1, 2),\\n distortion_params[mask, :],\\n ).reshape(-1, 2)\\n\\n # Make sure after we have undistorted our images, the shapes are still correct\\n assert coord_stack.shape == (3,) + num_rays_shape + (2,)\\n\\n # Gets our directions for all our rays in camera coordinates and checks shapes at the end\\n # Here, directions_stack is of shape (3, num_rays, 3)\\n # directions_stack[0] is the direction for ray in camera coordinates\\n # directions_stack[1] is the direction for ray in camera coordinates offset by 1 in x\\n # directions_stack[2] is the direction for ray in camera coordinates offset by 1 in y\\n cam_types = torch.unique(self.camera_type, sorted=False)\\n directions_stack = torch.empty((3,) + num_rays_shape + (3,), device=self.device)\\n if CameraType.PERSPECTIVE.value in cam_types:\\n mask = (self.camera_type[true_indices] == CameraType.PERSPECTIVE.value).squeeze(-1) # (num_rays)\\n mask = torch.stack([mask, mask, mask], dim=0)\\n directions_stack[..., 0][mask] = torch.masked_select(coord_stack[..., 0], mask).float()\\n directions_stack[..., 1][mask] = torch.masked_select(coord_stack[..., 1], mask).float()\\n directions_stack[..., 2][mask] = -1.0\\n\\n if CameraType.FISHEYE.value in cam_types:\\n mask = (self.camera_type[true_indices] == CameraType.FISHEYE.value).squeeze(-1) # (num_rays)\\n mask = torch.stack([mask, mask, mask], dim=0)\\n\\n theta = torch.sqrt(torch.sum(coord_stack**2, dim=-1))\\n theta = torch.clip(theta, 0.0, math.pi)\\n\\n sin_theta = torch.sin(theta)\\n\\n directions_stack[..., 0][mask] = torch.masked_select(coord_stack[..., 0] * sin_theta / theta, mask).float()\\n directions_stack[..., 1][mask] = torch.masked_select(coord_stack[..., 1] * sin_theta / theta, mask).float()\\n directions_stack[..., 2][mask] = -torch.masked_select(torch.cos(theta), mask)\\n\\n if CameraType.EQUIRECTANGULAR.value in cam_types:\\n mask = (self.camera_type[true_indices] == CameraType.EQUIRECTANGULAR.value).squeeze(-1) # (num_rays)\\n mask = torch.stack([mask, mask, mask], dim=0)\\n\\n # For equirect, fx = fy = height = width/2\\n # Then coord[..., 0] goes from -1 to 1 and coord[..., 1] goes from -1/2 to 1/2\\n theta = -torch.pi * coord_stack[..., 0] # minus sign for right-handed\\n phi = torch.pi * (0.5 - coord_stack[..., 1])\\n # use spherical in local camera coordinates (+y up, x=0 and z<0 is theta=0)\\n directions_stack[..., 0][mask] = torch.masked_select(-torch.sin(theta) * torch.sin(phi), mask).float()\\n directions_stack[..., 1][mask] = torch.masked_select(torch.cos(phi), mask).float()\\n directions_stack[..., 2][mask] = torch.masked_select(-torch.cos(theta) * torch.sin(phi), mask).float()\\n\\n for value in cam_types:\\n if value not in [CameraType.PERSPECTIVE.value, CameraType.FISHEYE.value, CameraType.EQUIRECTANGULAR.value]:\\n raise ValueError(f\\\"Camera type {value} not supported.\\\")\\n\\n assert directions_stack.shape == (3,) + num_rays_shape + (3,)\\n\\n c2w = self.camera_to_worlds[true_indices]\\n assert c2w.shape == num_rays_shape + (3, 4)\\n\\n if camera_opt_to_camera is not None:\\n c2w = pose_utils.multiply(c2w, camera_opt_to_camera)\\n rotation = c2w[..., :3, :3] # (..., 3, 3)\\n assert rotation.shape == num_rays_shape + (3, 3)\\n\\n directions_stack = torch.sum(\\n directions_stack[..., None, :] * rotation, dim=-1\\n ) # (..., 1, 3) * (..., 3, 3) -> (..., 3)\\n\\n directions_norm = torch.norm(directions_stack, dim=-1, keepdim=True)\\n directions_norm = directions_norm[0]\\n\\n directions_stack = normalize(directions_stack, dim=-1)\\n assert directions_stack.shape == (3,) + num_rays_shape + (3,)\\n\\n origins = c2w[..., :3, 3] # (..., 3)\\n assert origins.shape == num_rays_shape + (3,)\\n\\n directions = directions_stack[0]\\n assert directions.shape == num_rays_shape + (3,)\\n\\n # norms of the vector going between adjacent coords, giving us dx and dy per output ray\\n dx = torch.sqrt(torch.sum((directions - directions_stack[1]) ** 2, dim=-1)) # (\\\"num_rays\\\":...,)\\n dy = torch.sqrt(torch.sum((directions - directions_stack[2]) ** 2, dim=-1)) # (\\\"num_rays\\\":...,)\\n assert dx.shape == num_rays_shape and dy.shape == num_rays_shape\\n\\n pixel_area = (dx * dy)[..., None] # (\\\"num_rays\\\":..., 1)\\n assert pixel_area.shape == num_rays_shape + (1,)\\n\\n times = self.times[camera_indices, 0] if self.times is not None else None\\n\\n\\n return RayBundle(\\n origins=origins,\\n directions=directions,\\n pixel_area=pixel_area,\\n camera_indices=camera_indices,\\n directions_norm=directions_norm,\\n times=times,\\n probes=self.probe,\\n )\\n\\n def to_json(\\n self, camera_idx: int, image: Optional[TensorType[\\\"height\\\", \\\"width\\\", 2]] = None, max_size: Optional[int] = None\\n ) -> Dict:\\n \\\"\\\"\\\"Convert a camera to a json dictionary.\\n\\n Args:\\n camera_idx: Index of the camera to convert.\\n image: An image in range [0, 1] that is encoded to a base64 string.\\n max_size: Max size to resize the image to if present.\\n\\n Returns:\\n A JSON representation of the camera\\n \\\"\\\"\\\"\\n flattened = self.flatten()\\n json_ = {\\n \\\"type\\\": \\\"PinholeCamera\\\",\\n \\\"cx\\\": flattened[camera_idx].cx.item(),\\n \\\"cy\\\": flattened[camera_idx].cy.item(),\\n \\\"fx\\\": flattened[camera_idx].fx.item(),\\n \\\"fy\\\": flattened[camera_idx].fy.item(),\\n \\\"camera_to_world\\\": self.camera_to_worlds[camera_idx].tolist(),\\n \\\"camera_index\\\": camera_idx,\\n \\\"times\\\": flattened[camera_idx].times.item() if self.times is not None else None,\\n }\\n if image is not None:\\n image_uint8 = (image * 255).detach().type(torch.uint8)\\n if max_size is not None:\\n image_uint8 = image_uint8.permute(2, 0, 1)\\n image_uint8 = torchvision.transforms.functional.resize(image_uint8, max_size) # type: ignore\\n image_uint8 = image_uint8.permute(1, 2, 0)\\n image_uint8 = image_uint8.cpu().numpy()\\n data = cv2.imencode(\\\".jpg\\\", image_uint8)[1].tobytes()\\n json_[\\\"image\\\"] = str(\\\"data:image/jpeg;base64,\\\" + base64.b64encode(data).decode(\\\"ascii\\\"))\\n return json_\\n\\n def get_intrinsics_matrices(self) -> TensorType[\\\"num_cameras\\\":..., 3, 3]:\\n \\\"\\\"\\\"Returns the intrinsic matrices for each camera.\\n\\n Returns:\\n Pinhole camera intrinsics matrices\\n \\\"\\\"\\\"\\n K = torch.zeros((*self.shape, 3, 3), dtype=torch.float32)\\n K[..., 0, 0] = self.fx.squeeze(-1)\\n K[..., 1, 1] = self.fy.squeeze(-1)\\n K[..., 0, 2] = self.cx.squeeze(-1)\\n K[..., 1, 2] = self.cy.squeeze(-1)\\n K[..., 2, 2] = 1.0\\n return K\\n\\n def rescale_output_resolution(\\n self,\\n scaling_factor: Union[TensorType[\\\"num_cameras\\\":...], TensorType[\\\"num_cameras\\\":..., 1], float, int],\\n round_hw=False,\\n ) -> None:\\n \\\"\\\"\\\"Rescale the output resolution of the cameras.\\n\\n Args:\\n scaling_factor: Scaling factor to apply to the output resolution.\\n round_hw: Whether to round the height and width to the nearest integer.\\n \\\"\\\"\\\"\\n if isinstance(scaling_factor, (float, int)):\\n scaling_factor = torch.tensor([scaling_factor]).to(self.device).broadcast_to((self.cx.shape))\\n elif isinstance(scaling_factor, torch.Tensor) and scaling_factor.shape == self.shape:\\n scaling_factor = scaling_factor.unsqueeze(-1)\\n elif isinstance(scaling_factor, torch.Tensor) and scaling_factor.shape == (*self.shape, 1):\\n pass\\n else:\\n raise ValueError(\\n f\\\"Scaling factor must be a float, int, or a tensor of shape {self.shape} or {(*self.shape, 1)}.\\\"\\n )\\n\\n self.fx = self.fx * scaling_factor\\n self.fy = self.fy * scaling_factor\\n self.cx = self.cx * scaling_factor\\n self.cy = self.cy * scaling_factor\\n if not round_hw:\\n self.height = (self.height * scaling_factor).to(torch.int64)\\n self.width = (self.width * scaling_factor).to(torch.int64)\\n else:\\n self.height = torch.floor(self.height * scaling_factor + 0.5).to(torch.int64)\\n self.width = torch.floor(self.width * scaling_factor + 0.5).to(torch.int64)\\n\\n def get_plotly(self, camera_group):\\n\\n # define local necssary coordinates for plotting\\n num_cameras = self.camera_to_worlds.shape[0]\\n _cam_center_c = np.array([[.0, .0, .0]]).repeat(num_cameras, axis=0)\\n _cam_forward_c = np.array([[.0, .0, -1.0]]).repeat(num_cameras, axis=0)\\n _cam_up_c = np.array([[.0, 1.0, .0]]).repeat(num_cameras, axis=0)\\n _cam_right_c = np.array([[1.0, .0, .0]]).repeat(num_cameras, axis=0)\\n\\n _pyramid_width = self.width.cpu().numpy() / self.fx.cpu().numpy()\\n _pyramid_height = self.height.cpu().numpy() / self.fy.cpu().numpy()\\n\\n _cam_pyramid_ur = np.concatenate([_pyramid_width/2, _pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\\n _cam_pyramid_dr = np.concatenate([_pyramid_width/2, -_pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\\n _cam_pyramid_ul = np.concatenate([-_pyramid_width/2, _pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\\n _cam_pyramid_dl = np.concatenate([-_pyramid_width/2, -_pyramid_height/2, -np.ones_like(_pyramid_width)], axis=-1)\\n\\n _local_coordinates = {\\n 'center': _cam_center_c, \\n 'forward': _cam_forward_c, \\n 'up': _cam_up_c, \\n 'right': _cam_right_c, \\n 'pyramid_ur': _cam_pyramid_ur, \\n 'pyramid_dr': _cam_pyramid_dr, \\n 'pyramid_ul': _cam_pyramid_ul, \\n 'pyramid_dl': _cam_pyramid_dl, \\n }\\n\\n # transform it into world coordinates\\n data = {}\\n for k in _local_coordinates.keys():\\n _local_coor_homo = np.concatenate([_local_coordinates[k].reshape(-1, 3) * plotly_camera_scale, np.ones((num_cameras, 1))], axis=-1) # num_cam, 4\\n _cw = self.camera_to_worlds.cpu().numpy() # num_cam, 3, 4\\n\\n _homo = np.einsum('ijk,ik->ij', _cw, _local_coor_homo) # num_cam, 3\\n data[k] = _homo[:, :3]\\n\\n plot_data = plot_camera_components(data, image_list=self.image_filenames, camera_group=camera_group)\\n \\n if isinstance(plot_data, list):\\n return plot_data\\n else:\\n return [plot_data]\"\n },\n {\n \"identifier\": \"RayBundle\",\n \"path\": \"nerfstudio/cameras/rays.py\",\n \"snippet\": \"class RayBundle(TensorDataclass):\\n \\\"\\\"\\\"A bundle of ray parameters.\\\"\\\"\\\"\\n\\n # TODO(ethan): make sure the sizes with ... are correct\\n origins: TensorType[..., 3]\\n \\\"\\\"\\\"Ray origins (XYZ)\\\"\\\"\\\"\\n directions: TensorType[..., 3]\\n \\\"\\\"\\\"Unit ray direction vector\\\"\\\"\\\"\\n pixel_area: TensorType[..., 1]\\n \\\"\\\"\\\"Projected area of pixel a distance 1 away from origin\\\"\\\"\\\"\\n directions_norm: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Norm of ray direction vector before normalization\\\"\\\"\\\"\\n camera_indices: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Camera indices\\\"\\\"\\\"\\n nears: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Distance along ray to start sampling\\\"\\\"\\\"\\n fars: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Rays Distance along ray to stop sampling\\\"\\\"\\\"\\n metadata: Optional[Dict[str, TensorType[\\\"num_rays\\\", \\\"latent_dims\\\"]]] = None\\n \\\"\\\"\\\"Additional metadata or data needed for interpolation, will mimic shape of rays\\\"\\\"\\\"\\n times: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Times at which rays are sampled\\\"\\\"\\\"\\n probes: Optional[Probes] = None\\n \\\"\\\"\\\"Probe Cameras Object. This object doesn't follow the same shape pattern as the other fields. \\n Lazy broadcasting is used for preventing CUDA memory overflow. \\\"\\\"\\\"\\n\\n def set_camera_indices(self, camera_index: int) -> None:\\n \\\"\\\"\\\"Sets all of the the camera indices to a specific camera index.\\n\\n Args:\\n camera_index: Camera index.\\n \\\"\\\"\\\"\\n self.camera_indices = torch.ones_like(self.origins[..., 0:1]).long() * camera_index\\n\\n def __len__(self):\\n num_rays = torch.numel(self.origins) // self.origins.shape[-1]\\n return num_rays\\n\\n def sample(self, num_rays: int) -> \\\"RayBundle\\\":\\n \\\"\\\"\\\"Returns a RayBundle as a subset of rays.\\n\\n Args:\\n num_rays: Number of rays in output RayBundle\\n\\n Returns:\\n RayBundle with subset of rays.\\n \\\"\\\"\\\"\\n assert num_rays <= len(self)\\n indices = random.sample(range(len(self)), k=num_rays)\\n return self[indices]\\n\\n def get_row_major_sliced_ray_bundle(self, start_idx: int, end_idx: int) -> \\\"RayBundle\\\":\\n \\\"\\\"\\\"Flattens RayBundle and extracts chunk given start and end indicies.\\n\\n Args:\\n start_idx: Start index of RayBundle chunk.\\n end_idx: End index of RayBundle chunk.\\n\\n Returns:\\n Flattened RayBundle with end_idx-start_idx rays.\\n\\n \\\"\\\"\\\"\\n return self.flatten()[start_idx:end_idx]\\n\\n def get_ray_samples(\\n self,\\n bin_starts: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n bin_ends: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n spacing_starts: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None,\\n spacing_ends: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None,\\n spacing_to_euclidean_fn: Optional[Callable] = None,\\n ) -> RaySamples:\\n \\\"\\\"\\\"Produces samples for each ray by projection points along the ray direction. Currently samples uniformly.\\n\\n Args:\\n bin_starts: Distance from origin to start of bin. (in Euclidean space)\\n bin_ends: Distance from origin to end of bin. (in Euclidean space)\\n spacing_starts: start point in normalized space. [0, 1]\\n spacing_ends: end point in normalized space. [0, 1]\\n\\n Returns:\\n Samples projected along ray.\\n \\\"\\\"\\\"\\n deltas = bin_ends - bin_starts\\n if self.camera_indices is not None:\\n camera_indices = self.camera_indices[..., None]\\n else:\\n camera_indices = None\\n\\n shaped_raybundle_fields = self[..., None]\\n\\n frustums = Frustums(\\n origins=shaped_raybundle_fields.origins, # [..., 1, 3]\\n directions=shaped_raybundle_fields.directions, # [..., 1, 3]\\n starts=bin_starts, # [..., num_samples, 1]\\n ends=bin_ends, # [..., num_samples, 1]\\n pixel_area=shaped_raybundle_fields.pixel_area, # [..., 1, 1]\\n )\\n\\n ray_samples = RaySamples(\\n frustums=frustums,\\n camera_indices=camera_indices, # [..., 1, 1]\\n deltas=deltas, # [..., num_samples, 1]\\n spacing_starts=spacing_starts, # [..., num_samples, 1]\\n spacing_ends=spacing_ends, # [..., num_samples, 1]\\n spacing_to_euclidean_fn=spacing_to_euclidean_fn,\\n metadata=shaped_raybundle_fields.metadata,\\n times=None if self.times is None else self.times[..., None], # [..., 1, 1]\\n probes=self.probes, # special class, not following the same shape pattern\\n )\\n\\n return ray_samples\"\n },\n {\n \"identifier\": \"base_config\",\n \"path\": \"nerfstudio/configs/base_config.py\",\n \"snippet\": \"CONSOLE = Console(width=120)\\nclass PrintableConfig: # pylint: disable=too-few-public-methods\\nclass InstantiateConfig(PrintableConfig): # pylint: disable=too-few-public-methods\\nclass MachineConfig(PrintableConfig):\\nclass LocalWriterConfig(InstantiateConfig):\\nclass LoggingConfig(PrintableConfig):\\nclass TrainerConfig(PrintableConfig):\\nclass ViewerConfig(PrintableConfig):\\nclass Config(PrintableConfig):\\n def __str__(self):\\n def setup(self, **kwargs) -> Any:\\n def setup(self, banner_messages: Optional[List[str]] = None, **kwargs) -> Any:\\n def is_viewer_enabled(self) -> bool:\\n def is_wandb_enabled(self) -> bool:\\n def is_tensorboard_enabled(self) -> bool:\\n def set_timestamp(self) -> None:\\n def set_experiment_name(self) -> None:\\n def get_base_dir(self) -> Path:\\n def get_checkpoint_dir(self) -> Path:\\n def print_to_terminal(self) -> None:\\n def save_config(self) -> None:\"\n },\n {\n \"identifier\": \"InputDataset\",\n \"path\": \"nerfstudio/data/datasets/base_dataset.py\",\n \"snippet\": \"class InputDataset(Dataset):\\n \\\"\\\"\\\"Dataset that returns images.\\n\\n Args:\\n dataparser_outputs: description of where and how to read input images.\\n scale_factor: The scaling factor for the dataparser outputs\\n \\\"\\\"\\\"\\n\\n def __init__(self, dataparser_outputs: DataparserOutputs, scale_factor: float = 1.0):\\n super().__init__()\\n self._dataparser_outputs = dataparser_outputs\\n self.has_masks = dataparser_outputs.mask_filenames is not None\\n self.scale_factor = scale_factor\\n self.scene_box = deepcopy(dataparser_outputs.scene_box)\\n self.metadata = deepcopy(dataparser_outputs.metadata)\\n self.cameras = deepcopy(dataparser_outputs.cameras)\\n self.cameras.rescale_output_resolution(scaling_factor=scale_factor)\\n self.image_cache = {}\\n\\n def __len__(self):\\n return len(self._dataparser_outputs.image_filenames)\\n\\n def get_numpy_image(self, image_idx: int) -> npt.NDArray[np.uint8]:\\n \\\"\\\"\\\"Returns the image of shape (H, W, 3 or 4).\\n\\n Args:\\n image_idx: The image index in the dataset.\\n \\\"\\\"\\\"\\n image_filename = self._dataparser_outputs.image_filenames[image_idx]\\n pil_image = Image.open(image_filename)\\n if self.scale_factor != 1.0:\\n width, height = pil_image.size\\n newsize = (int(width * self.scale_factor), int(height * self.scale_factor))\\n pil_image = pil_image.resize(newsize, resample=Image.BILINEAR)\\n image = np.array(pil_image, dtype=\\\"uint8\\\") # shape is (h, w, 3 or 4)\\n # mask_filename = str(image_filename).replace(\\\"dense/images\\\", \\\"masks\\\").replace(\\\".jpg\\\", \\\".npy\\\")\\n # mask = np.load(mask_filename)\\n # image = image * mask[..., None]\\n\\n assert len(image.shape) == 3\\n assert image.dtype == np.uint8\\n assert image.shape[2] in [3, 4], f\\\"Image shape of {image.shape} is in correct.\\\"\\n return image\\n\\n def get_image(self, image_idx: int) -> TensorType[\\\"image_height\\\", \\\"image_width\\\", \\\"num_channels\\\"]:\\n \\\"\\\"\\\"Returns a 3 channel image.\\n\\n Args:\\n image_idx: The image index in the dataset.\\n \\\"\\\"\\\"\\n image = torch.from_numpy(self.get_numpy_image(image_idx).astype(\\\"float32\\\") / 255.0)\\n if self._dataparser_outputs.alpha_color is not None and image.shape[-1] == 4:\\n assert image.shape[-1] == 4\\n image = image[:, :, :3] * image[:, :, -1:] + self._dataparser_outputs.alpha_color * (1.0 - image[:, :, -1:])\\n else:\\n image = image[:, :, :3]\\n return image\\n\\n def get_data(self, image_idx: int) -> Dict:\\n \\\"\\\"\\\"Returns the ImageDataset data as a dictionary.\\n\\n Args:\\n image_idx: The image index in the dataset.\\n \\\"\\\"\\\"\\n if image_idx in self.image_cache:\\n image = self.image_cache[image_idx]\\n else:\\n image = self.get_image(image_idx)\\n self.image_cache[image_idx] = image\\n\\n data = {\\\"image_idx\\\": image_idx, 'image_filename': self._dataparser_outputs.image_filenames[image_idx].name}\\n data[\\\"image\\\"] = image\\n for _, data_func_dict in self._dataparser_outputs.additional_inputs.items():\\n assert \\\"func\\\" in data_func_dict, \\\"Missing function to process data: specify `func` in `additional_inputs`\\\"\\n func = data_func_dict[\\\"func\\\"]\\n assert \\\"kwargs\\\" in data_func_dict, \\\"No data to process: specify `kwargs` in `additional_inputs`\\\"\\n data.update(func(image_idx, **data_func_dict[\\\"kwargs\\\"]))\\n if self.has_masks:\\n mask_filepath = self._dataparser_outputs.mask_filenames[image_idx]\\n data[\\\"mask\\\"] = get_image_mask_tensor_from_path(filepath=mask_filepath, scale_factor=self.scale_factor)\\n metadata = self.get_metadata(data)\\n data.update(metadata)\\n return data\\n\\n # pylint: disable=no-self-use\\n def get_metadata(self, data: Dict) -> Dict:\\n \\\"\\\"\\\"Method that can be used to process any additional metadata that may be part of the model inputs.\\n\\n Args:\\n image_idx: The image index in the dataset.\\n \\\"\\\"\\\"\\n del data\\n return {}\\n\\n def __getitem__(self, image_idx: int) -> Dict:\\n data = self.get_data(image_idx)\\n return data\"\n },\n {\n \"identifier\": \"Model\",\n \"path\": \"nerfstudio/models/base_model.py\",\n \"snippet\": \"class Model(nn.Module):\\n \\\"\\\"\\\"Model class\\n Where everything (Fields, Optimizers, Samplers, Visualization, etc) is linked together. This should be\\n subclassed for custom NeRF model.\\n\\n Args:\\n config: configuration for instantiating model\\n scene_box: dataset scene box\\n \\\"\\\"\\\"\\n\\n config: ModelConfig\\n\\n def __init__(\\n self,\\n config: ModelConfig,\\n scene_box: SceneBox,\\n num_train_data: int,\\n world_size: int = 1,\\n local_rank: int = 0,\\n load_step: int = None, \\n **kwargs,\\n ) -> None:\\n super().__init__()\\n self.config = config\\n self.scene_box = scene_box\\n self.num_train_data = num_train_data\\n self.kwargs = kwargs\\n self.collider = None\\n self.world_size = world_size\\n self.local_rank = local_rank\\n self.load_step = load_step\\n\\n self.populate_modules() # populate the modules\\n self.callbacks = None\\n # to keep track of which device the nn.Module is on\\n self.device_indicator_param = nn.Parameter(torch.empty(0))\\n\\n @property\\n def device(self):\\n \\\"\\\"\\\"Returns the device that the model is on.\\\"\\\"\\\"\\n return self.device_indicator_param.device\\n\\n def get_training_callbacks( # pylint:disable=no-self-use\\n self, training_callback_attributes: TrainingCallbackAttributes # pylint: disable=unused-argument\\n ) -> List[TrainingCallback]:\\n \\\"\\\"\\\"Returns a list of callbacks that run functions at the specified training iterations.\\\"\\\"\\\"\\n return []\\n\\n def populate_modules(self):\\n \\\"\\\"\\\"Set the necessary modules to get the network working.\\\"\\\"\\\"\\n # default instantiates optional modules that are common among many networks\\n # NOTE: call `super().populate_modules()` in subclasses\\n\\n if self.config.enable_collider:\\n self.collider = NearFarCollider(\\n near_plane=self.config.collider_params[\\\"near_plane\\\"], far_plane=self.config.collider_params[\\\"far_plane\\\"]\\n )\\n\\n @abstractmethod\\n def get_param_groups(self) -> Dict[str, List[Parameter]]:\\n \\\"\\\"\\\"Obtain the parameter groups for the optimizers\\n\\n Returns:\\n Mapping of different parameter groups\\n \\\"\\\"\\\"\\n\\n @abstractmethod\\n def get_outputs(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Takes in a Ray Bundle and returns a dictionary of outputs.\\n\\n Args:\\n ray_bundle: Input bundle of rays. This raybundle should have all the\\n needed information to compute the outputs.\\n\\n Returns:\\n Outputs of model. (ie. rendered colors)\\n \\\"\\\"\\\"\\n\\n def forward(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Run forward starting with a ray bundle. This outputs different things depending on the configuration\\n of the model and whether or not the batch is provided (whether or not we are training basically)\\n\\n Args:\\n ray_bundle: containing all the information needed to render that ray latents included\\n \\\"\\\"\\\"\\n\\n if self.collider is not None:\\n ray_bundle = self.collider(ray_bundle)\\n\\n return self.get_outputs(ray_bundle)\\n\\n def get_metrics_dict(self, outputs, batch) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Compute and returns metrics.\\n\\n Args:\\n outputs: the output to compute loss dict to\\n batch: ground truth batch corresponding to outputs\\n \\\"\\\"\\\"\\n # pylint: disable=unused-argument\\n # pylint: disable=no-self-use\\n return {}\\n \\n\\n @abstractmethod\\n def get_loss_dict(self, outputs, batch, metrics_dict=None) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Computes and returns the losses dict.\\n\\n Args:\\n outputs: the output to compute loss dict to\\n batch: ground truth batch corresponding to outputs\\n metrics_dict: dictionary of metrics, some of which we can use for loss\\n \\\"\\\"\\\"\\n \\n def n_parameters(self):\\n return -1.0\\n\\n @torch.no_grad()\\n def get_outputs_for_camera_ray_bundle(self, camera_ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Takes in camera parameters and computes the output of the model.\\n\\n Args:\\n camera_ray_bundle: ray bundle to calculate outputs over\\n \\\"\\\"\\\"\\n num_rays_per_chunk = self.config.eval_num_rays_per_chunk\\n image_height, image_width = camera_ray_bundle.origins.shape[:2]\\n num_rays = len(camera_ray_bundle)\\n outputs_lists = defaultdict(list)\\n for i in range(0, num_rays, num_rays_per_chunk):\\n start_idx = i\\n end_idx = i + num_rays_per_chunk\\n ray_bundle = camera_ray_bundle.get_row_major_sliced_ray_bundle(start_idx, end_idx)\\n outputs = self.forward(ray_bundle=ray_bundle)\\n for output_name, output in outputs.items(): # type: ignore\\n outputs_lists[output_name].append(output)\\n outputs = {}\\n for output_name, outputs_list in outputs_lists.items():\\n if not torch.is_tensor(outputs_list[0]):\\n # TODO: handle lists of tensors as well\\n continue\\n outputs[output_name] = torch.cat(outputs_list).view(image_height, image_width, -1) # type: ignore\\n return outputs\\n\\n @abstractmethod\\n def get_image_metrics_and_images(\\n self, outputs: Dict[str, torch.Tensor], batch: Dict[str, torch.Tensor]\\n ) -> Tuple[Dict[str, float], Dict[str, torch.Tensor]]:\\n \\\"\\\"\\\"Writes the test image outputs.\\n TODO: This shouldn't return a loss\\n\\n Args:\\n image_idx: Index of the image.\\n step: Current step.\\n batch: Batch of data.\\n outputs: Outputs of the model.\\n\\n Returns:\\n A dictionary of metrics.\\n \\\"\\\"\\\"\\n\\n def load_model(self, loaded_state: Dict[str, Any]) -> None:\\n \\\"\\\"\\\"Load the checkpoint from the given path\\n\\n Args:\\n loaded_state: dictionary of pre-trained model states\\n \\\"\\\"\\\"\\n state = {key.replace(\\\"module.\\\", \\\"\\\"): value for key, value in loaded_state[\\\"model\\\"].items()}\\n self.load_state_dict(state) # type: ignore\\n \\n def customized_save(self, step: int, checkpoint_dir) -> None:\\n \\\"\\\"\\\"Call the model's customized save function.\\n\\n Args:\\n step: Current step.\\n checkpoint_dir: directory of checkpoint\\n \\\"\\\"\\\"\\n pass\\n\\n def customized_load(self, load_step: int, checkpoint_dir) -> None:\\n \\\"\\\"\\\"Call the model's customized load function.\\n\\n Args:\\n checkpoint_dir: directory of checkpoint\\n \\\"\\\"\\\"\\n pass\"\n },\n {\n \"identifier\": \"colormaps\",\n \"path\": \"nerfstudio/utils/colormaps.py\",\n \"snippet\": \"def apply_colormap(image: TensorType[\\\"bs\\\":..., 1], cmap=\\\"viridis\\\") -> TensorType[\\\"bs\\\":..., \\\"rgb\\\":3]:\\ndef apply_depth_colormap(\\n depth: TensorType[\\\"bs\\\":..., 1],\\n accumulation: Optional[TensorType[\\\"bs\\\":..., 1]] = None,\\n near_plane: Optional[float] = None,\\n far_plane: Optional[float] = None,\\n cmap=\\\"turbo\\\",\\n) -> TensorType[\\\"bs\\\":..., \\\"rgb\\\":3]:\\ndef apply_boolean_colormap(\\n image: TensorType[\\\"bs\\\":..., 1, bool],\\n true_color: TensorType[\\\"bs\\\":..., \\\"rgb\\\":3] = colors.WHITE,\\n false_color: TensorType[\\\"bs\\\":..., \\\"rgb\\\":3] = colors.BLACK,\\n) -> TensorType[\\\"bs\\\":..., \\\"rgb\\\":3]:\"\n },\n {\n \"identifier\": \"profiler\",\n \"path\": \"nerfstudio/utils/profiler.py\",\n \"snippet\": \"CONSOLE = Console(width=120)\\nPROFILER = []\\ndef time_function(func: Callable) -> Callable:\\n def wrapper(*args, **kwargs):\\ndef flush_profiler(config: cfg.LoggingConfig):\\ndef setup_profiler(config: cfg.LoggingConfig):\\n def __init__(self, config: cfg.LoggingConfig):\\n def update_time(self, func_name: str, start_time: float, end_time: float):\\n def print_profile(self):\\nclass Profiler:\"\n },\n {\n \"identifier\": \"writer\",\n \"path\": \"nerfstudio/utils/writer.py\",\n \"snippet\": \"CONSOLE = Console(width=120)\\nEVENT_WRITERS = []\\nEVENT_STORAGE = []\\nGLOBAL_BUFFER = {}\\n ITER_TRAIN_TIME = \\\"Train Iter (time)\\\"\\n TOTAL_TRAIN_TIME = \\\"Train Total (time)\\\"\\n ITER_VIS_TIME = \\\"Viewer Rendering (time)\\\"\\n ETA = \\\"ETA (time)\\\"\\n TRAIN_RAYS_PER_SEC = \\\"Train Rays / Sec\\\"\\n TEST_RAYS_PER_SEC = \\\"Test Rays / Sec\\\"\\n VIS_RAYS_PER_SEC = \\\"Vis Rays / Sec\\\"\\n CURR_TEST_PSNR = \\\"Test PSNR\\\"\\n IMAGE = \\\"write_image\\\"\\n PLOTLY = \\\"write_plotly\\\"\\n SCALAR = \\\"write_scalar\\\"\\n DICT = \\\"write_scalar_dict\\\"\\n CONFIG = \\\"write_config\\\"\\nclass EventName(enum.Enum):\\nclass EventType(enum.Enum):\\nclass Writer:\\nclass TimeWriter:\\nclass WandbWriter(Writer):\\nclass TensorboardWriter(Writer):\\nclass LocalWriter:\\ndef put_image(name, image: TensorType[\\\"H\\\", \\\"W\\\", \\\"C\\\"], step: int):\\ndef put_plotly(name: str, figure: Any, step: int = 0):\\ndef put_scalar(name: str, scalar: Any, step: int):\\ndef put_dict(name: str, scalar_dict: Dict[str, Any], step: int):\\ndef put_config(name: str, config_dict: Dict[str, Any], step: int):\\ndef put_time(name: str, duration: float, step: int, avg_over_steps: bool = True, update_eta: bool = False):\\ndef write_out_storage():\\ndef setup_local_writer(config: cfg.LoggingConfig, max_iter: int, banner_messages: Optional[List[str]] = None) -> None:\\ndef setup_event_writer(config: cfg.Config, log_dir: Path) -> None:\\n def write_image(self, name: str, image: TensorType[\\\"H\\\", \\\"W\\\", \\\"C\\\"], step: int) -> None:\\n def write_plotly(self, name: str, figure: Any, step: int) -> None:\\n def write_scalar(self, name: str, scalar: Union[float, torch.Tensor], step: int) -> None:\\n def write_scalar_dict(self, name: str, scalar_dict: Dict[str, Any], step: int) -> None:\\n def __init__(self, writer, name, step=None, write=True):\\n def __enter__(self):\\n def __exit__(self, *args):\\n def __init__(self, log_dir: Path, experiment_name: str):\\n def write_image(self, name: str, image: TensorType[\\\"H\\\", \\\"W\\\", \\\"C\\\"], step: int) -> None:\\n def write_plotly(self, name: str, figure: Any, step: int) -> None:\\n def write_scalar(self, name: str, scalar: Union[float, torch.Tensor], step: int) -> None:\\n def write_config(self, name: str, config_dict: Dict[str, Any], step: int):\\n def __init__(self, log_dir: Path):\\n def write_image(self, name: str, image: TensorType[\\\"H\\\", \\\"W\\\", \\\"C\\\"], step: int) -> None:\\n def write_plotly(self, name: str, figure: Any, step: int) -> None:\\n def write_scalar(self, name: str, scalar: Union[float, torch.Tensor], step: int) -> None:\\n def write_config(self, name: str, config_dict: Dict[str, Any], step: int): # pylint: disable=unused-argument\\ndef _cursorup(x: int):\\ndef _format_time(seconds):\\n def __init__(self, config: cfg.LocalWriterConfig, banner_messages: Optional[List[str]] = None):\\n def write_stats_log(self, step: int) -> None:\\n def write_config(self, name: str, config_dict: Dict[str, Any], step: int):\\n def _consolidate_events(self):\\n def _update_header(self, latest_map, new_key):\\n def _print_stats(self, latest_map, padding=\\\" \\\"):\"\n },\n {\n \"identifier\": \"check_main_thread\",\n \"path\": \"nerfstudio/utils/decorators.py\",\n \"snippet\": \"def check_main_thread(func: Callable) -> Callable:\\n \\\"\\\"\\\"Decorator: check if you are on main thread\\\"\\\"\\\"\\n\\n def wrapper(*args, **kwargs):\\n ret = None\\n if comms.is_main_process():\\n ret = func(*args, **kwargs)\\n return ret\\n\\n return wrapper\"\n },\n {\n \"identifier\": \"decorate_all\",\n \"path\": \"nerfstudio/utils/decorators.py\",\n \"snippet\": \"def decorate_all(decorators: List[Callable]) -> Callable:\\n \\\"\\\"\\\"A decorator to decorate all member functions of a class\\n\\n Args:\\n decorators: list of decorators to add to all functions in the class\\n \\\"\\\"\\\"\\n\\n def decorate(cls):\\n for attr in cls.__dict__:\\n if callable(getattr(cls, attr)) and attr != \\\"__init__\\\":\\n for decorator in decorators:\\n setattr(cls, attr, decorator(getattr(cls, attr)))\\n return cls\\n\\n return decorate\"\n },\n {\n \"identifier\": \"BasicImages\",\n \"path\": \"nerfstudio/utils/images.py\",\n \"snippet\": \"class BasicImages:\\n \\\"\\\"\\\"This is a very primitive struct for holding images, especially for when these images\\n are of different heights / widths.\\n\\n The purpose of this is to have a special struct wrapping around a list so that the\\n nerfstudio_collate fn and other parts of the code recognise this as a struct to leave alone\\n instead of reshaping or concatenating into a single tensor (since this will likely be used\\n for cases where we have images of different sizes and shapes).\\n\\n This only has one batch dimension and will likely be replaced down the line with some\\n TensorDataclass alternative that supports arbitrary batches.\\n \\\"\\\"\\\"\\n\\n def __init__(self, images: List):\\n assert isinstance(images, List)\\n assert not images or isinstance(\\n images[0], torch.Tensor\\n ), f\\\"Input should be a list of tensors, not {type(images[0]) if isinstance(images, List) else type(images)}\\\"\\n self.images = images\\n\\n def to(self, device):\\n \\\"\\\"\\\"Move the images to the given device.\\\"\\\"\\\"\\n assert isinstance(device, torch.device)\\n return BasicImages([image.to(device) for image in self.images])\"\n },\n {\n \"identifier\": \"load_from_json\",\n \"path\": \"nerfstudio/utils/io.py\",\n \"snippet\": \"def load_from_json(filename: Path):\\n \\\"\\\"\\\"Load a dictionary from a JSON filename.\\n\\n Args:\\n filename: The filename to load from.\\n \\\"\\\"\\\"\\n assert filename.suffix == \\\".json\\\"\\n with open(filename, encoding=\\\"UTF-8\\\") as file:\\n return json.load(file)\"\n },\n {\n \"identifier\": \"write_to_json\",\n \"path\": \"nerfstudio/utils/io.py\",\n \"snippet\": \"def write_to_json(filename: Path, content: dict):\\n \\\"\\\"\\\"Write data to a JSON file.\\n\\n Args:\\n filename: The filename to write to.\\n content: The dictionary data to write.\\n \\\"\\\"\\\"\\n assert filename.suffix == \\\".json\\\", \\\"Filename must have .json extension but got {}\\\".format(filename)\\n with open(filename, \\\"w\\\", encoding=\\\"UTF-8\\\") as file:\\n json.dump(content, file)\"\n },\n {\n \"identifier\": \"GLOBAL_BUFFER\",\n \"path\": \"nerfstudio/utils/writer.py\",\n \"snippet\": \"GLOBAL_BUFFER = {}\"\n },\n {\n \"identifier\": \"EventName\",\n \"path\": \"nerfstudio/utils/writer.py\",\n \"snippet\": \"class EventName(enum.Enum):\\n \\\"\\\"\\\"Names of possible events that can be logged via Local Writer for convenience.\\n see config/logging/default_logging.yaml\\\"\\\"\\\"\\n\\n ITER_TRAIN_TIME = \\\"Train Iter (time)\\\"\\n TOTAL_TRAIN_TIME = \\\"Train Total (time)\\\"\\n ITER_VIS_TIME = \\\"Viewer Rendering (time)\\\"\\n ETA = \\\"ETA (time)\\\"\\n TRAIN_RAYS_PER_SEC = \\\"Train Rays / Sec\\\"\\n TEST_RAYS_PER_SEC = \\\"Test Rays / Sec\\\"\\n VIS_RAYS_PER_SEC = \\\"Vis Rays / Sec\\\"\\n CURR_TEST_PSNR = \\\"Test PSNR\\\"\"\n },\n {\n \"identifier\": \"TimeWriter\",\n \"path\": \"nerfstudio/utils/writer.py\",\n \"snippet\": \"class TimeWriter:\\n \\\"\\\"\\\"Timer context manager that calculates duration around wrapped functions\\\"\\\"\\\"\\n\\n def __init__(self, writer, name, step=None, write=True):\\n self.writer = writer\\n self.name = name\\n self.step = step\\n self.write = write\\n\\n self.start: float = 0.0\\n self.duration: float = 0.0\\n\\n def __enter__(self):\\n torch.cuda.synchronize()\\n self.start = time()\\n return self\\n\\n def __exit__(self, *args):\\n torch.cuda.synchronize()\\n self.duration = time() - self.start\\n update_step = self.step is not None\\n if self.write:\\n self.writer.put_time(\\n name=self.name,\\n duration=self.duration,\\n step=self.step if update_step else GLOBAL_BUFFER[\\\"max_iter\\\"],\\n avg_over_steps=update_step,\\n update_eta=self.name == EventName.ITER_TRAIN_TIME,\\n )\"\n },\n {\n \"identifier\": \"run_viewer_bridge_server_as_subprocess\",\n \"path\": \"nerfstudio/viewer/server/subprocess.py\",\n \"snippet\": \"def run_viewer_bridge_server_as_subprocess(\\n websocket_port: int,\\n zmq_port: Optional[int] = None,\\n ip_address: str = \\\"127.0.0.1\\\",\\n log_filename: Union[str, None] = None,\\n):\\n \\\"\\\"\\\"Runs the viewer bridge server as a subprocess.\\n\\n Args:\\n zmq_port: Port to use for the ZMQ server.\\n websocket_port: Port to use for the websocket server.\\n ip_address: host to connect to\\n log_filename: Filename to use for the log file. If None, no log file is created.\\n\\n Returns:\\n None\\n \\\"\\\"\\\"\\n args = [sys.executable, \\\"-u\\\", \\\"-m\\\", server.__name__]\\n\\n # find an available port for zmq\\n if zmq_port is None:\\n sock = socket.socket()\\n sock.bind((\\\"\\\", 0))\\n zmq_port = sock.getsockname()[1]\\n string = f\\\"Using ZMQ port: {zmq_port}\\\"\\n CONSOLE.print(f\\\"[bold yellow]{string}\\\")\\n\\n args.append(\\\"--zmq-port\\\")\\n args.append(str(zmq_port))\\n args.append(\\\"--websocket-port\\\")\\n args.append(str(websocket_port))\\n args.append(\\\"--ip-address\\\")\\n args.append(str(ip_address))\\n # supress output if no log filename is specified\\n logfile = open( # pylint: disable=consider-using-with\\n log_filename if log_filename else os.devnull, \\\"w\\\", encoding=\\\"utf8\\\"\\n )\\n process = subprocess.Popen( # pylint: disable=consider-using-with\\n args, stdout=logfile, stderr=logfile, start_new_session=True\\n )\\n\\n def cleanup(process):\\n process.kill()\\n process.wait()\\n\\n def poll_process():\\n \\\"\\\"\\\"\\n Continually check to see if the viewer bridge server process is still running and has not failed.\\n If it fails, alert the user and exit the entire program.\\n \\\"\\\"\\\"\\n while process.poll() is None:\\n time.sleep(0.5)\\n string = f\\\"\\\\nThe viewer bridge server subprocess failed. Please check the log file {log_filename}.\\\\n\\\"\\n string += (\\n \\\"You likely have to modify --viewer.zmq-port and/or --viewer.websocket-port in the \\\"\\n \\\"config to avoid conflicting ports.\\\\n\\\"\\n )\\n string += \\\"Try modifying --viewer.websocket-port 7007\\\\n\\\"\\n CONSOLE.print(f\\\"[bold red]{string}\\\")\\n cleanup(process)\\n # This exists the entire program. sys.exit() will only kill the thread that this runs in.\\n os.kill(os.getpid(), signal.SIGKILL)\\n\\n # continually check to see if the process stopped\\n t1 = threading.Thread(target=poll_process)\\n t1.daemon = True\\n t1.start()\\n atexit.register(cleanup, process)\\n return zmq_port\"\n },\n {\n \"identifier\": \"get_intrinsics_matrix_and_camera_to_world_h\",\n \"path\": \"nerfstudio/viewer/server/utils.py\",\n \"snippet\": \"def get_intrinsics_matrix_and_camera_to_world_h(\\n camera_object: Dict[str, Any], image_height: int\\n) -> Tuple[torch.Tensor, torch.Tensor]:\\n \\\"\\\"\\\"Returns the camera intrinsics matrix and the camera to world homogeneous matrix.\\n\\n Args:\\n camera_object: a Camera object.\\n image_size: the size of the image (height, width)\\n \\\"\\\"\\\"\\n # intrinsics\\n fov = camera_object[\\\"fov\\\"]\\n aspect = camera_object[\\\"aspect\\\"]\\n image_width = aspect * image_height\\n pp_w = image_width / 2.0\\n pp_h = image_height / 2.0\\n focal_length = three_js_perspective_camera_focal_length(fov, image_height)\\n intrinsics_matrix = torch.tensor([[focal_length, 0, pp_w], [0, focal_length, pp_h], [0, 0, 1]]).float()\\n\\n # extrinsics\\n camera_to_world_h = torch.tensor(get_chunks(camera_object[\\\"matrix\\\"], size_of_chunk=4)).T.float()\\n camera_to_world_h = torch.stack(\\n [\\n camera_to_world_h[0, :],\\n camera_to_world_h[2, :],\\n camera_to_world_h[1, :],\\n camera_to_world_h[3, :],\\n ],\\n dim=0,\\n )\\n\\n return intrinsics_matrix, camera_to_world_h\"\n },\n {\n \"identifier\": \"Viewer\",\n \"path\": \"nerfstudio/viewer/server/visualizer.py\",\n \"snippet\": \"class Viewer:\\n \\\"\\\"\\\"Viewer class for connecting to the bridge server.\\n\\n Args:\\n zmq_port: Where to connect with ZMQ.\\n window: An already existing ViewerWindow.\\n ip_address: The ip address of the bridge server.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self, zmq_port: Optional[int] = None, window: Optional[ViewerWindow] = None, ip_address: str = \\\"127.0.0.1\\\"\\n ):\\n if zmq_port is None and window is None:\\n raise ValueError(\\\"Must specify either zmq_port or window.\\\")\\n if window is None:\\n self.window = ViewerWindow(zmq_port=zmq_port, ip_address=ip_address)\\n else:\\n self.window = window\\n self.path = Path(())\\n\\n @staticmethod\\n def view_into(window: ViewerWindow, path: Path):\\n \\\"\\\"\\\"Returns a new Viewer but keeping the same ViewerWindow.\\\"\\\"\\\"\\n vis = Viewer(window=window)\\n vis.path = path\\n return vis\\n\\n def __getitem__(self, path):\\n return Viewer.view_into(self.window, self.path.append(path))\\n\\n def __repr__(self):\\n return f\\\"<Viewer using: {self.window} at path: {self.path}>\\\"\\n\\n def write(self, data: Union[Dict, str, None] = None):\\n \\\"\\\"\\\"Write data.\\\"\\\"\\\"\\n path = self.path.lower()\\n return self.window.send({\\\"type\\\": \\\"write\\\", \\\"path\\\": path, \\\"data\\\": data})\\n\\n def read(self):\\n \\\"\\\"\\\"Read data.\\\"\\\"\\\"\\n path = self.path.lower()\\n return self.window.send({\\\"type\\\": \\\"read\\\", \\\"path\\\": path})\\n\\n def delete(self):\\n \\\"\\\"\\\"Delete data.\\\"\\\"\\\"\\n return self.write(data=None)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import base64\nimport enum\nimport os\nimport sys\nimport threading\nimport time\nimport warnings\nimport cv2\nimport numpy as np\nimport torch\nfrom pathlib import Path\nfrom typing import Any, Dict, Optional, Tuple\nfrom cryptography.utils import CryptographyDeprecationWarning\nfrom rich.console import Console\nfrom nerfstudio.cameras.cameras import Cameras\nfrom nerfstudio.cameras.rays import RayBundle\nfrom nerfstudio.configs import base_config as cfg\nfrom nerfstudio.data.datasets.base_dataset import InputDataset\nfrom nerfstudio.models.base_model import Model\nfrom nerfstudio.utils import colormaps, profiler, writer\nfrom nerfstudio.utils.decorators import check_main_thread, decorate_all\nfrom nerfstudio.utils.images import BasicImages\nfrom nerfstudio.utils.io import load_from_json, write_to_json\nfrom nerfstudio.utils.writer import GLOBAL_BUFFER, EventName, TimeWriter\nfrom nerfstudio.viewer.server.subprocess import run_viewer_bridge_server_as_subprocess\nfrom nerfstudio.viewer.server.utils import get_intrinsics_matrix_and_camera_to_world_h\nfrom nerfstudio.viewer.server.visualizer import Viewer"},"token_num":{"kind":"number","value":21585,"string":"21,585"},"cropped_code":{"kind":"string","value":"\n if self.prev_camera_matrix is not None and np.allclose(camera_object[\"matrix\"], self.prev_camera_matrix):\n self.camera_moving = False\n else:\n self.prev_camera_matrix = camera_object[\"matrix\"]\n self.camera_moving = True\n\n output_type = self.vis[\"renderingState/output_choice\"].read()\n if output_type is None:\n output_type = OutputTypes.INIT\n if self.prev_output_type != output_type:\n self.camera_moving = True\n\n colormap_type = self.vis[\"renderingState/colormap_choice\"].read()\n if colormap_type is None:\n colormap_type = ColormapTypes.INIT\n if self.prev_colormap_type != colormap_type:\n self.camera_moving = True\n\n return camera_object\n\n def _apply_colormap(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):\n \"\"\"Determines which colormap to use based on set colormap type\n\n Args:\n outputs: the output tensors for which to apply colormaps on\n colors: is only set if colormap is for semantics. Defaults to None.\n eps: epsilon to handle floating point comparisons\n \"\"\"\n if self.output_list:\n reformatted_output = self._process_invalid_output(self.prev_output_type)\n\n # default for rgb images\n if self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].shape[-1] == 3:\n return outputs[reformatted_output]\n\n # rendering depth outputs\n if self.prev_colormap_type == ColormapTypes.DEPTH or (\n self.prev_colormap_type == ColormapTypes.DEFAULT\n and outputs[reformatted_output].dtype == torch.float\n and (torch.max(outputs[reformatted_output]) - 1.0) > eps # handle floating point arithmetic\n ):\n accumulation_str = (\n OutputTypes.ACCUMULATION\n if OutputTypes.ACCUMULATION in self.output_list\n else OutputTypes.ACCUMULATION_FINE\n )\n return colormaps.apply_depth_colormap(outputs[reformatted_output], accumulation=outputs[accumulation_str])\n\n # rendering accumulation outputs\n if self.prev_colormap_type == ColormapTypes.TURBO or (\n self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.float\n ):\n return colormaps.apply_colormap(outputs[reformatted_output])\n\n # rendering semantic outputs\n if self.prev_colormap_type == ColormapTypes.SEMANTIC or (\n self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.int\n ):\n logits = outputs[reformatted_output]\n labels = torch.argmax(torch.nn.functional.softmax(logits, dim=-1), dim=-1) # type: ignore\n assert colors is not None\n return colors[labels]\n\n # rendering boolean outputs\n if self.prev_colormap_type == ColormapTypes.BOOLEAN or (\n self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.bool\n ):\n return colormaps.apply_boolean_colormap(outputs[reformatted_output])\n\n raise NotImplementedError\n\n def _send_output_to_viewer(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):\n \"\"\"Chooses the correct output and sends it to the viewer\n\n Args:\n outputs: the dictionary of outputs to choose from, from the graph\n colors: is only set if colormap is for semantics. Defaults to None.\n eps: epsilon to handle floating point comparisons\n \"\"\"\n if self.output_list is None:\n self.output_list = list(outputs.keys())\n viewer_output_list = list(np.copy(self.output_list))\n # remapping rgb_fine -> rgb for all cases just so that we dont have 2 of them in the options\n if OutputTypes.RGB_FINE in self.output_list:\n viewer_output_list.remove(OutputTypes.RGB_FINE)\n viewer_output_list.insert(0, OutputTypes.RGB)\n self.vis[\"renderingState/output_options\"].write(viewer_output_list)\n\n reformatted_output = self._process_invalid_output(self.prev_output_type)\n # re-register colormaps and send to viewer\n if self.output_type_changed or self.prev_colormap_type == ColormapTypes.INIT:\n self.prev_colormap_type = ColormapTypes.DEFAULT\n colormap_options = [ColormapTypes.DEFAULT]\n if (\n outputs[reformatted_output].shape[-1] != 3\n and outputs[reformatted_output].dtype == torch.float\n and (torch.max(outputs[reformatted_output]) - 1.0) <= eps # handle floating point arithmetic\n ):\n # accumulation can also include depth\n colormap_options.extend([\"depth\"])\n self.output_type_changed = False\n self.vis[\"renderingState/colormap_choice\"].write(self.prev_colormap_type)\n self.vis[\"renderingState/colormap_options\"].write(colormap_options)\n selected_output = (self._apply_colormap(outputs, colors) * 255).type(torch.uint8)\n image = selected_output[..., [2, 1, 0]].cpu().numpy()\n\n data = cv2.imencode(\".jpg\", image, [cv2.IMWRITE_JPEG_QUALITY, 75])[1].tobytes()\n data = str(\"data:image/jpeg;base64,\" + base64.b64encode(data).decode(\"ascii\"))\n self.vis[\"render_img\"].write(data)\n\n def _update_viewer_stats(self, render_time: float, num_rays: int, image_height: int, image_width: int) -> None:\n \"\"\"Function that calculates and populates all the rendering statistics accordingly\n\n Args:\n render_time: total time spent rendering current view\n num_rays: number of rays rendered\n image_height: resolution of the current view\n image_width: resolution of the current view\n \"\"\"\n"},"all_code":{"kind":"string","value":"# Copyright 2022 The Nerfstudio Team. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n\"\"\"Code to interface with the `vis/` (the JS viewer).\n\"\"\"\nfrom __future__ import annotations\n\n\n\n\nwarnings.filterwarnings(\"ignore\", category=CryptographyDeprecationWarning)\n\nCONSOLE = Console(width=120)\n\n\ndef get_viewer_version() -> str:\n \"\"\"Get the version of the viewer.\"\"\"\n json_filename = os.path.join(os.path.dirname(__file__), \"../app/package.json\")\n version = load_from_json(Path(json_filename))[\"version\"]\n return version\n\n\n@check_main_thread\ndef setup_viewer(config: cfg.ViewerConfig, log_filename: Path):\n \"\"\"Sets up the viewer if enabled\n\n Args:\n config: the configuration to instantiate viewer\n \"\"\"\n viewer_state = ViewerState(config, log_filename=log_filename)\n banner_messages = [f\"Viewer at: {viewer_state.viewer_url}\"]\n return viewer_state, banner_messages\n\n\nclass OutputTypes(str, enum.Enum):\n \"\"\"Noncomprehsnive list of output render types\"\"\"\n\n INIT = \"init\"\n RGB = \"rgb\"\n RGB_FINE = \"rgb_fine\"\n ACCUMULATION = \"accumulation\"\n ACCUMULATION_FINE = \"accumulation_fine\"\n\n\nclass ColormapTypes(str, enum.Enum):\n \"\"\"Noncomprehsnive list of colormap render types\"\"\"\n\n INIT = \"init\"\n DEFAULT = \"default\"\n TURBO = \"turbo\"\n DEPTH = \"depth\"\n SEMANTIC = \"semantic\"\n BOOLEAN = \"boolean\"\n\n\nclass IOChangeException(Exception):\n \"\"\"Basic camera exception to interrupt viewer\"\"\"\n\n\nclass SetTrace:\n \"\"\"Basic trace function\"\"\"\n\n def __init__(self, func):\n self.func = func\n\n def __enter__(self):\n sys.settrace(self.func)\n return self\n\n def __exit__(self, ext_type, exc_value, traceback):\n sys.settrace(None)\n\n\nclass RenderThread(threading.Thread):\n \"\"\"Thread that does all the rendering calls while listening for interrupts\n\n Args:\n state: current viewer state object\n graph: current checkpoint of model\n camera_ray_bundle: input rays to pass through the graph to render out\n \"\"\"\n\n def __init__(self, state: \"ViewerState\", graph: Model, camera_ray_bundle: RayBundle):\n threading.Thread.__init__(self)\n self.state = state\n self.graph = graph\n self.camera_ray_bundle = camera_ray_bundle\n self.exc = None\n self.vis_outputs = None\n\n def run(self):\n \"\"\"run function that renders out images given the current graph and ray bundles.\n Interlaced with a trace function that checks to see if any I/O changes were registered.\n Exits and continues program if IOChangeException thrown.\n \"\"\"\n outputs = None\n try:\n with SetTrace(self.state.check_interrupt):\n with torch.no_grad():\n outputs = self.graph.get_outputs_for_camera_ray_bundle(self.camera_ray_bundle)\n except Exception as e: # pylint: disable=broad-except\n self.exc = e\n\n if outputs:\n self.vis_outputs = outputs\n\n self.state.check_done_render = True\n self.state.check_interrupt_vis = False\n\n def join(self, timeout=None):\n threading.Thread.join(self)\n if self.exc:\n raise self.exc\n\n\nclass CheckThread(threading.Thread):\n \"\"\"Thread the constantly checks for io changes and sets a flag indicating interrupt\n\n Args:\n state: current viewer state object\n \"\"\"\n\n def __init__(self, state):\n threading.Thread.__init__(self)\n self.state = state\n\n def run(self):\n \"\"\"Run function that checks to see if any of the existing state has changed\n (e.g. camera pose/output type/resolutions).\n Sets the viewer state flag to true to signal\n to render thread that an interrupt was registered.\n \"\"\"\n self.state.check_done_render = False\n while not self.state.check_done_render:\n # check camera\n data = self.state.vis[\"renderingState/camera\"].read()\n if data is not None:\n camera_object = data[\"object\"]\n if self.state.prev_camera_matrix is None or (\n not np.allclose(camera_object[\"matrix\"], self.state.prev_camera_matrix)\n and not self.state.prev_moving\n ):\n self.state.check_interrupt_vis = True\n self.state.prev_moving = True\n return\n self.state.prev_moving = False\n\n # check output type\n output_type = self.state.vis[\"renderingState/output_choice\"].read()\n if output_type is None:\n output_type = OutputTypes.INIT\n if self.state.prev_output_type != output_type:\n self.state.check_interrupt_vis = True\n return\n\n # check colormap type\n colormap_type = self.state.vis[\"renderingState/colormap_choice\"].read()\n if colormap_type is None:\n colormap_type = ColormapTypes.INIT\n if self.state.prev_colormap_type != colormap_type:\n self.state.check_interrupt_vis = True\n return\n\n # check max render\n max_resolution = self.state.vis[\"renderingState/maxResolution\"].read()\n if max_resolution is not None:\n if self.state.max_resolution != max_resolution:\n self.state.check_interrupt_vis = True\n return\n\n\n@decorate_all([check_main_thread])\nclass ViewerState:\n \"\"\"Class to hold state for viewer variables\n\n Args:\n config: viewer setup configuration\n \"\"\"\n\n def __init__(self, config: cfg.ViewerConfig, log_filename: Path):\n self.config = config\n self.vis = None\n self.viewer_url = None\n self.log_filename = log_filename\n if self.config.launch_bridge_server:\n # start the viewer bridge server\n assert self.config.websocket_port is not None\n self.log_filename.parent.mkdir(exist_ok=True)\n zmq_port = run_viewer_bridge_server_as_subprocess(\n self.config.websocket_port,\n zmq_port=self.config.zmq_port,\n ip_address=self.config.ip_address,\n log_filename=str(self.log_filename),\n )\n # TODO(ethan): log the output of the viewer bridge server in a file where the training logs go\n CONSOLE.line()\n version = get_viewer_version()\n websocket_url = f\"ws://localhost:{self.config.websocket_port}\"\n self.viewer_url = f\"https://viewer.nerf.studio/versions/{version}/?websocket_url={websocket_url}\"\n CONSOLE.rule(characters=\"=\")\n CONSOLE.print(f\"[Public] Open the viewer at {self.viewer_url}\")\n CONSOLE.rule(characters=\"=\")\n CONSOLE.line()\n self.vis = Viewer(zmq_port=zmq_port, ip_address=self.config.ip_address)\n else:\n assert self.config.zmq_port is not None\n self.vis = Viewer(zmq_port=self.config.zmq_port, ip_address=self.config.ip_address)\n\n # viewer specific variables\n self.prev_camera_matrix = None\n self.prev_output_type = OutputTypes.INIT\n self.prev_colormap_type = ColormapTypes.INIT\n self.prev_moving = False\n self.output_type_changed = True\n self.max_resolution = 1000\n self.check_interrupt_vis = False\n self.check_done_render = True\n self.step = 0\n self.static_fps = 1\n self.moving_fps = 24\n self.camera_moving = False\n self.prev_camera_timestamp = 0\n self.probe_config = None\n\n self.output_list = None\n\n def _pick_drawn_image_idxs(self, total_num: int) -> list[int]:\n \"\"\"Determine indicies of images to display in viewer.\n\n Args:\n total_num: total number of training images.\n\n Returns:\n List of indices from [0, total_num-1].\n \"\"\"\n if self.config.max_num_display_images < 0:\n num_display_images = total_num\n else:\n num_display_images = min(self.config.max_num_display_images, total_num)\n # draw indices, roughly evenly spaced\n return np.linspace(0, total_num - 1, num_display_images, dtype=np.int32).tolist()\n\n def init_scene(self, dataset: InputDataset, start_train=True) -> None:\n \"\"\"Draw some images and the scene aabb in the viewer.\n\n Args:\n dataset: dataset to render in the scene\n start_train: whether to start train when viewer init;\n if False, only displays dataset until resume train is toggled\n \"\"\"\n # set the config base dir\n self.vis[\"renderingState/config_base_dir\"].write(str(self.log_filename.parents[0]))\n\n # clear the current scene\n self.vis[\"sceneState/sceneBox\"].delete()\n self.vis[\"sceneState/cameras\"].delete()\n\n # draw the training cameras and images\n image_indices = self._pick_drawn_image_idxs(len(dataset))\n for idx in image_indices:\n image = dataset[idx][\"image\"]\n if isinstance(image, BasicImages):\n bgr = image.images[0][..., [2, 1, 0]]\n else:\n bgr = image[..., [2, 1, 0]]\n camera_json = dataset.cameras.to_json(camera_idx=idx, image=bgr, max_size=100)\n self.vis[f\"sceneState/cameras/{idx:06d}\"].write(camera_json)\n\n # draw the scene box (i.e., the bounding box)\n json_ = dataset.scene_box.to_json()\n self.vis[\"sceneState/sceneBox\"].write(json_)\n\n # set the initial state whether to train or not\n self.vis[\"renderingState/isTraining\"].write(start_train)\n\n # self.vis[\"renderingState/render_time\"].write(str(0))\n self.probe_config = dataset.cameras.probe_config\n\n # set the properties of the camera\n # self.vis[\"renderingState/camera\"].write(json_)\n\n # set the main camera intrinsics to one from the dataset\n # K = camera.get_intrinsics_matrix()\n # set_persp_intrinsics_matrix(self.vis, K.double().numpy())\n\n def _check_camera_path_payload(self, trainer, step: int):\n \"\"\"Check to see if the camera path export button was pressed.\"\"\"\n # check if we should interrupt from a button press?\n camera_path_payload = self.vis[\"camera_path_payload\"].read()\n if camera_path_payload:\n # save a model checkpoint\n trainer.save_checkpoint(step)\n # write to json file\n camera_path_filename = camera_path_payload[\"camera_path_filename\"] + '.json'\n camera_path = camera_path_payload[\"camera_path\"]\n write_to_json(Path(camera_path_filename), camera_path)\n self.vis[\"camera_path_payload\"].delete()\n\n def update_scene(self, trainer, step: int, graph: Model, num_rays_per_batch: int) -> None:\n \"\"\"updates the scene based on the graph weights\n\n Args:\n step: iteration step of training\n graph: the current checkpoint of the model\n \"\"\"\n\n has_temporal_distortion = getattr(graph, \"temporal_distortion\", None) is not None\n self.vis[\"model/has_temporal_distortion\"].write(str(has_temporal_distortion).lower())\n\n is_training = self.vis[\"renderingState/isTraining\"].read()\n self.step = step\n\n self._check_camera_path_payload(trainer, step)\n\n camera_object = self._get_camera_object()\n if camera_object is None:\n return\n\n if is_training is None or is_training:\n # in training mode\n\n if self.camera_moving:\n # if the camera is moving, then we pause training and update camera continuously\n\n while self.camera_moving:\n self._render_image_in_viewer(camera_object, graph, is_training)\n camera_object = self._get_camera_object()\n else:\n # if the camera is not moving, then we approximate how many training steps need to be taken\n # to render at a FPS defined by self.static_fps.\n\n if EventName.TRAIN_RAYS_PER_SEC.value in GLOBAL_BUFFER[\"events\"]:\n train_rays_per_sec = GLOBAL_BUFFER[\"events\"][EventName.TRAIN_RAYS_PER_SEC.value][\"avg\"]\n target_train_util = self.vis[\"renderingState/targetTrainUtil\"].read()\n if target_train_util is None:\n target_train_util = 0.9\n\n batches_per_sec = train_rays_per_sec / num_rays_per_batch\n\n num_steps = max(int(1 / self.static_fps * batches_per_sec), 1)\n else:\n num_steps = 1\n\n if step % num_steps == 0:\n self._render_image_in_viewer(camera_object, graph, is_training)\n\n else:\n # in pause training mode, enter render loop with set graph\n local_step = step\n run_loop = not is_training\n while run_loop:\n # if self._is_render_step(local_step) and step > 0:\n if step > 0:\n self._render_image_in_viewer(camera_object, graph, is_training)\n camera_object = self._get_camera_object()\n is_training = self.vis[\"renderingState/isTraining\"].read()\n self._check_camera_path_payload(trainer, step)\n run_loop = not is_training\n local_step += 1\n\n def check_interrupt(self, frame, event, arg): # pylint: disable=unused-argument\n \"\"\"Raises interrupt when flag has been set and not already on lowest resolution.\n Used in conjunction with SetTrace.\n \"\"\"\n if event == \"line\":\n if self.check_interrupt_vis and not self.camera_moving:\n raise IOChangeException\n return self.check_interrupt\n\n def _get_camera_object(self):\n \"\"\"Gets the camera object from the viewer and updates the movement state if it has changed.\"\"\"\n\n data = self.vis[\"renderingState/camera\"].read()\n if data is None:\n return None\n\n camera_object = data[\"object\"]\n\n if self.prev_camera_matrix is not None and np.allclose(camera_object[\"matrix\"], self.prev_camera_matrix):\n self.camera_moving = False\n else:\n self.prev_camera_matrix = camera_object[\"matrix\"]\n self.camera_moving = True\n\n output_type = self.vis[\"renderingState/output_choice\"].read()\n if output_type is None:\n output_type = OutputTypes.INIT\n if self.prev_output_type != output_type:\n self.camera_moving = True\n\n colormap_type = self.vis[\"renderingState/colormap_choice\"].read()\n if colormap_type is None:\n colormap_type = ColormapTypes.INIT\n if self.prev_colormap_type != colormap_type:\n self.camera_moving = True\n\n return camera_object\n\n def _apply_colormap(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):\n \"\"\"Determines which colormap to use based on set colormap type\n\n Args:\n outputs: the output tensors for which to apply colormaps on\n colors: is only set if colormap is for semantics. Defaults to None.\n eps: epsilon to handle floating point comparisons\n \"\"\"\n if self.output_list:\n reformatted_output = self._process_invalid_output(self.prev_output_type)\n\n # default for rgb images\n if self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].shape[-1] == 3:\n return outputs[reformatted_output]\n\n # rendering depth outputs\n if self.prev_colormap_type == ColormapTypes.DEPTH or (\n self.prev_colormap_type == ColormapTypes.DEFAULT\n and outputs[reformatted_output].dtype == torch.float\n and (torch.max(outputs[reformatted_output]) - 1.0) > eps # handle floating point arithmetic\n ):\n accumulation_str = (\n OutputTypes.ACCUMULATION\n if OutputTypes.ACCUMULATION in self.output_list\n else OutputTypes.ACCUMULATION_FINE\n )\n return colormaps.apply_depth_colormap(outputs[reformatted_output], accumulation=outputs[accumulation_str])\n\n # rendering accumulation outputs\n if self.prev_colormap_type == ColormapTypes.TURBO or (\n self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.float\n ):\n return colormaps.apply_colormap(outputs[reformatted_output])\n\n # rendering semantic outputs\n if self.prev_colormap_type == ColormapTypes.SEMANTIC or (\n self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.int\n ):\n logits = outputs[reformatted_output]\n labels = torch.argmax(torch.nn.functional.softmax(logits, dim=-1), dim=-1) # type: ignore\n assert colors is not None\n return colors[labels]\n\n # rendering boolean outputs\n if self.prev_colormap_type == ColormapTypes.BOOLEAN or (\n self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.bool\n ):\n return colormaps.apply_boolean_colormap(outputs[reformatted_output])\n\n raise NotImplementedError\n\n def _send_output_to_viewer(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):\n \"\"\"Chooses the correct output and sends it to the viewer\n\n Args:\n outputs: the dictionary of outputs to choose from, from the graph\n colors: is only set if colormap is for semantics. Defaults to None.\n eps: epsilon to handle floating point comparisons\n \"\"\"\n if self.output_list is None:\n self.output_list = list(outputs.keys())\n viewer_output_list = list(np.copy(self.output_list))\n # remapping rgb_fine -> rgb for all cases just so that we dont have 2 of them in the options\n if OutputTypes.RGB_FINE in self.output_list:\n viewer_output_list.remove(OutputTypes.RGB_FINE)\n viewer_output_list.insert(0, OutputTypes.RGB)\n self.vis[\"renderingState/output_options\"].write(viewer_output_list)\n\n reformatted_output = self._process_invalid_output(self.prev_output_type)\n # re-register colormaps and send to viewer\n if self.output_type_changed or self.prev_colormap_type == ColormapTypes.INIT:\n self.prev_colormap_type = ColormapTypes.DEFAULT\n colormap_options = [ColormapTypes.DEFAULT]\n if (\n outputs[reformatted_output].shape[-1] != 3\n and outputs[reformatted_output].dtype == torch.float\n and (torch.max(outputs[reformatted_output]) - 1.0) <= eps # handle floating point arithmetic\n ):\n # accumulation can also include depth\n colormap_options.extend([\"depth\"])\n self.output_type_changed = False\n self.vis[\"renderingState/colormap_choice\"].write(self.prev_colormap_type)\n self.vis[\"renderingState/colormap_options\"].write(colormap_options)\n selected_output = (self._apply_colormap(outputs, colors) * 255).type(torch.uint8)\n image = selected_output[..., [2, 1, 0]].cpu().numpy()\n\n data = cv2.imencode(\".jpg\", image, [cv2.IMWRITE_JPEG_QUALITY, 75])[1].tobytes()\n data = str(\"data:image/jpeg;base64,\" + base64.b64encode(data).decode(\"ascii\"))\n self.vis[\"render_img\"].write(data)\n\n def _update_viewer_stats(self, render_time: float, num_rays: int, image_height: int, image_width: int) -> None:\n \"\"\"Function that calculates and populates all the rendering statistics accordingly\n\n Args:\n render_time: total time spent rendering current view\n num_rays: number of rays rendered\n image_height: resolution of the current view\n image_width: resolution of the current view\n \"\"\""},"next_line":{"kind":"string","value":" writer.put_time("},"gold_snippet_index":{"kind":"number","value":7,"string":"7"},"created_at":{"kind":"string","value":"2023-12-15 20:07:22+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5671,"cells":{"repo_name":{"kind":"string","value":"amazon-science/c2f-seg"},"file_path":{"kind":"string","value":"data/dataloader_transformer.py"},"context":{"kind":"list like","value":[{"identifier":"FishBowl","path":"data/dataloader_Fishbowl.py","snippet":"class FishBowl(object):\n def __init__(self, config, mode, subtest=None):\n self.datatype = mode\n data_dir = config.root_path\n\n self.img_path = os.path.join(data_dir, self.datatype+\"_data\", self.datatype+\"_frames\")\n self.mode = mode\n self.dtype = torch.float32\n self.test_set = subtest\n \n self.data_summary = pickle.load(open(os.path.join(data_dir, self.datatype+\"_data\", self.datatype+\"_data.pkl\"), \"rb\"))\n self.obj_lists = list(self.data_summary.keys())\n self.device = \"cpu\"\n\n self.seq_len = 32 if self.mode == \"test\" else config.train_seq_len\n\n self.cur_vid = None\n self.video_frames = None\n self.patch_h = config.patch_H\n self.patch_w = config.patch_W\n self.enlarge_coef = config.enlarge_coef\n\n def decode2binarymask(self, masks):\n mask = mask_utils.decode(masks)\n binary_masks = mask.astype('bool') # (Image_W,Image_H,128)\n binary_masks = binary_masks.transpose(2,0,1) #(128, Image_W, Image_H)\n return binary_masks\n\n def __len__(self):\n return len(self.obj_lists)\n\n def __getitem__(self, idx):\n v_id, obj_id = self.obj_lists[idx].split(\"_\")\n if v_id != self.cur_vid:\n self.cur_vid = v_id\n fm_crop = []\n fm_no_crop = []\n vm_crop = []\n vm_no_crop = []\n img_crop = []\n \n obj_position = []\n\n counts = []\n loss_mask_weight = []\n\n # for evaluation \n video_ids = []\n object_ids = []\n frame_ids = []\n\n obj_dict = self.data_summary[self.obj_lists[idx]]\n timesteps = list(obj_dict.keys())\n assert np.all(np.diff(sorted(timesteps))==1)\n start_t, end_t = min(timesteps), max(timesteps)\n # print(start_t, end_t)\n if self.mode != \"test\" and end_t - start_t > self.seq_len - 1:\n start_t = np.random.randint(start_t, end_t-(self.seq_len-2))\n end_t = start_t + self.seq_len - 1\n\n if self.mode == \"test\":\n if start_t + self.seq_len-1<=end_t:\n end_t = start_t + self.seq_len-1\n\n for t_step in range(start_t, end_t):\n image_path = os.path.join(self.img_path, v_id, str(t_step).zfill(5)+'.png')\n img = cv2.imread(image_path)[:,:,::-1]\n # get visible mask and full mask\n vm = self.decode2binarymask(obj_dict[t_step][\"VM\"])[0]\n fm = self.decode2binarymask(obj_dict[t_step][\"FM\"])[0] # 320, 480\n vx_min, vx_max, vy_min, vy_max = obj_dict[t_step][\"VM_bx\"]\n x_center = (vx_min + vx_max) // 2\n y_center = (vy_min + vy_max) // 2\n x_len = int((vx_max - vx_min) * self.enlarge_coef)\n y_len = int((vy_max - vy_min) * self.enlarge_coef)\n vx_min = max(0, x_center - x_len // 2)\n vx_max = min(320, x_center + x_len // 2)\n vy_min = max(0, y_center - y_len // 2)\n vy_max = min(480, y_center + y_len // 2)\n\n obj_position.append([vx_min, vx_max, vy_min, vy_max])\n vm_crop.append(vm[vx_min:vx_max+1, vy_min:vy_max+1])\n fm_crop.append(fm[vx_min:vx_max+1, vy_min:vy_max+1])\n img_crop.append(img[vx_min:vx_max+1, vy_min:vy_max+1])\n\n vm_no_crop.append(vm)\n fm_no_crop.append(fm)\n # get loss mask\n loss_mask_weight.append(self.decode2binarymask(obj_dict[t_step][\"loss_mask_weight\"])[0])\n\n # for evaluation\n video_ids.append(int(v_id))\n object_ids.append(int(obj_id))\n frame_ids.append(t_step)\n counts.append(1)\n \n if True:\n num_pad = self.seq_len - (end_t - start_t)\n for _ in range(num_pad):\n obj_position.append(copy.deepcopy(obj_position[-1]))\n\n fm_crop.append(copy.deepcopy(fm_crop[-1]))\n fm_no_crop.append(copy.deepcopy(fm_no_crop[-1]))\n vm_crop.append(copy.deepcopy(vm_crop[-1]))\n vm_no_crop.append(copy.deepcopy(vm_no_crop[-1]))\n img_crop.append(copy.deepcopy(img_crop[-1]))\n\n loss_mask_weight.append(copy.deepcopy(loss_mask_weight[-1]))\n \n video_ids.append(video_ids[-1])\n object_ids.append(object_ids[-1])\n frame_ids.append(frame_ids[-1] + 1)\n counts.append(0)\n \n vm_crop, vm_crop_gt, fm_crop, img_crop, vm_pad, vm_scale = self.crop_and_rescale(vm_crop, fm_crop, img_crop)\n\n vm_crop = np.stack(vm_crop, axis=0) # Seq_len * h * w\n vm_crop_gt = np.stack(vm_crop_gt, axis=0) # Seq_len * h * w\n vm_no_crop = np.stack(vm_no_crop, axis=0) # Seq_len * H * W\n fm_crop = np.stack(fm_crop, axis=0) # Seq_len * h * w\n fm_no_crop = np.stack(fm_no_crop, axis=0) # Seq_len * H * W\n\n vm_crop = torch.from_numpy(np.array(vm_crop)).to(self.dtype).to(self.device)\n vm_crop_gt = torch.from_numpy(np.array(vm_crop_gt)).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n fm_crop = torch.from_numpy(np.array(fm_crop)).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n\n vm_pad = torch.from_numpy(np.array(vm_pad)).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(np.array(vm_scale)).to(self.dtype).to(self.device)\n\n video_ids = torch.from_numpy(np.array(video_ids)).to(self.dtype).to(self.device)\n object_ids = torch.from_numpy(np.array(object_ids)).to(self.dtype).to(self.device)\n frame_ids = torch.from_numpy(np.array(frame_ids)).to(self.dtype).to(self.device)\n counts = torch.from_numpy(np.array(counts)).to(self.dtype).to(self.device)\n loss_mask_weight = torch.from_numpy(np.array(loss_mask_weight)).to(self.dtype).to(self.device) \n obj_position = torch.from_numpy(np.array(obj_position)).to(self.dtype).to(self.device)\n\n obj_data = {\n \"vm_crop\": vm_crop,\n \"vm_crop_gt\": vm_crop_gt,\n \"vm_no_crop\": vm_no_crop,\n \"fm_crop\": fm_crop,\n \"fm_no_crop\": fm_no_crop,\n \"img_crop\": img_crop,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"video_ids\": video_ids,\n \"object_ids\": object_ids,\n \"frame_ids\": frame_ids,\n \"counts\": counts,\n \"loss_mask\": loss_mask_weight, \n \"obj_position\": obj_position,\n }\n\n return obj_data\n\n def crop_and_rescale(self, vm_crop, fm_crop_vm=None, img_crop=None):\n h, w = np.array([m.shape for m in vm_crop]).max(axis=0)\n vm_pad = []\n vm_scale = []\n vm_crop_gt = []\n\n for i, m in enumerate(vm_crop):\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n vm_pad.append(np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)]))\n vm_scale.append(np.array([self.patch_h/h, self.patch_w/w]))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n if self.mode==\"train\":\n vm_crop[i] = self.data_augmentation(m)\n vm_crop_gt.append(m)\n else:\n vm_crop[i] = m\n vm_crop_gt.append(m)\n\n for i, m in enumerate(fm_crop_vm):\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n fm_crop_vm[i] = m\n\n for i, img_ in enumerate(img_crop):\n img_ = transform.rescale(img_, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop[i] = img_\n\n vm_pad = np.stack(vm_pad)\n vm_scale = np.stack(vm_scale)\n return vm_crop, vm_crop_gt, fm_crop_vm, img_crop, vm_pad, vm_scale\n \n def getImg(self, v_id):\n imgs = []\n imgs_list = os.listdir(os.path.join(self.img_path, v_id))\n imgs_list.sort()\n for sub_path in imgs_list:\n img_path = os.path.join(self.img_path, v_id, sub_path)\n img_tmp = plt.imread(img_path)\n imgs.append(img_tmp)\n assert len(imgs) == 128\n return imgs\n\n def create_iterator(self, batch_size):\n while True:\n sample_loader = DataLoader(\n dataset=self,\n batch_size=batch_size,\n drop_last=True,\n collate_fn=self.collate_fn\n )\n for item in sample_loader:\n yield item\n \n @staticmethod\n def collate_fn(batch):\n keys = batch[0].keys()\n res = {}\n for k in keys:\n temp_ = []\n for b in batch:\n if b[k] is not None:\n temp_.append(b[k])\n if len(temp_) > 0:\n res[k] = default_collate(temp_)\n else:\n res[k] = None\n return res\n \n def data_augmentation(self, mask):\n mask = mask.astype(np.float)\n rdv = random.random()\n n_repeat = random.randint(1, 4)\n if rdv <= 0.1:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n elif rdv > 0.1 and rdv < 0.6:\n rdv_1 = random.random()\n rdv_2 = random.random()\n for i in range(n_repeat):\n w = random.randint(5, 13)\n h = random.randint(5, 13)\n kernel = np.ones((w, h), dtype=np.uint8)\n if rdv_1 <= 0.5:\n mask = cv2.dilate(mask, kernel, 1)\n elif rdv_1 > 0.5 and rdv_1 <= 1.0:\n mask = cv2.erode(mask, kernel, 1)\n if rdv_2 <= 0.1:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n else:\n mask = mask\n return (mask>0.5)"},{"identifier":"MOViD_A","path":"data/dataloader_MOViD_A.py","snippet":"class MOViD_A(object):\n def __init__(self, config, mode):\n super(MOViD_A, self).__init__()\n self.mode = mode\n self.dtype = torch.float32\n self.device = \"cpu\"\n root_path = config.root_path\n self.data_dir = os.path.join(root_path, mode)\n \n self.instance_list = np.genfromtxt(\n os.path.join(root_path, \"{}_instance.txt\".format(mode)),\n dtype=np.str,\n encoding='utf-8'\n )\n\n self.train_seq_len = 24\n self.cur_vid = None\n self.patch_h = config.patch_H\n self.patch_w = config.patch_W\n self.enlarge_coef = config.enlarge_coef\n\n def __len__(self):\n return len(self.instance_list)\n\n def __getitem__(self, idx, specified_V_O_id=None):\n # whether choose a specific instance to load\n if specified_V_O_id is None:\n v_id, obj_id, value = self.instance_list[idx].split(\"_\")\n else:\n v_id, obj_id, value = specified_V_O_id.split(\"_\")\n v_id, obj_id, value = int(v_id), int(obj_id), int(value)\n if v_id != self.cur_vid:\n self.cur_vid = v_id\n self.video_path = os.path.join(self.data_dir, str(v_id))\n metadata = self.read_json(os.path.join(self.video_path, 'metadata.json'))\n\n self.num_frames = metadata[\"metadata\"][\"num_frames\"]\n self.height = metadata['metadata']['height']\n self.width = metadata['metadata']['width']\n self.instances = [self.format_instance_information(obj) for obj in metadata[\"instances\"]]\n\n vis_mask_paths = [os.path.join(self.video_path, \"segmentation_full_{}.png\".format(str(f).zfill(5))) for f in range(self.num_frames)]\n vis_mask = [np.array(Image.open(frame_path)) for frame_path in vis_mask_paths] #[t,h,w]\n\n full_mask_paths = [os.path.join(self.video_path, \"segmentation_{}_{}.png\".format(obj_id, str(f).zfill(5))) for f in range(self.num_frames)]\n full_mask = [np.array(Image.open(frame_path)) for frame_path in full_mask_paths] #[t,h,w]\n \n rgb_img_path = [os.path.join(self.video_path, \"rgba_full_{}.png\".format(str(f).zfill(5))) for f in range(self.num_frames)]\n rgb_img = [np.array(Image.open(frame_path))[...,:3] for frame_path in rgb_img_path]\n \n counts = []\n obj_position = []\n\n vm_crop = []\n vm_no_crop = []\n fm_crop = []\n fm_no_crop = []\n loss_mask_weight = []\n img_crop = []\n # for evaluation \n video_ids = []\n object_ids = []\n frame_ids = []\n\n timesteps = self.instances[obj_id]['bbox_frames']\n start_t, end_t = 0, 23\n if self.mode != \"test\" and end_t - start_t > self.train_seq_len - 1:\n start_t = np.random.randint(start_t, end_t-(self.train_seq_len-2))\n end_t = start_t + self.train_seq_len - 1\n\n for t_step in range(start_t, end_t+1):\n Image_H, Image_W = self.height, self.width\n # some objects will move out the field of view in some frames\n if t_step in timesteps:\n index = self.instances[obj_id][\"bbox_frames\"].index(t_step)\n xmin, ymin, xmax, ymax = self.instances[obj_id][\"bboxes\"][index]\n vx_min, vy_min, vx_max, vy_max = int(Image_H*xmin), int(Image_W*ymin), int(Image_H*xmax), int(Image_W*ymax)\n counts.append(1)\n else:\n bboxs = mask_find_bboxs(full_mask[t_step].astype(np.uint8))\n \n if bboxs.size==0:\n vx_min, vy_min, vx_max, vy_max = 0, 0, 256, 256\n else:\n b = bboxs[-1][:4]\n vx_min, vy_min, vx_max, vy_max = b[1], b[0], b[1]+b[3], b[0]+b[2]\n counts.append(0)\n\n # enlarge the bbox\n x_center = (vx_min + vx_max) // 2\n y_center = (vy_min + vy_max) // 2\n x_len = int((vx_max - vx_min) * self.enlarge_coef)\n y_len = int((vy_max - vy_min) * self.enlarge_coef)\n vx_min = max(0, x_center - x_len // 2)\n vx_max = min(Image_H, x_center + x_len // 2)\n vy_min = max(0, y_center - y_len // 2)\n vy_max = min(Image_W, y_center + y_len // 2)\n\n obj_position.append([vx_min, vx_max, vy_min, vy_max])\n\n # get mask\n vm = vis_mask[t_step]\n vm_crop.append(vm[vx_min:vx_max+1, vy_min:vy_max+1]==value)\n vm_no_crop.append(vm==value)\n\n fm = full_mask[t_step]\n fm_crop.append(fm[vx_min:vx_max+1, vy_min:vy_max+1]==value)\n fm_no_crop.append(fm==value)\n \n # get image\n image = rgb_img[t_step]\n img_crop.append(image[vx_min:vx_max+1, vy_min:vy_max+1])\n\n # get loss mask\n fore_ground = vm == 0\n obj_ground = vm==value\n loss_mask = np.logical_or(fore_ground, obj_ground)\n\n loss_mask_weight.append(loss_mask)\n\n # for evaluation\n video_ids.append(v_id)\n object_ids.append(obj_id)\n frame_ids.append(t_step)\n\n obj_position = torch.from_numpy(np.array(obj_position)).to(self.dtype).to(self.device)\n \n vm_crop, fm_crop, vm_pad, vm_scale, vm_crop_gt, img_crop = self.crop_and_rescale(vm_crop, fm_crop, img_crop)\n\n vm_crop = np.stack(vm_crop, axis=0) # Seq_len * h * w\n vm_no_crop = np.stack(vm_no_crop, axis=0) # Seq_len * H * W\n # fm_crop = np.stack(fm_crop, axis=0) # Seq_len * h * w\n fm_crop = np.stack(fm_crop, axis=0) # Seq_len * h * w\n fm_no_crop = np.stack(fm_no_crop, axis=0) # Seq_len * H * W\n img_crop = np.stack(img_crop, axis=0) # Sqe_len * H * W\n\n vm_crop = torch.from_numpy(np.array(vm_crop)).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n fm_crop = torch.from_numpy(np.array(fm_crop)).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n\n vm_pad = torch.from_numpy(np.array(vm_pad)).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(np.array(vm_scale)).to(self.dtype).to(self.device)\n\n video_ids = torch.from_numpy(np.array(video_ids)).to(self.dtype).to(self.device)\n object_ids = torch.from_numpy(np.array(object_ids)).to(self.dtype).to(self.device)\n frame_ids = torch.from_numpy(np.array(frame_ids)).to(self.dtype).to(self.device)\n counts = torch.from_numpy(np.array(counts)).to(self.dtype).to(self.device)\n loss_mask_weight = torch.from_numpy(np.array(loss_mask_weight)).to(self.dtype).to(self.device) \n obj_position = torch.from_numpy(np.array(obj_position)).to(self.dtype).to(self.device)\n\n obj_data = {\n \"vm_crop\": vm_crop,\n \"vm_no_crop\": vm_no_crop,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n\n \"img_crop\": img_crop,\n \n \"fm_crop\": fm_crop,\n \"fm_no_crop\": fm_no_crop,\n\n \"obj_position\": obj_position, \n \"loss_mask\": loss_mask_weight, \n \"counts\": counts,\n \"video_ids\": video_ids,\n \"object_ids\": object_ids,\n \"frame_ids\": frame_ids,\n }\n\n return obj_data\n\n def crop_and_rescale(self, vm_crop, fm_crop=None,img_crop=None):\n h, w = np.array([m.shape for m in vm_crop]).max(axis=0)\n vm_pad = []\n vm_crop_gt = []\n vm_scale = []\n for i, img in enumerate(img_crop):\n img = transform.rescale(img, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img = np.pad(img, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop[i] = img\n\n for i, m in enumerate(vm_crop):\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n if self.mode==\"train\":\n vm_crop[i] = self.data_augmentation(m)\n else:\n vm_crop[i] = m\n vm_crop_gt.append(m)\n vm_pad.append(np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)]))\n vm_scale.append(np.array([self.patch_h/h, self.patch_w/w]))\n\n for i, m in enumerate(fm_crop):\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n fm_crop[i] = m\n\n vm_pad = np.stack(vm_pad)\n vm_scale = np.stack(vm_scale)\n return vm_crop, fm_crop, vm_pad, vm_scale, vm_crop_gt,img_crop\n \n def read_json(self,dir_):\n with open(dir_) as f:\n data = json.load(f)\n return data\n\n def format_instance_information(self, obj):\n return {\n \"bboxes\": obj[\"bboxes\"],\n \"bbox_frames\": obj[\"bbox_frames\"],\n }\n\n def create_iterator(self, batch_size):\n while True:\n sample_loader = DataLoader(\n dataset=self,\n batch_size=batch_size,\n drop_last=True,\n collate_fn=self.collate_fn\n )\n\n for item in sample_loader:\n yield item\n\n @staticmethod\n def collate_fn(batch):\n keys = batch[0].keys()\n res = {}\n for k in keys:\n temp_ = []\n for b in batch:\n if b[k] is not None:\n temp_.append(b[k])\n if len(temp_) > 0:\n res[k] = default_collate(temp_)\n else:\n res[k] = None\n return res\n \n def data_augmentation(self, mask):\n mask = mask.astype(np.float)\n rdv = random.random()\n n_repeat = random.randint(1, 4)\n if rdv <= 0.1:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n elif rdv > 0.1 and rdv < 0.6:\n rdv_1 = random.random()\n rdv_2 = random.random()\n for i in range(n_repeat):\n w = random.randint(5, 13)\n h = random.randint(5, 13)\n kernel = np.ones((w, h), dtype=np.uint8)\n if rdv_1 <= 0.5:\n mask = cv2.dilate(mask, kernel, 1)\n elif rdv_1 > 0.5 and rdv_1 <= 1.0:\n mask = cv2.erode(mask, kernel, 1)\n if rdv_2 <= 0.1:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n else:\n mask = mask\n return (mask>0.5)"},{"identifier":"Kins_Fusion_dataset","path":"data/dataloader_KINS.py","snippet":"class Kins_Fusion_dataset(torch.utils.data.Dataset):\n def __init__(self, config, mode):\n super(Kins_Fusion_dataset, self).__init__()\n self.config = config\n self.mode = mode\n self.root_path = config.root_path\n \n # Load Fusion dataset\n self.data_info = pickle.load(open(os.path.join(self.root_path, \"fusion_{}.pkl\".format(self.mode)), \"rb\"))\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \"c2f_seg_{}_list.txt\".format(self.mode)), dtype=np.str, encoding='utf-8')\n self.img_root_path = os.path.join(self.root_path, \"{}ing\".format(mode),\"image_2\")\n \n # Load the GT of AISFormer\n if mode==\"train\":\n aisformer_gt = cvb.load(os.path.join(self.root_path, \"instances_train.json\"))\n else:\n aisformer_gt = cvb.load(os.path.join(self.root_path, \"instances_val_upate.json\"))\n annotations = aisformer_gt[\"annotations\"]\n images = aisformer_gt[\"images\"]\n self.images, self.annotations = self.make_json_dict(images, annotations)\n \n # Load the GT of vanilla KINS\n self.base_img_path = os.path.join(self.root_path, \"{}ing\".format(mode), \"image_2\")\n self.base_ann_path= os.path.join(self.root_path, \"update_{}_2020.json\".format(mode))\n annotations = cvb.load(self.base_ann_path)\n imgs_info = annotations['images']\n anns_info = annotations[\"annotations\"]\n self.imgs_dict, self.anns_dict = self.make_json_dict(imgs_info, anns_info)\n\n # dataloader setting\n self.dtype = torch.float32\n self.enlarge_coef = 2\n self.patch_h = 256\n self.patch_w = 256\n self.device = \"cpu\"\n\n def __len__(self):\n return self.label_info.shape[0]\n\n def __getitem__(self, index):\n return self.load_item(index)\n \n def load_item(self, index):\n # load aisformer predicted visible masks\n if \"aisformer\" in self.label_info[index]:\n dataset_name, image_id, anno_id = self.label_info[index].split(\",\")\n image_id, anno_id = int(image_id), int(anno_id)\n # add image information\n img_name = self.images[image_id]\n img_path = os.path.join(self.img_root_path, img_name)\n # img_path = os.path.join(self.img_root_path, str(image_id).zfill(6)+ \".png\")\n img = np.array(Image.open(img_path))\n instances = self.data_info['{}_{}'.format(dataset_name, image_id)][anno_id]\n segmentation = instances[\"pred_visible_mask\"]\n height, width = segmentation[\"size\"]\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\n vm_no_crop_gt = mask_utils.decode([instances[\"gt_visible_mask\"]]).astype(bool)\n rles = mask_utils.frPyObjects(instances[\"gt_full_mask\"], height, width)\n fm_no_crop = mask_utils.decode(mask_utils.merge(rles)).astype(bool)\n fm_no_crop = fm_no_crop[..., np.newaxis]\n\n bbox = instances[\"pred_visible_mask_bbox\"]\n y_min, x_min, w, h = bbox\n y_max, x_max = y_min + w, x_min + h\n x_center = (x_min + x_max) // 2\n y_center = (y_min + y_max) // 2\n x_len = int((x_max - x_min) * self.enlarge_coef)\n y_len = int((y_max - y_min) * self.enlarge_coef)\n x_min = max(0, x_center - x_len // 2)\n x_max = min(height, x_center + x_len // 2)\n y_min = max(0, y_center - y_len // 2)\n y_max = min(width, y_center + y_len // 2)\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\n \n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\n \n h, w = vm_crop.shape[:2]\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop = m[np.newaxis, ...]\n\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop = img_\n\n # data augmentation\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\n\n h, w = vm_crop_gt.shape[:2]\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop_gt = m[np.newaxis, ...]\n\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \n fm_crop = m[np.newaxis, ...]\n\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\n loss_mask[loss_mask==255]=0\n loss_mask = 1-loss_mask.astype(bool)\n\n vm_no_crop = vm_no_crop[np.newaxis, ...]\n fm_no_crop = fm_no_crop[np.newaxis, ...]\n\n obj_position = np.array([x_min, x_max, y_min, y_max])\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\n counts = np.array([1])\n \n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\n\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\n\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n vm_no_crop_gt = torch.from_numpy(np.array(vm_no_crop_gt)).to(self.dtype).to(self.device)\n\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\n \n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\n \n if self.mode==\"train\":\n meta = {\n # \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop_aug,\n \"vm_crop_gt\": vm_crop_gt,\n # \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n # \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n }\n elif self.mode==\"test\":\n meta = {\n \"vm_no_crop\": vm_no_crop,\n \"vm_no_crop_gt\": vm_no_crop_gt,\n \"vm_crop\": vm_crop,\n \"vm_crop_gt\": vm_crop_gt,\n \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n }\n return meta\n else:\n img_id, anno_id, category_id = self.label_info[index].split(\"_\")\n img_id, anno_id, category_id = int(img_id), int(anno_id), int(category_id)\n\n img_name = self.imgs_dict[img_id]\n img_path = os.path.join(self.base_img_path, img_name)\n \n img = cv2.imread(img_path, cv2.IMREAD_COLOR)\n height, width, _ = img.shape\n \n ann = self.anns_dict[img_id][anno_id]\n fm_no_crop = self.polys_to_mask(ann[\"a_segm\"], height, width)\n vm_no_crop = self.polys_to_mask(ann[\"i_segm\"], height, width)\n if np.sum(vm_no_crop)==0:\n counts = np.array([0])\n else:\n counts = np.array([1])\n y_min, x_min, w, h = ann[\"i_bbox\"]\n\n y_max, x_max = y_min + w, x_min + h\n x_center = (x_min + x_max) // 2\n y_center = (y_min + y_max) // 2\n x_len = int((x_max - x_min) * self.enlarge_coef)\n y_len = int((y_max - y_min) * self.enlarge_coef)\n x_min = max(0, x_center - x_len // 2)\n x_max = min(height, x_center + x_len // 2)\n y_min = max(0, y_center - y_len // 2)\n y_max = min(width, y_center + y_len // 2)\n \n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1].astype(bool)\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1].astype(bool)\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\n\n h, w = vm_crop.shape[:2]\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop = m[np.newaxis, ...]\n\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop = img_\n\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \n fm_crop = m[np.newaxis, ...]\n\n obj_position = np.array([x_min, x_max, y_min, y_max])\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\n\n vm_no_crop = vm_no_crop[np.newaxis, ...]\n fm_no_crop = fm_no_crop[np.newaxis, ...]\n\n loss_mask = fm_no_crop-vm_no_crop\n loss_mask[loss_mask==255]=0\n loss_mask = 1-loss_mask.astype(bool)\n # data augmentation\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\n\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\n\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n # vm_crop here is the GT\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\n \n img_id = torch.from_numpy(np.array(img_id)).to(self.dtype).to(self.device)\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\n # category_id = torch.from_numpy(np.array(category_id)).to(self.dtype).to(self.device)\n if self.mode==\"train\":\n meta = {\n # \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop_aug,\n \"vm_crop_gt\": vm_crop,\n # \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n # \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": img_id,\n \"anno_id\": anno_id,\n # for vq\n # \"mask_crop\": fm_crop\n }\n elif self.mode==\"test\":\n meta = {\n \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop,\n \"vm_crop_gt\": vm_crop,\n \"fm_no_crop\": fm_no_crop,\n \"vm_no_crop_gt\": vm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": img_id,\n \"anno_id\": anno_id,\n # for vq\n # \"mask_crop\": fm_crop\n }\n return meta\n\n def data_augmentation(self, mask):\n mask = mask.astype(np.float)\n rdv = random.random()\n n_repeat = random.randint(1, 4)\n if rdv <= 0.2:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n elif rdv > 0.2 and rdv <0.6:\n rdv_1 = random.random()\n rdv_2 = random.random()\n for i in range(n_repeat):\n w = random.randint(5, 13)\n h = random.randint(5, 13)\n kernel = np.ones((w, h), dtype=np.uint8)\n if rdv_1 <= 0.55:\n mask = cv2.dilate(mask, kernel, 1)\n elif rdv_1 > 0.55 and rdv_1 <= 1.0:\n mask = cv2.erode(mask, kernel, 1)\n if rdv_2 <= 0.1:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n else:\n mask = mask\n return (mask>0.5)\n \n @staticmethod\n def collate_fn(batch):\n keys = batch[0].keys()\n res = {}\n for k in keys:\n temp_ = []\n for b in batch:\n if b[k] is not None:\n temp_.append(b[k])\n if len(temp_) > 0:\n res[k] = default_collate(temp_)\n else:\n res[k] = None\n\n return res\n\n def create_iterator(self, batch_size):\n while True:\n sample_loader = DataLoader(\n dataset=self,\n batch_size=batch_size,\n drop_last=True,\n collate_fn=self.collate_fn\n )\n\n for item in sample_loader:\n yield item\n\n def make_json_dict(self, imgs, anns):\n imgs_dict = {}\n anns_dict = {}\n for ann in anns:\n image_id = ann[\"image_id\"]\n if not image_id in anns_dict:\n anns_dict[image_id] = []\n anns_dict[image_id].append(ann)\n else:\n anns_dict[image_id].append(ann)\n \n for img in imgs:\n image_id = img['id']\n imgs_dict[image_id] = img['file_name']\n\n return imgs_dict, anns_dict\n\n def polys_to_mask(self, polygons, height, width):\n rles = mask_utils.frPyObjects(polygons, height, width)\n rle = mask_utils.merge(rles)\n mask = mask_utils.decode(rle)\n return mask"},{"identifier":"KINS_Aisformer_VRSP_Intersection","path":"data/dataloader_KINS.py","snippet":"class KINS_Aisformer_VRSP_Intersection(torch.utils.data.Dataset):\n def __init__(self, config, mode):\n super(KINS_Aisformer_VRSP_Intersection, self).__init__()\n self.config = config\n self.mode = mode\n self.root_path = config.root_path\n \n # Load Intersection dataset\n self.data_info = pickle.load(open(os.path.join(self.root_path, \"kins_intersection.pkl\"), \"rb\"))\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \"kins_intersection_list.txt\"), dtype=np.str, encoding='utf-8')\n if mode==\"train\":\n aisformer_gt = cvb.load(os.path.join(self.root_path, \"instances_train.json\"))\n else:\n aisformer_gt = cvb.load(os.path.join(self.root_path, \"instances_val_upate.json\"))\n annotations = aisformer_gt[\"annotations\"]\n images = aisformer_gt[\"images\"]\n self.images, self.annotations = self.make_json_dict(images, annotations)\n self.img_root_path = os.path.join(self.root_path, \"{}ing\".format(mode), \"image_2\")\n self.dtype = torch.float32\n self.enlarge_coef = 2\n self.patch_h = 256\n self.patch_w = 256\n self.device = \"cpu\"\n \n def __len__(self):\n return self.label_info.shape[0]\n\n def __getitem__(self, index):\n return self.load_item(index)\n \n def mask_find_bboxs(self, mask):\n retval, labels, stats, centroids = cv2.connectedComponentsWithStats(mask, connectivity=8)\n stats = stats[stats[:,4].argsort()]\n return stats\n \n def generate_heatmap(self, mask, kernel, sigma):\n heatmap = cv2.GaussianBlur(mask, kernel, sigma)\n am = np.amax(heatmap)\n heatmap /= am / 1\n return heatmap\n \n def load_item(self, index):\n image_id, anno_id = self.label_info[index].split(\"_\")\n image_id, anno_id = int(image_id), int(anno_id)\n instances = self.data_info[image_id][anno_id]\n\n segmentation = instances[\"pred_visible_mask\"]\n height, width = segmentation[\"size\"]\n # add image information\n img_name = self.images[image_id]\n img_path = os.path.join(self.img_root_path, img_name)\n # img_path = os.path.join(self.img_root_path, str(image_id).zfill(6)+ \".png\")\n img = Image.open(img_path)\n img = img.resize((width,height), Image.ANTIALIAS)\n img = np.array(img)\n \n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\n vm_no_crop_gt = mask_utils.decode([instances[\"gt_visible_mask\"]]).astype(bool)\n # fm_no_crop = mask_utils.decode([instances[\"gt_full_mask\"]]).astype(bool)\n rles = mask_utils.frPyObjects(instances[\"gt_full_mask\"], height, width)\n fm_no_crop = mask_utils.decode(mask_utils.merge(rles)).astype(bool)\n \n bbox = instances[\"pred_visible_mask_bbox\"]\n y_min, x_min, w, h = bbox\n y_max, x_max = y_min + w, x_min + h\n x_center = (x_min + x_max) // 2\n y_center = (y_min + y_max) // 2\n x_len = int((x_max - x_min) * self.enlarge_coef)\n y_len = int((y_max - y_min) * self.enlarge_coef)\n x_min = max(0, x_center - x_len // 2)\n x_max = min(height, x_center + x_len // 2)\n y_min = max(0, y_center - y_len // 2)\n y_max = min(width, y_center + y_len // 2)\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\n\n x_center_crop = x_center - x_min\n y_center_crop = y_center - y_min\n \n fm_no_crop = fm_no_crop[..., np.newaxis]\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n\n h, w = vm_crop.shape[:2]\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop = m[np.newaxis, ...]\n \n center_crop = np.zeros_like(vm_crop[0])\n x_center_crop = int(x_center_crop*self.patch_h/h)\n y_center_crop = int(y_center_crop*self.patch_w/w)\n center_crop[x_center_crop: x_center_crop+1, y_center_crop: y_center_crop+1]=1\n center_crop = self.generate_heatmap(center_crop.astype(np.float), (35, 35), 9)\n center_crop = center_crop[np.newaxis, ...]\n\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop = img_\n\n h, w = vm_crop_gt.shape[:2]\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop_gt = m[np.newaxis, ...]\n\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \n fm_crop = m[np.newaxis, ...]\n\n refine_loss_mask = 1 - (vm_crop_gt==vm_crop).astype(bool)\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\n # import pdb;pdb.set_trace()\n loss_mask[loss_mask==255]=0\n loss_mask = 1-loss_mask.astype(bool)\n\n vm_no_crop = vm_no_crop[np.newaxis, ...]\n fm_no_crop = fm_no_crop[np.newaxis, ...]\n\n obj_position = np.array([x_min, x_max, y_min, y_max])\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\n counts = np.array([1])\n\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\n\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\n\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\n vm_no_crop_gt = torch.from_numpy(vm_no_crop_gt).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n refine_loss_mask = torch.from_numpy(np.array(refine_loss_mask)).to(self.dtype).to(self.device)\n center_crop = torch.from_numpy(np.array(center_crop)).to(self.dtype).to(self.device)\n \n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n img = torch.from_numpy(np.array(img)).to(self.dtype).to(self.device)\n\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\n \n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\n \n if self.mode==\"train\":\n meta = {\n # \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop,\n # \"vm_crop_gt\": vm_crop_gt,\n # \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"center_crop\": center_crop,\n # \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n # for vq\n # \"mask_crop\": fm_crop\n }\n # elif self.mode==\"test\":\n # meta = {\n # # \"vm_no_crop\": vm_no_crop,\n # \"vm_crop\": vm_crop,\n # \"vm_crop_gt\": vm_crop_gt,\n # # \"vm_no_crop_gt\": vm_no_crop_gt,\n # # \"refine_loss_mask\": refine_loss_mask,\n # # \"fm_no_crop\": fm_no_crop,\n # \"fm_crop\": fm_crop,\n # \"img_crop\": img_crop,\n # # \"loss_mask\": loss_mask,\n # # \"obj_position\": obj_position,\n # # \"vm_pad\": vm_pad,\n # # \"vm_scale\": vm_scale,\n # # \"counts\":counts,\n # # \"img_id\": image_id,\n # # \"anno_id\": anno_id,\n # # # for vq\n # # # \"mask_crop\": fm_crop\n # # # \"img\":img,\n # }\n elif self.mode==\"test\":\n meta = {\n \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop,\n \"vm_crop_gt\": vm_crop_gt,\n \"vm_no_crop_gt\": vm_no_crop_gt,\n \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"center_crop\": center_crop,\n \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n # for vq\n # \"mask_crop\": fm_crop\n \"img\":img,\n }\n return meta\n\n @staticmethod\n def collate_fn(batch):\n keys = batch[0].keys()\n res = {}\n for k in keys:\n temp_ = []\n for b in batch:\n if b[k] is not None:\n temp_.append(b[k])\n if len(temp_) > 0:\n res[k] = default_collate(temp_)\n else:\n res[k] = None\n\n return res\n\n def create_iterator(self, batch_size):\n while True:\n sample_loader = DataLoader(\n dataset=self,\n batch_size=batch_size,\n drop_last=True,\n collate_fn=self.collate_fn\n )\n\n for item in sample_loader:\n yield item\n\n def polys_to_mask(self, polygons, height, width):\n rles = mask_utils.frPyObjects(polygons, height, width)\n rle = mask_utils.merge(rles)\n mask = mask_utils.decode(rle)\n return mask\n \n def make_json_dict(self, imgs, anns):\n imgs_dict = {}\n anns_dict = {}\n for ann in anns:\n image_id = ann[\"image_id\"]\n if not image_id in anns_dict:\n anns_dict[image_id] = []\n anns_dict[image_id].append(ann)\n else:\n anns_dict[image_id].append(ann)\n \n for img in imgs:\n image_id = img['id']\n imgs_dict[image_id] = img['file_name']\n\n return imgs_dict, anns_dict"},{"identifier":"COCOA_Fusion_dataset","path":"data/dataloader_COCOA.py","snippet":"class COCOA_Fusion_dataset(torch.utils.data.Dataset):\n def __init__(self, config, mode):\n super(COCOA_Fusion_dataset, self).__init__()\n self.config = config\n self.mode = mode\n self.root_path = config.root_path\n \n # Load Fusion dataset \n self.data_info = pickle.load(open(os.path.join(self.root_path, \"fusion_{}.pkl\".format(self.mode)), \"rb\"))\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \"c2f_seg_{}_list.txt\".format(self.mode)), dtype=np.str, encoding='utf-8')\n \n if mode==\"train\":\n train_label = cvb.load(os.path.join(self.root_path, \"COCO_amodal_train2014_with_classes.json\"))\n self.anns_dict = train_label[\"annotations\"]\n self.img_root_path = os.path.join(self.root_path, \"train2014\")\n elif mode==\"test\":\n val_label = cvb.load(os.path.join(self.root_path, \"COCO_amodal_val2014_with_classes.json\"))\n self.anns_dict = val_label[\"annotations\"]\n self.img_root_path = os.path.join(self.root_path, \"val2014\")\n \n self.dtype = torch.float32\n self.enlarge_coef = 2\n self.patch_h = 256\n self.patch_w = 256\n self.device = \"cpu\"\n\n \n def __len__(self):\n return self.label_info.shape[0]\n\n def __getitem__(self, index):\n return self.load_item(index)\n \n def load_item(self, index):\n # predicted vm\n if len(self.label_info[index].split(\",\"))==3:\n dataset_name, image_id, anno_id = self.label_info[index].split(\",\")\n image_id, anno_id = int(image_id), int(anno_id)\n if self.mode==\"train\":\n img_path = os.path.join(self.img_root_path, \"COCO_{}2014_{}.jpg\".format(self.mode, str(image_id).zfill(12)))\n elif self.mode==\"test\":\n img_path = os.path.join(self.img_root_path, \"COCO_val2014_{}.jpg\".format(str(image_id).zfill(12)))\n img = np.array(Image.open(img_path))\n if len(img.shape)==2:\n img = np.repeat(img[:, :, np.newaxis], 3, axis=2)\n instances = self.data_info[\"{}_{}\".format(dataset_name, image_id)][anno_id]\n segmentation = instances[\"pred_visible_mask\"]\n height, weight = segmentation[\"size\"]\n # occlude_rate = instances[\"occlude_rate\"]\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\n fm_no_crop = mask_utils.decode([instances[\"gt_full_mask\"]]).astype(bool)\n vm_no_crop_gt = mask_utils.decode([instances[\"gt_visible_mask\"]]).astype(bool)\n\n bbox = instances[\"pred_visible_mask_bbox\"]\n y_min, x_min, w, h = bbox\n y_max, x_max = y_min + w, x_min + h\n x_center = (x_min + x_max) // 2\n y_center = (y_min + y_max) // 2\n x_len = int((x_max - x_min) * self.enlarge_coef)\n y_len = int((y_max - y_min) * self.enlarge_coef)\n x_min = max(0, x_center - x_len // 2)\n x_max = min(height, x_center + x_len // 2)\n y_min = max(0, y_center - y_len // 2)\n y_max = min(weight, y_center + y_len // 2)\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\n # import pdb;pdb.set_trace()\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n\n h, w = vm_crop.shape[:2]\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop = m[np.newaxis, ...]\n\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop = img_\n\n h, w = vm_crop_gt.shape[:2]\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop_gt = m[np.newaxis, ...]\n\n # data augmentation\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\n\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \n fm_crop = m[np.newaxis, ...]\n # if self.mode==\"test\":\n # loss_mask = mask_utils.decode([instances[\"loss_mask\"]]).astype(bool)[...,0]\n # else:\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\n loss_mask[loss_mask==255]=0\n loss_mask = 1-loss_mask.astype(bool)\n\n vm_no_crop = vm_no_crop[np.newaxis, ...]\n fm_no_crop = fm_no_crop[np.newaxis, ...]\n\n obj_position = np.array([x_min, x_max, y_min, y_max])\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\n counts = np.array([1])\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\n\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\n\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n img = torch.from_numpy(np.array(img)).to(self.dtype).to(self.device)\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\n \n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\n # occlude_rate = torch.from_numpy(np.array(occlude_rate)).to(self.dtype).to(self.device)\n \n if self.mode==\"train\":\n meta = {\n # \"vm_no_crop\": vm_no_crop,\n # \"vm_crop\": vm_crop,\n \"vm_crop\": vm_crop_aug,\n \"vm_crop_gt\": vm_crop_gt,\n # \"vm_crop_gt\": vm_crop_gt,\n # \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n # \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n # for vq\n # \"mask_crop\": fm_crop\n # \"img_no_crop\": img,\n }\n elif self.mode==\"test\":\n meta = {\n \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop,\n \"img_crop\": img_crop,\n \"vm_crop_gt\": vm_crop_gt,\n \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n # \"occlude_rate\":occlude_rate\n # for vq\n # \"mask_crop\": fm_crop\n # \"img_no_crop\": img,\n }\n return meta\n # gt vm\n elif len(self.label_info[index].split(\",\"))==2:\n anno_id, img_path = self.label_info[index].split(\",\")\n anno_id = int(anno_id)\n img = cv2.imread(img_path, cv2.IMREAD_COLOR)\n height, width, _ = img.shape\n\n ann = self.anns_dict[anno_id]\n img_id = ann[\"image_id\"]\n # category_id = ann[\"category_id\"]\n\n full_mask = ann[\"segmentation\"]\n fm_no_crop = mask_utils.decode(full_mask)[...,np.newaxis]\n\n visible_mask = ann[\"visible_mask\"]\n vm_no_crop = mask_utils.decode(visible_mask)[...,np.newaxis]\n\n if np.sum(vm_no_crop)==0:\n counts = np.array([0])\n else:\n counts = np.array([1])\n y_min, x_min, w, h = ann[\"bbox\"]\n y_max, x_max = y_min + w, x_min + h\n y_min, x_min, y_max, x_max = int(y_min), int(x_min), int(y_max), int(x_max) \n\n x_center = (x_min + x_max) // 2\n y_center = (y_min + y_max) // 2\n x_len = int((x_max - x_min) * self.enlarge_coef)\n y_len = int((y_max - y_min) * self.enlarge_coef)\n x_min = max(0, x_center - x_len // 2)\n x_max = min(height, x_center + x_len // 2)\n y_min = max(0, y_center - y_len // 2)\n y_max = min(width, y_center + y_len // 2)\n \n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\n\n h, w = vm_crop.shape[:2]\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop = m[np.newaxis, ...]\n\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop = img_\n\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \n fm_crop = m[np.newaxis, ...]\n\n obj_position = np.array([x_min, x_max, y_min, y_max])\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\n\n # full_pad = ((0, max(375-height, 0)), (0, max(1242-width, 0)))\n # vm_no_crop = np.pad(vm_no_crop, full_pad)[:375, :1242]\n # fm_no_crop = np.pad(fm_no_crop, full_pad)[:375, :1242]\n vm_no_crop = vm_no_crop[np.newaxis, ...]\n fm_no_crop = fm_no_crop[np.newaxis, ...]\n\n loss_mask = fm_no_crop-vm_no_crop\n loss_mask[loss_mask==255]=0\n loss_mask = 1-loss_mask.astype(bool)\n # data augmentation\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\n \n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\n\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\n\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\n img_crop = torch.from_numpy(img_crop).to(self.dtype).to(self.device)\n img = torch.from_numpy(img).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n \n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\n \n img_id = torch.from_numpy(np.array(img_id)).to(self.dtype).to(self.device)\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\n # category_id = torch.from_numpy(np.array(category_id)).to(self.dtype).to(self.device)\n if self.mode==\"train\":\n meta = {\n # \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop_aug,\n \"vm_crop_gt\": vm_crop,\n # \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n # \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\": counts,\n \"img_id\": img_id,\n \"anno_id\": anno_id,\n # \"category_id\": category_id,\n # for vq\n # \"mask_crop\": fm_crop\n # \"img_no_crop\": img\n }\n elif self.mode==\"test\":\n meta = {\n \"vm_no_crop\": vm_no_crop,\n \"vm_no_crop_gt\": vm_no_crop,\n \"vm_crop\": vm_crop,\n \"vm_crop_gt\": vm_crop,\n \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": img_id,\n \"anno_id\": anno_id,\n # \"category_id\": category_id,\n # for vq\n # \"mask_crop\": fm_crop\n \"img_no_crop\": img,\n }\n return meta\n \n @staticmethod\n def collate_fn(batch):\n keys = batch[0].keys()\n res = {}\n for k in keys:\n temp_ = []\n for b in batch:\n if b[k] is not None:\n temp_.append(b[k])\n if len(temp_) > 0:\n res[k] = default_collate(temp_)\n else:\n res[k] = None\n\n return res\n\n def create_iterator(self, batch_size):\n while True:\n sample_loader = DataLoader(\n dataset=self,\n batch_size=batch_size,\n drop_last=True,\n collate_fn=self.collate_fn\n )\n\n for item in sample_loader:\n yield item\n\n def polys_to_mask(self, polygons, height, width):\n rles = mask_utils.frPyObjects(polygons, height, width)\n rle = mask_utils.merge(rles)\n mask = mask_utils.decode(rle)\n return mask\n\n # def data_augmentation(self, mask):\n # return mask\n \n def data_augmentation(self, mask):\n mask = mask.astype(np.float)\n rdv = random.random()\n n_repeat = random.randint(1, 4)\n if rdv <= 0.2:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n elif rdv > 0.2 and rdv <0.9:\n rdv_1 = random.random()\n rdv_2 = random.random()\n for i in range(n_repeat):\n w = random.randint(5, 13)\n h = random.randint(5, 13)\n kernel = np.ones((w, h), dtype=np.uint8)\n if rdv_1 <= 0.6:\n mask = cv2.dilate(mask, kernel, 1)\n elif rdv_1 > 0.6 and rdv_1 <= 1.0:\n mask = cv2.erode(mask, kernel, 1)\n if rdv_2 <= 0.2:\n mask = cv2.GaussianBlur(mask, (35,35), 11)\n else:\n mask = mask\n return (mask>0.5)\n \n def make_json_dict(self, imgs, anns):\n imgs_dict = {}\n anns_dict = {}\n for ann in anns:\n image_id = ann[\"image_id\"]\n if not image_id in anns_dict:\n anns_dict[image_id] = []\n anns_dict[image_id].append(ann)\n else:\n anns_dict[image_id].append(ann)\n \n for img in imgs:\n image_id = img['id']\n imgs_dict[image_id] = img['file_name']\n\n return imgs_dict, anns_dict"},{"identifier":"COCOA_VRSP","path":"data/dataloader_COCOA.py","snippet":"class COCOA_VRSP(torch.utils.data.Dataset):\n def __init__(self, config, mode):\n super(COCOA_VRSP, self).__init__()\n self.config = config\n self.mode = mode\n self.data_info = pickle.load(open(os.path.join(self.root_path, \"fusion_{}.pkl\".format(self.mode)), \"rb\"))\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \"c2f_seg_{}_list.txt\".format(self.mode)), dtype=np.str, encoding='utf-8')\n \n if self.mode==\"train\":\n self.img_root_path = os.path.join(self.root_path, \"train2014\")\n elif self.mode==\"test\":\n self.img_root_path = os.path.join(self.root_path, \"val2014\")\n\n self.dtype = torch.float32\n self.enlarge_coef = 2\n self.patch_h = 256\n self.patch_w = 256\n self.device = \"cpu\"\n\n \n def __len__(self):\n return self.label_info.shape[0]\n\n def __getitem__(self, index):\n return self.load_item(index)\n \n def generate_heatmap(self, mask, kernel, sigma):\n heatmap = cv2.GaussianBlur(mask, kernel, sigma)\n am = np.amax(heatmap)\n heatmap /= am / 1\n return heatmap\n \n def load_item(self, index):\n image_id, anno_id = self.label_info[index].split(\"_\")\n image_id, anno_id = int(image_id), int(anno_id)\n if self.mode==\"train\":\n img_path = os.path.join(self.img_root_path, \"COCO_{}2014_{}.jpg\".format(self.mode, str(image_id).zfill(12)))\n elif self.mode==\"test\":\n img_path = os.path.join(self.img_root_path, \"COCO_val2014_{}.jpg\".format(str(image_id).zfill(12)))\n img = np.array(Image.open(img_path))\n if len(img.shape)==2:\n img = np.repeat(img[:, :, np.newaxis], 3, axis=2)\n instances = self.data_info[image_id][anno_id]\n segmentation = instances[\"pred_visible_mask\"]\n height, weight = segmentation[\"size\"]\n occlude_rate = instances[\"occlude_rate\"]\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\n fm_no_crop = mask_utils.decode([instances[\"gt_full_mask\"]]).astype(bool)\n vm_no_crop_gt = mask_utils.decode([instances[\"gt_visible_mask\"]]).astype(bool)\n\n bbox = instances[\"pred_visible_mask_bbox\"]\n y_min, x_min, w, h = bbox\n y_max, x_max = y_min + w, x_min + h\n x_center = (x_min + x_max) // 2\n y_center = (y_min + y_max) // 2\n x_len = int((x_max - x_min) * self.enlarge_coef)\n y_len = int((y_max - y_min) * self.enlarge_coef)\n x_min = max(0, x_center - x_len // 2)\n x_max = min(height, x_center + x_len // 2)\n y_min = max(0, y_center - y_len // 2)\n y_max = min(weight, y_center + y_len // 2)\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\n \n x_center_crop = x_center - x_min\n y_center_crop = y_center - y_min\n\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\n\n h, w = vm_crop.shape[:2]\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop = m[np.newaxis, ...]\n\n center_crop = np.zeros_like(vm_crop[0])\n x_center_crop = int(x_center_crop*self.patch_h/h)\n y_center_crop = int(y_center_crop*self.patch_w/w)\n center_crop[x_center_crop: x_center_crop+1, y_center_crop: y_center_crop+1]=1\n center_crop = self.generate_heatmap(center_crop.astype(np.float), (35, 35), 9)\n center_crop = center_crop[np.newaxis, ...]\n\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\n cur_h, cur_w = img_.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\n img_crop = img_\n\n h, w = vm_crop_gt.shape[:2]\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\n vm_crop_gt = m[np.newaxis, ...]\n\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\n cur_h, cur_w = m.shape[:2]\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \n fm_crop = m[np.newaxis, ...]\n\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\n loss_mask[loss_mask==255]=0\n loss_mask = 1-loss_mask.astype(bool)\n\n vm_no_crop = vm_no_crop[np.newaxis, ...]\n fm_no_crop = fm_no_crop[np.newaxis, ...]\n\n obj_position = np.array([x_min, x_max, y_min, y_max])\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\n counts = np.array([1])\n\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\n\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\n\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\n center_crop = torch.from_numpy(np.array(center_crop)).to(self.dtype).to(self.device)\n \n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\n img = torch.from_numpy(np.array(img)).to(self.dtype).to(self.device)\n\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\n \n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\n occlude_rate = torch.from_numpy(np.array(occlude_rate)).to(self.dtype).to(self.device)\n \n if self.mode==\"train\":\n meta = {\n # \"vm_no_crop\": vm_no_crop,\n \"vm_crop\": vm_crop,\n # \"vm_crop_gt\": vm_crop_gt,\n # \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"center_crop\": center_crop,\n # \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n \"img_no_crop\": img,\n }\n elif self.mode==\"test\":\n meta = {\n \"vm_no_crop\": vm_no_crop,\n \"vm_no_crop_gt\": vm_no_crop_gt,\n \"vm_crop\": vm_crop,\n \"vm_crop_gt\": vm_crop_gt,\n \"fm_no_crop\": fm_no_crop,\n \"fm_crop\": fm_crop,\n \"img_crop\": img_crop,\n \"center_crop\": center_crop,\n \"loss_mask\": loss_mask,\n \"obj_position\": obj_position,\n \"vm_pad\": vm_pad,\n \"vm_scale\": vm_scale,\n \"counts\":counts,\n \"img_id\": image_id,\n \"anno_id\": anno_id,\n \"occlude_rate\":occlude_rate,\n # # for vq\n # \"mask_crop\": fm_crop,\n \"img\": img,\n }\n return meta\n\n @staticmethod\n def collate_fn(batch):\n keys = batch[0].keys()\n res = {}\n for k in keys:\n temp_ = []\n for b in batch:\n if b[k] is not None:\n temp_.append(b[k])\n if len(temp_) > 0:\n res[k] = default_collate(temp_)\n else:\n res[k] = None\n\n return res\n\n def create_iterator(self, batch_size):\n while True:\n sample_loader = DataLoader(\n dataset=self,\n batch_size=batch_size,\n drop_last=True,\n collate_fn=self.collate_fn\n )\n\n for item in sample_loader:\n yield item\n\n def polys_to_mask(self, polygons, height, width):\n rles = mask_utils.frPyObjects(polygons, height, width)\n rle = mask_utils.merge(rles)\n mask = mask_utils.decode(rle)\n return mask"}],"string":"[\n {\n \"identifier\": \"FishBowl\",\n \"path\": \"data/dataloader_Fishbowl.py\",\n \"snippet\": \"class FishBowl(object):\\n def __init__(self, config, mode, subtest=None):\\n self.datatype = mode\\n data_dir = config.root_path\\n\\n self.img_path = os.path.join(data_dir, self.datatype+\\\"_data\\\", self.datatype+\\\"_frames\\\")\\n self.mode = mode\\n self.dtype = torch.float32\\n self.test_set = subtest\\n \\n self.data_summary = pickle.load(open(os.path.join(data_dir, self.datatype+\\\"_data\\\", self.datatype+\\\"_data.pkl\\\"), \\\"rb\\\"))\\n self.obj_lists = list(self.data_summary.keys())\\n self.device = \\\"cpu\\\"\\n\\n self.seq_len = 32 if self.mode == \\\"test\\\" else config.train_seq_len\\n\\n self.cur_vid = None\\n self.video_frames = None\\n self.patch_h = config.patch_H\\n self.patch_w = config.patch_W\\n self.enlarge_coef = config.enlarge_coef\\n\\n def decode2binarymask(self, masks):\\n mask = mask_utils.decode(masks)\\n binary_masks = mask.astype('bool') # (Image_W,Image_H,128)\\n binary_masks = binary_masks.transpose(2,0,1) #(128, Image_W, Image_H)\\n return binary_masks\\n\\n def __len__(self):\\n return len(self.obj_lists)\\n\\n def __getitem__(self, idx):\\n v_id, obj_id = self.obj_lists[idx].split(\\\"_\\\")\\n if v_id != self.cur_vid:\\n self.cur_vid = v_id\\n fm_crop = []\\n fm_no_crop = []\\n vm_crop = []\\n vm_no_crop = []\\n img_crop = []\\n \\n obj_position = []\\n\\n counts = []\\n loss_mask_weight = []\\n\\n # for evaluation \\n video_ids = []\\n object_ids = []\\n frame_ids = []\\n\\n obj_dict = self.data_summary[self.obj_lists[idx]]\\n timesteps = list(obj_dict.keys())\\n assert np.all(np.diff(sorted(timesteps))==1)\\n start_t, end_t = min(timesteps), max(timesteps)\\n # print(start_t, end_t)\\n if self.mode != \\\"test\\\" and end_t - start_t > self.seq_len - 1:\\n start_t = np.random.randint(start_t, end_t-(self.seq_len-2))\\n end_t = start_t + self.seq_len - 1\\n\\n if self.mode == \\\"test\\\":\\n if start_t + self.seq_len-1<=end_t:\\n end_t = start_t + self.seq_len-1\\n\\n for t_step in range(start_t, end_t):\\n image_path = os.path.join(self.img_path, v_id, str(t_step).zfill(5)+'.png')\\n img = cv2.imread(image_path)[:,:,::-1]\\n # get visible mask and full mask\\n vm = self.decode2binarymask(obj_dict[t_step][\\\"VM\\\"])[0]\\n fm = self.decode2binarymask(obj_dict[t_step][\\\"FM\\\"])[0] # 320, 480\\n vx_min, vx_max, vy_min, vy_max = obj_dict[t_step][\\\"VM_bx\\\"]\\n x_center = (vx_min + vx_max) // 2\\n y_center = (vy_min + vy_max) // 2\\n x_len = int((vx_max - vx_min) * self.enlarge_coef)\\n y_len = int((vy_max - vy_min) * self.enlarge_coef)\\n vx_min = max(0, x_center - x_len // 2)\\n vx_max = min(320, x_center + x_len // 2)\\n vy_min = max(0, y_center - y_len // 2)\\n vy_max = min(480, y_center + y_len // 2)\\n\\n obj_position.append([vx_min, vx_max, vy_min, vy_max])\\n vm_crop.append(vm[vx_min:vx_max+1, vy_min:vy_max+1])\\n fm_crop.append(fm[vx_min:vx_max+1, vy_min:vy_max+1])\\n img_crop.append(img[vx_min:vx_max+1, vy_min:vy_max+1])\\n\\n vm_no_crop.append(vm)\\n fm_no_crop.append(fm)\\n # get loss mask\\n loss_mask_weight.append(self.decode2binarymask(obj_dict[t_step][\\\"loss_mask_weight\\\"])[0])\\n\\n # for evaluation\\n video_ids.append(int(v_id))\\n object_ids.append(int(obj_id))\\n frame_ids.append(t_step)\\n counts.append(1)\\n \\n if True:\\n num_pad = self.seq_len - (end_t - start_t)\\n for _ in range(num_pad):\\n obj_position.append(copy.deepcopy(obj_position[-1]))\\n\\n fm_crop.append(copy.deepcopy(fm_crop[-1]))\\n fm_no_crop.append(copy.deepcopy(fm_no_crop[-1]))\\n vm_crop.append(copy.deepcopy(vm_crop[-1]))\\n vm_no_crop.append(copy.deepcopy(vm_no_crop[-1]))\\n img_crop.append(copy.deepcopy(img_crop[-1]))\\n\\n loss_mask_weight.append(copy.deepcopy(loss_mask_weight[-1]))\\n \\n video_ids.append(video_ids[-1])\\n object_ids.append(object_ids[-1])\\n frame_ids.append(frame_ids[-1] + 1)\\n counts.append(0)\\n \\n vm_crop, vm_crop_gt, fm_crop, img_crop, vm_pad, vm_scale = self.crop_and_rescale(vm_crop, fm_crop, img_crop)\\n\\n vm_crop = np.stack(vm_crop, axis=0) # Seq_len * h * w\\n vm_crop_gt = np.stack(vm_crop_gt, axis=0) # Seq_len * h * w\\n vm_no_crop = np.stack(vm_no_crop, axis=0) # Seq_len * H * W\\n fm_crop = np.stack(fm_crop, axis=0) # Seq_len * h * w\\n fm_no_crop = np.stack(fm_no_crop, axis=0) # Seq_len * H * W\\n\\n vm_crop = torch.from_numpy(np.array(vm_crop)).to(self.dtype).to(self.device)\\n vm_crop_gt = torch.from_numpy(np.array(vm_crop_gt)).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n fm_crop = torch.from_numpy(np.array(fm_crop)).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n\\n vm_pad = torch.from_numpy(np.array(vm_pad)).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(np.array(vm_scale)).to(self.dtype).to(self.device)\\n\\n video_ids = torch.from_numpy(np.array(video_ids)).to(self.dtype).to(self.device)\\n object_ids = torch.from_numpy(np.array(object_ids)).to(self.dtype).to(self.device)\\n frame_ids = torch.from_numpy(np.array(frame_ids)).to(self.dtype).to(self.device)\\n counts = torch.from_numpy(np.array(counts)).to(self.dtype).to(self.device)\\n loss_mask_weight = torch.from_numpy(np.array(loss_mask_weight)).to(self.dtype).to(self.device) \\n obj_position = torch.from_numpy(np.array(obj_position)).to(self.dtype).to(self.device)\\n\\n obj_data = {\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"video_ids\\\": video_ids,\\n \\\"object_ids\\\": object_ids,\\n \\\"frame_ids\\\": frame_ids,\\n \\\"counts\\\": counts,\\n \\\"loss_mask\\\": loss_mask_weight, \\n \\\"obj_position\\\": obj_position,\\n }\\n\\n return obj_data\\n\\n def crop_and_rescale(self, vm_crop, fm_crop_vm=None, img_crop=None):\\n h, w = np.array([m.shape for m in vm_crop]).max(axis=0)\\n vm_pad = []\\n vm_scale = []\\n vm_crop_gt = []\\n\\n for i, m in enumerate(vm_crop):\\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n vm_pad.append(np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)]))\\n vm_scale.append(np.array([self.patch_h/h, self.patch_w/w]))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n if self.mode==\\\"train\\\":\\n vm_crop[i] = self.data_augmentation(m)\\n vm_crop_gt.append(m)\\n else:\\n vm_crop[i] = m\\n vm_crop_gt.append(m)\\n\\n for i, m in enumerate(fm_crop_vm):\\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n fm_crop_vm[i] = m\\n\\n for i, img_ in enumerate(img_crop):\\n img_ = transform.rescale(img_, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop[i] = img_\\n\\n vm_pad = np.stack(vm_pad)\\n vm_scale = np.stack(vm_scale)\\n return vm_crop, vm_crop_gt, fm_crop_vm, img_crop, vm_pad, vm_scale\\n \\n def getImg(self, v_id):\\n imgs = []\\n imgs_list = os.listdir(os.path.join(self.img_path, v_id))\\n imgs_list.sort()\\n for sub_path in imgs_list:\\n img_path = os.path.join(self.img_path, v_id, sub_path)\\n img_tmp = plt.imread(img_path)\\n imgs.append(img_tmp)\\n assert len(imgs) == 128\\n return imgs\\n\\n def create_iterator(self, batch_size):\\n while True:\\n sample_loader = DataLoader(\\n dataset=self,\\n batch_size=batch_size,\\n drop_last=True,\\n collate_fn=self.collate_fn\\n )\\n for item in sample_loader:\\n yield item\\n \\n @staticmethod\\n def collate_fn(batch):\\n keys = batch[0].keys()\\n res = {}\\n for k in keys:\\n temp_ = []\\n for b in batch:\\n if b[k] is not None:\\n temp_.append(b[k])\\n if len(temp_) > 0:\\n res[k] = default_collate(temp_)\\n else:\\n res[k] = None\\n return res\\n \\n def data_augmentation(self, mask):\\n mask = mask.astype(np.float)\\n rdv = random.random()\\n n_repeat = random.randint(1, 4)\\n if rdv <= 0.1:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n elif rdv > 0.1 and rdv < 0.6:\\n rdv_1 = random.random()\\n rdv_2 = random.random()\\n for i in range(n_repeat):\\n w = random.randint(5, 13)\\n h = random.randint(5, 13)\\n kernel = np.ones((w, h), dtype=np.uint8)\\n if rdv_1 <= 0.5:\\n mask = cv2.dilate(mask, kernel, 1)\\n elif rdv_1 > 0.5 and rdv_1 <= 1.0:\\n mask = cv2.erode(mask, kernel, 1)\\n if rdv_2 <= 0.1:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n else:\\n mask = mask\\n return (mask>0.5)\"\n },\n {\n \"identifier\": \"MOViD_A\",\n \"path\": \"data/dataloader_MOViD_A.py\",\n \"snippet\": \"class MOViD_A(object):\\n def __init__(self, config, mode):\\n super(MOViD_A, self).__init__()\\n self.mode = mode\\n self.dtype = torch.float32\\n self.device = \\\"cpu\\\"\\n root_path = config.root_path\\n self.data_dir = os.path.join(root_path, mode)\\n \\n self.instance_list = np.genfromtxt(\\n os.path.join(root_path, \\\"{}_instance.txt\\\".format(mode)),\\n dtype=np.str,\\n encoding='utf-8'\\n )\\n\\n self.train_seq_len = 24\\n self.cur_vid = None\\n self.patch_h = config.patch_H\\n self.patch_w = config.patch_W\\n self.enlarge_coef = config.enlarge_coef\\n\\n def __len__(self):\\n return len(self.instance_list)\\n\\n def __getitem__(self, idx, specified_V_O_id=None):\\n # whether choose a specific instance to load\\n if specified_V_O_id is None:\\n v_id, obj_id, value = self.instance_list[idx].split(\\\"_\\\")\\n else:\\n v_id, obj_id, value = specified_V_O_id.split(\\\"_\\\")\\n v_id, obj_id, value = int(v_id), int(obj_id), int(value)\\n if v_id != self.cur_vid:\\n self.cur_vid = v_id\\n self.video_path = os.path.join(self.data_dir, str(v_id))\\n metadata = self.read_json(os.path.join(self.video_path, 'metadata.json'))\\n\\n self.num_frames = metadata[\\\"metadata\\\"][\\\"num_frames\\\"]\\n self.height = metadata['metadata']['height']\\n self.width = metadata['metadata']['width']\\n self.instances = [self.format_instance_information(obj) for obj in metadata[\\\"instances\\\"]]\\n\\n vis_mask_paths = [os.path.join(self.video_path, \\\"segmentation_full_{}.png\\\".format(str(f).zfill(5))) for f in range(self.num_frames)]\\n vis_mask = [np.array(Image.open(frame_path)) for frame_path in vis_mask_paths] #[t,h,w]\\n\\n full_mask_paths = [os.path.join(self.video_path, \\\"segmentation_{}_{}.png\\\".format(obj_id, str(f).zfill(5))) for f in range(self.num_frames)]\\n full_mask = [np.array(Image.open(frame_path)) for frame_path in full_mask_paths] #[t,h,w]\\n \\n rgb_img_path = [os.path.join(self.video_path, \\\"rgba_full_{}.png\\\".format(str(f).zfill(5))) for f in range(self.num_frames)]\\n rgb_img = [np.array(Image.open(frame_path))[...,:3] for frame_path in rgb_img_path]\\n \\n counts = []\\n obj_position = []\\n\\n vm_crop = []\\n vm_no_crop = []\\n fm_crop = []\\n fm_no_crop = []\\n loss_mask_weight = []\\n img_crop = []\\n # for evaluation \\n video_ids = []\\n object_ids = []\\n frame_ids = []\\n\\n timesteps = self.instances[obj_id]['bbox_frames']\\n start_t, end_t = 0, 23\\n if self.mode != \\\"test\\\" and end_t - start_t > self.train_seq_len - 1:\\n start_t = np.random.randint(start_t, end_t-(self.train_seq_len-2))\\n end_t = start_t + self.train_seq_len - 1\\n\\n for t_step in range(start_t, end_t+1):\\n Image_H, Image_W = self.height, self.width\\n # some objects will move out the field of view in some frames\\n if t_step in timesteps:\\n index = self.instances[obj_id][\\\"bbox_frames\\\"].index(t_step)\\n xmin, ymin, xmax, ymax = self.instances[obj_id][\\\"bboxes\\\"][index]\\n vx_min, vy_min, vx_max, vy_max = int(Image_H*xmin), int(Image_W*ymin), int(Image_H*xmax), int(Image_W*ymax)\\n counts.append(1)\\n else:\\n bboxs = mask_find_bboxs(full_mask[t_step].astype(np.uint8))\\n \\n if bboxs.size==0:\\n vx_min, vy_min, vx_max, vy_max = 0, 0, 256, 256\\n else:\\n b = bboxs[-1][:4]\\n vx_min, vy_min, vx_max, vy_max = b[1], b[0], b[1]+b[3], b[0]+b[2]\\n counts.append(0)\\n\\n # enlarge the bbox\\n x_center = (vx_min + vx_max) // 2\\n y_center = (vy_min + vy_max) // 2\\n x_len = int((vx_max - vx_min) * self.enlarge_coef)\\n y_len = int((vy_max - vy_min) * self.enlarge_coef)\\n vx_min = max(0, x_center - x_len // 2)\\n vx_max = min(Image_H, x_center + x_len // 2)\\n vy_min = max(0, y_center - y_len // 2)\\n vy_max = min(Image_W, y_center + y_len // 2)\\n\\n obj_position.append([vx_min, vx_max, vy_min, vy_max])\\n\\n # get mask\\n vm = vis_mask[t_step]\\n vm_crop.append(vm[vx_min:vx_max+1, vy_min:vy_max+1]==value)\\n vm_no_crop.append(vm==value)\\n\\n fm = full_mask[t_step]\\n fm_crop.append(fm[vx_min:vx_max+1, vy_min:vy_max+1]==value)\\n fm_no_crop.append(fm==value)\\n \\n # get image\\n image = rgb_img[t_step]\\n img_crop.append(image[vx_min:vx_max+1, vy_min:vy_max+1])\\n\\n # get loss mask\\n fore_ground = vm == 0\\n obj_ground = vm==value\\n loss_mask = np.logical_or(fore_ground, obj_ground)\\n\\n loss_mask_weight.append(loss_mask)\\n\\n # for evaluation\\n video_ids.append(v_id)\\n object_ids.append(obj_id)\\n frame_ids.append(t_step)\\n\\n obj_position = torch.from_numpy(np.array(obj_position)).to(self.dtype).to(self.device)\\n \\n vm_crop, fm_crop, vm_pad, vm_scale, vm_crop_gt, img_crop = self.crop_and_rescale(vm_crop, fm_crop, img_crop)\\n\\n vm_crop = np.stack(vm_crop, axis=0) # Seq_len * h * w\\n vm_no_crop = np.stack(vm_no_crop, axis=0) # Seq_len * H * W\\n # fm_crop = np.stack(fm_crop, axis=0) # Seq_len * h * w\\n fm_crop = np.stack(fm_crop, axis=0) # Seq_len * h * w\\n fm_no_crop = np.stack(fm_no_crop, axis=0) # Seq_len * H * W\\n img_crop = np.stack(img_crop, axis=0) # Sqe_len * H * W\\n\\n vm_crop = torch.from_numpy(np.array(vm_crop)).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n fm_crop = torch.from_numpy(np.array(fm_crop)).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n\\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n\\n vm_pad = torch.from_numpy(np.array(vm_pad)).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(np.array(vm_scale)).to(self.dtype).to(self.device)\\n\\n video_ids = torch.from_numpy(np.array(video_ids)).to(self.dtype).to(self.device)\\n object_ids = torch.from_numpy(np.array(object_ids)).to(self.dtype).to(self.device)\\n frame_ids = torch.from_numpy(np.array(frame_ids)).to(self.dtype).to(self.device)\\n counts = torch.from_numpy(np.array(counts)).to(self.dtype).to(self.device)\\n loss_mask_weight = torch.from_numpy(np.array(loss_mask_weight)).to(self.dtype).to(self.device) \\n obj_position = torch.from_numpy(np.array(obj_position)).to(self.dtype).to(self.device)\\n\\n obj_data = {\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n\\n \\\"img_crop\\\": img_crop,\\n \\n \\\"fm_crop\\\": fm_crop,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n\\n \\\"obj_position\\\": obj_position, \\n \\\"loss_mask\\\": loss_mask_weight, \\n \\\"counts\\\": counts,\\n \\\"video_ids\\\": video_ids,\\n \\\"object_ids\\\": object_ids,\\n \\\"frame_ids\\\": frame_ids,\\n }\\n\\n return obj_data\\n\\n def crop_and_rescale(self, vm_crop, fm_crop=None,img_crop=None):\\n h, w = np.array([m.shape for m in vm_crop]).max(axis=0)\\n vm_pad = []\\n vm_crop_gt = []\\n vm_scale = []\\n for i, img in enumerate(img_crop):\\n img = transform.rescale(img, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img = np.pad(img, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop[i] = img\\n\\n for i, m in enumerate(vm_crop):\\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n if self.mode==\\\"train\\\":\\n vm_crop[i] = self.data_augmentation(m)\\n else:\\n vm_crop[i] = m\\n vm_crop_gt.append(m)\\n vm_pad.append(np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)]))\\n vm_scale.append(np.array([self.patch_h/h, self.patch_w/w]))\\n\\n for i, m in enumerate(fm_crop):\\n m = transform.rescale(m, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n fm_crop[i] = m\\n\\n vm_pad = np.stack(vm_pad)\\n vm_scale = np.stack(vm_scale)\\n return vm_crop, fm_crop, vm_pad, vm_scale, vm_crop_gt,img_crop\\n \\n def read_json(self,dir_):\\n with open(dir_) as f:\\n data = json.load(f)\\n return data\\n\\n def format_instance_information(self, obj):\\n return {\\n \\\"bboxes\\\": obj[\\\"bboxes\\\"],\\n \\\"bbox_frames\\\": obj[\\\"bbox_frames\\\"],\\n }\\n\\n def create_iterator(self, batch_size):\\n while True:\\n sample_loader = DataLoader(\\n dataset=self,\\n batch_size=batch_size,\\n drop_last=True,\\n collate_fn=self.collate_fn\\n )\\n\\n for item in sample_loader:\\n yield item\\n\\n @staticmethod\\n def collate_fn(batch):\\n keys = batch[0].keys()\\n res = {}\\n for k in keys:\\n temp_ = []\\n for b in batch:\\n if b[k] is not None:\\n temp_.append(b[k])\\n if len(temp_) > 0:\\n res[k] = default_collate(temp_)\\n else:\\n res[k] = None\\n return res\\n \\n def data_augmentation(self, mask):\\n mask = mask.astype(np.float)\\n rdv = random.random()\\n n_repeat = random.randint(1, 4)\\n if rdv <= 0.1:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n elif rdv > 0.1 and rdv < 0.6:\\n rdv_1 = random.random()\\n rdv_2 = random.random()\\n for i in range(n_repeat):\\n w = random.randint(5, 13)\\n h = random.randint(5, 13)\\n kernel = np.ones((w, h), dtype=np.uint8)\\n if rdv_1 <= 0.5:\\n mask = cv2.dilate(mask, kernel, 1)\\n elif rdv_1 > 0.5 and rdv_1 <= 1.0:\\n mask = cv2.erode(mask, kernel, 1)\\n if rdv_2 <= 0.1:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n else:\\n mask = mask\\n return (mask>0.5)\"\n },\n {\n \"identifier\": \"Kins_Fusion_dataset\",\n \"path\": \"data/dataloader_KINS.py\",\n \"snippet\": \"class Kins_Fusion_dataset(torch.utils.data.Dataset):\\n def __init__(self, config, mode):\\n super(Kins_Fusion_dataset, self).__init__()\\n self.config = config\\n self.mode = mode\\n self.root_path = config.root_path\\n \\n # Load Fusion dataset\\n self.data_info = pickle.load(open(os.path.join(self.root_path, \\\"fusion_{}.pkl\\\".format(self.mode)), \\\"rb\\\"))\\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \\\"c2f_seg_{}_list.txt\\\".format(self.mode)), dtype=np.str, encoding='utf-8')\\n self.img_root_path = os.path.join(self.root_path, \\\"{}ing\\\".format(mode),\\\"image_2\\\")\\n \\n # Load the GT of AISFormer\\n if mode==\\\"train\\\":\\n aisformer_gt = cvb.load(os.path.join(self.root_path, \\\"instances_train.json\\\"))\\n else:\\n aisformer_gt = cvb.load(os.path.join(self.root_path, \\\"instances_val_upate.json\\\"))\\n annotations = aisformer_gt[\\\"annotations\\\"]\\n images = aisformer_gt[\\\"images\\\"]\\n self.images, self.annotations = self.make_json_dict(images, annotations)\\n \\n # Load the GT of vanilla KINS\\n self.base_img_path = os.path.join(self.root_path, \\\"{}ing\\\".format(mode), \\\"image_2\\\")\\n self.base_ann_path= os.path.join(self.root_path, \\\"update_{}_2020.json\\\".format(mode))\\n annotations = cvb.load(self.base_ann_path)\\n imgs_info = annotations['images']\\n anns_info = annotations[\\\"annotations\\\"]\\n self.imgs_dict, self.anns_dict = self.make_json_dict(imgs_info, anns_info)\\n\\n # dataloader setting\\n self.dtype = torch.float32\\n self.enlarge_coef = 2\\n self.patch_h = 256\\n self.patch_w = 256\\n self.device = \\\"cpu\\\"\\n\\n def __len__(self):\\n return self.label_info.shape[0]\\n\\n def __getitem__(self, index):\\n return self.load_item(index)\\n \\n def load_item(self, index):\\n # load aisformer predicted visible masks\\n if \\\"aisformer\\\" in self.label_info[index]:\\n dataset_name, image_id, anno_id = self.label_info[index].split(\\\",\\\")\\n image_id, anno_id = int(image_id), int(anno_id)\\n # add image information\\n img_name = self.images[image_id]\\n img_path = os.path.join(self.img_root_path, img_name)\\n # img_path = os.path.join(self.img_root_path, str(image_id).zfill(6)+ \\\".png\\\")\\n img = np.array(Image.open(img_path))\\n instances = self.data_info['{}_{}'.format(dataset_name, image_id)][anno_id]\\n segmentation = instances[\\\"pred_visible_mask\\\"]\\n height, width = segmentation[\\\"size\\\"]\\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\\n vm_no_crop_gt = mask_utils.decode([instances[\\\"gt_visible_mask\\\"]]).astype(bool)\\n rles = mask_utils.frPyObjects(instances[\\\"gt_full_mask\\\"], height, width)\\n fm_no_crop = mask_utils.decode(mask_utils.merge(rles)).astype(bool)\\n fm_no_crop = fm_no_crop[..., np.newaxis]\\n\\n bbox = instances[\\\"pred_visible_mask_bbox\\\"]\\n y_min, x_min, w, h = bbox\\n y_max, x_max = y_min + w, x_min + h\\n x_center = (x_min + x_max) // 2\\n y_center = (y_min + y_max) // 2\\n x_len = int((x_max - x_min) * self.enlarge_coef)\\n y_len = int((y_max - y_min) * self.enlarge_coef)\\n x_min = max(0, x_center - x_len // 2)\\n x_max = min(height, x_center + x_len // 2)\\n y_min = max(0, y_center - y_len // 2)\\n y_max = min(width, y_center + y_len // 2)\\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\\n \\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\\n \\n h, w = vm_crop.shape[:2]\\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop = m[np.newaxis, ...]\\n\\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop = img_\\n\\n # data augmentation\\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\\n\\n h, w = vm_crop_gt.shape[:2]\\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop_gt = m[np.newaxis, ...]\\n\\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \\n fm_crop = m[np.newaxis, ...]\\n\\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\\n loss_mask[loss_mask==255]=0\\n loss_mask = 1-loss_mask.astype(bool)\\n\\n vm_no_crop = vm_no_crop[np.newaxis, ...]\\n fm_no_crop = fm_no_crop[np.newaxis, ...]\\n\\n obj_position = np.array([x_min, x_max, y_min, y_max])\\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\\n counts = np.array([1])\\n \\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\\n\\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\\n\\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n vm_no_crop_gt = torch.from_numpy(np.array(vm_no_crop_gt)).to(self.dtype).to(self.device)\\n\\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n\\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\\n \\n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\\n \\n if self.mode==\\\"train\\\":\\n meta = {\\n # \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop_aug,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n # \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n # \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n }\\n elif self.mode==\\\"test\\\":\\n meta = {\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_no_crop_gt\\\": vm_no_crop_gt,\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n }\\n return meta\\n else:\\n img_id, anno_id, category_id = self.label_info[index].split(\\\"_\\\")\\n img_id, anno_id, category_id = int(img_id), int(anno_id), int(category_id)\\n\\n img_name = self.imgs_dict[img_id]\\n img_path = os.path.join(self.base_img_path, img_name)\\n \\n img = cv2.imread(img_path, cv2.IMREAD_COLOR)\\n height, width, _ = img.shape\\n \\n ann = self.anns_dict[img_id][anno_id]\\n fm_no_crop = self.polys_to_mask(ann[\\\"a_segm\\\"], height, width)\\n vm_no_crop = self.polys_to_mask(ann[\\\"i_segm\\\"], height, width)\\n if np.sum(vm_no_crop)==0:\\n counts = np.array([0])\\n else:\\n counts = np.array([1])\\n y_min, x_min, w, h = ann[\\\"i_bbox\\\"]\\n\\n y_max, x_max = y_min + w, x_min + h\\n x_center = (x_min + x_max) // 2\\n y_center = (y_min + y_max) // 2\\n x_len = int((x_max - x_min) * self.enlarge_coef)\\n y_len = int((y_max - y_min) * self.enlarge_coef)\\n x_min = max(0, x_center - x_len // 2)\\n x_max = min(height, x_center + x_len // 2)\\n y_min = max(0, y_center - y_len // 2)\\n y_max = min(width, y_center + y_len // 2)\\n \\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1].astype(bool)\\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1].astype(bool)\\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\\n\\n h, w = vm_crop.shape[:2]\\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop = m[np.newaxis, ...]\\n\\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop = img_\\n\\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \\n fm_crop = m[np.newaxis, ...]\\n\\n obj_position = np.array([x_min, x_max, y_min, y_max])\\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\\n\\n vm_no_crop = vm_no_crop[np.newaxis, ...]\\n fm_no_crop = fm_no_crop[np.newaxis, ...]\\n\\n loss_mask = fm_no_crop-vm_no_crop\\n loss_mask[loss_mask==255]=0\\n loss_mask = 1-loss_mask.astype(bool)\\n # data augmentation\\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\\n\\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\\n\\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n # vm_crop here is the GT\\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\\n \\n img_id = torch.from_numpy(np.array(img_id)).to(self.dtype).to(self.device)\\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\\n # category_id = torch.from_numpy(np.array(category_id)).to(self.dtype).to(self.device)\\n if self.mode==\\\"train\\\":\\n meta = {\\n # \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop_aug,\\n \\\"vm_crop_gt\\\": vm_crop,\\n # \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n # \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": img_id,\\n \\\"anno_id\\\": anno_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n }\\n elif self.mode==\\\"test\\\":\\n meta = {\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop_gt\\\": vm_crop,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"vm_no_crop_gt\\\": vm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": img_id,\\n \\\"anno_id\\\": anno_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n }\\n return meta\\n\\n def data_augmentation(self, mask):\\n mask = mask.astype(np.float)\\n rdv = random.random()\\n n_repeat = random.randint(1, 4)\\n if rdv <= 0.2:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n elif rdv > 0.2 and rdv <0.6:\\n rdv_1 = random.random()\\n rdv_2 = random.random()\\n for i in range(n_repeat):\\n w = random.randint(5, 13)\\n h = random.randint(5, 13)\\n kernel = np.ones((w, h), dtype=np.uint8)\\n if rdv_1 <= 0.55:\\n mask = cv2.dilate(mask, kernel, 1)\\n elif rdv_1 > 0.55 and rdv_1 <= 1.0:\\n mask = cv2.erode(mask, kernel, 1)\\n if rdv_2 <= 0.1:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n else:\\n mask = mask\\n return (mask>0.5)\\n \\n @staticmethod\\n def collate_fn(batch):\\n keys = batch[0].keys()\\n res = {}\\n for k in keys:\\n temp_ = []\\n for b in batch:\\n if b[k] is not None:\\n temp_.append(b[k])\\n if len(temp_) > 0:\\n res[k] = default_collate(temp_)\\n else:\\n res[k] = None\\n\\n return res\\n\\n def create_iterator(self, batch_size):\\n while True:\\n sample_loader = DataLoader(\\n dataset=self,\\n batch_size=batch_size,\\n drop_last=True,\\n collate_fn=self.collate_fn\\n )\\n\\n for item in sample_loader:\\n yield item\\n\\n def make_json_dict(self, imgs, anns):\\n imgs_dict = {}\\n anns_dict = {}\\n for ann in anns:\\n image_id = ann[\\\"image_id\\\"]\\n if not image_id in anns_dict:\\n anns_dict[image_id] = []\\n anns_dict[image_id].append(ann)\\n else:\\n anns_dict[image_id].append(ann)\\n \\n for img in imgs:\\n image_id = img['id']\\n imgs_dict[image_id] = img['file_name']\\n\\n return imgs_dict, anns_dict\\n\\n def polys_to_mask(self, polygons, height, width):\\n rles = mask_utils.frPyObjects(polygons, height, width)\\n rle = mask_utils.merge(rles)\\n mask = mask_utils.decode(rle)\\n return mask\"\n },\n {\n \"identifier\": \"KINS_Aisformer_VRSP_Intersection\",\n \"path\": \"data/dataloader_KINS.py\",\n \"snippet\": \"class KINS_Aisformer_VRSP_Intersection(torch.utils.data.Dataset):\\n def __init__(self, config, mode):\\n super(KINS_Aisformer_VRSP_Intersection, self).__init__()\\n self.config = config\\n self.mode = mode\\n self.root_path = config.root_path\\n \\n # Load Intersection dataset\\n self.data_info = pickle.load(open(os.path.join(self.root_path, \\\"kins_intersection.pkl\\\"), \\\"rb\\\"))\\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \\\"kins_intersection_list.txt\\\"), dtype=np.str, encoding='utf-8')\\n if mode==\\\"train\\\":\\n aisformer_gt = cvb.load(os.path.join(self.root_path, \\\"instances_train.json\\\"))\\n else:\\n aisformer_gt = cvb.load(os.path.join(self.root_path, \\\"instances_val_upate.json\\\"))\\n annotations = aisformer_gt[\\\"annotations\\\"]\\n images = aisformer_gt[\\\"images\\\"]\\n self.images, self.annotations = self.make_json_dict(images, annotations)\\n self.img_root_path = os.path.join(self.root_path, \\\"{}ing\\\".format(mode), \\\"image_2\\\")\\n self.dtype = torch.float32\\n self.enlarge_coef = 2\\n self.patch_h = 256\\n self.patch_w = 256\\n self.device = \\\"cpu\\\"\\n \\n def __len__(self):\\n return self.label_info.shape[0]\\n\\n def __getitem__(self, index):\\n return self.load_item(index)\\n \\n def mask_find_bboxs(self, mask):\\n retval, labels, stats, centroids = cv2.connectedComponentsWithStats(mask, connectivity=8)\\n stats = stats[stats[:,4].argsort()]\\n return stats\\n \\n def generate_heatmap(self, mask, kernel, sigma):\\n heatmap = cv2.GaussianBlur(mask, kernel, sigma)\\n am = np.amax(heatmap)\\n heatmap /= am / 1\\n return heatmap\\n \\n def load_item(self, index):\\n image_id, anno_id = self.label_info[index].split(\\\"_\\\")\\n image_id, anno_id = int(image_id), int(anno_id)\\n instances = self.data_info[image_id][anno_id]\\n\\n segmentation = instances[\\\"pred_visible_mask\\\"]\\n height, width = segmentation[\\\"size\\\"]\\n # add image information\\n img_name = self.images[image_id]\\n img_path = os.path.join(self.img_root_path, img_name)\\n # img_path = os.path.join(self.img_root_path, str(image_id).zfill(6)+ \\\".png\\\")\\n img = Image.open(img_path)\\n img = img.resize((width,height), Image.ANTIALIAS)\\n img = np.array(img)\\n \\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\\n vm_no_crop_gt = mask_utils.decode([instances[\\\"gt_visible_mask\\\"]]).astype(bool)\\n # fm_no_crop = mask_utils.decode([instances[\\\"gt_full_mask\\\"]]).astype(bool)\\n rles = mask_utils.frPyObjects(instances[\\\"gt_full_mask\\\"], height, width)\\n fm_no_crop = mask_utils.decode(mask_utils.merge(rles)).astype(bool)\\n \\n bbox = instances[\\\"pred_visible_mask_bbox\\\"]\\n y_min, x_min, w, h = bbox\\n y_max, x_max = y_min + w, x_min + h\\n x_center = (x_min + x_max) // 2\\n y_center = (y_min + y_max) // 2\\n x_len = int((x_max - x_min) * self.enlarge_coef)\\n y_len = int((y_max - y_min) * self.enlarge_coef)\\n x_min = max(0, x_center - x_len // 2)\\n x_max = min(height, x_center + x_len // 2)\\n y_min = max(0, y_center - y_len // 2)\\n y_max = min(width, y_center + y_len // 2)\\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\\n\\n x_center_crop = x_center - x_min\\n y_center_crop = y_center - y_min\\n \\n fm_no_crop = fm_no_crop[..., np.newaxis]\\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n\\n h, w = vm_crop.shape[:2]\\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop = m[np.newaxis, ...]\\n \\n center_crop = np.zeros_like(vm_crop[0])\\n x_center_crop = int(x_center_crop*self.patch_h/h)\\n y_center_crop = int(y_center_crop*self.patch_w/w)\\n center_crop[x_center_crop: x_center_crop+1, y_center_crop: y_center_crop+1]=1\\n center_crop = self.generate_heatmap(center_crop.astype(np.float), (35, 35), 9)\\n center_crop = center_crop[np.newaxis, ...]\\n\\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop = img_\\n\\n h, w = vm_crop_gt.shape[:2]\\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop_gt = m[np.newaxis, ...]\\n\\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \\n fm_crop = m[np.newaxis, ...]\\n\\n refine_loss_mask = 1 - (vm_crop_gt==vm_crop).astype(bool)\\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\\n # import pdb;pdb.set_trace()\\n loss_mask[loss_mask==255]=0\\n loss_mask = 1-loss_mask.astype(bool)\\n\\n vm_no_crop = vm_no_crop[np.newaxis, ...]\\n fm_no_crop = fm_no_crop[np.newaxis, ...]\\n\\n obj_position = np.array([x_min, x_max, y_min, y_max])\\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\\n counts = np.array([1])\\n\\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\\n\\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\\n\\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\\n vm_no_crop_gt = torch.from_numpy(vm_no_crop_gt).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n refine_loss_mask = torch.from_numpy(np.array(refine_loss_mask)).to(self.dtype).to(self.device)\\n center_crop = torch.from_numpy(np.array(center_crop)).to(self.dtype).to(self.device)\\n \\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n img = torch.from_numpy(np.array(img)).to(self.dtype).to(self.device)\\n\\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\\n \\n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\\n \\n if self.mode==\\\"train\\\":\\n meta = {\\n # \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop,\\n # \\\"vm_crop_gt\\\": vm_crop_gt,\\n # \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"center_crop\\\": center_crop,\\n # \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n }\\n # elif self.mode==\\\"test\\\":\\n # meta = {\\n # # \\\"vm_no_crop\\\": vm_no_crop,\\n # \\\"vm_crop\\\": vm_crop,\\n # \\\"vm_crop_gt\\\": vm_crop_gt,\\n # # \\\"vm_no_crop_gt\\\": vm_no_crop_gt,\\n # # \\\"refine_loss_mask\\\": refine_loss_mask,\\n # # \\\"fm_no_crop\\\": fm_no_crop,\\n # \\\"fm_crop\\\": fm_crop,\\n # \\\"img_crop\\\": img_crop,\\n # # \\\"loss_mask\\\": loss_mask,\\n # # \\\"obj_position\\\": obj_position,\\n # # \\\"vm_pad\\\": vm_pad,\\n # # \\\"vm_scale\\\": vm_scale,\\n # # \\\"counts\\\":counts,\\n # # \\\"img_id\\\": image_id,\\n # # \\\"anno_id\\\": anno_id,\\n # # # for vq\\n # # # \\\"mask_crop\\\": fm_crop\\n # # # \\\"img\\\":img,\\n # }\\n elif self.mode==\\\"test\\\":\\n meta = {\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n \\\"vm_no_crop_gt\\\": vm_no_crop_gt,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"center_crop\\\": center_crop,\\n \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n \\\"img\\\":img,\\n }\\n return meta\\n\\n @staticmethod\\n def collate_fn(batch):\\n keys = batch[0].keys()\\n res = {}\\n for k in keys:\\n temp_ = []\\n for b in batch:\\n if b[k] is not None:\\n temp_.append(b[k])\\n if len(temp_) > 0:\\n res[k] = default_collate(temp_)\\n else:\\n res[k] = None\\n\\n return res\\n\\n def create_iterator(self, batch_size):\\n while True:\\n sample_loader = DataLoader(\\n dataset=self,\\n batch_size=batch_size,\\n drop_last=True,\\n collate_fn=self.collate_fn\\n )\\n\\n for item in sample_loader:\\n yield item\\n\\n def polys_to_mask(self, polygons, height, width):\\n rles = mask_utils.frPyObjects(polygons, height, width)\\n rle = mask_utils.merge(rles)\\n mask = mask_utils.decode(rle)\\n return mask\\n \\n def make_json_dict(self, imgs, anns):\\n imgs_dict = {}\\n anns_dict = {}\\n for ann in anns:\\n image_id = ann[\\\"image_id\\\"]\\n if not image_id in anns_dict:\\n anns_dict[image_id] = []\\n anns_dict[image_id].append(ann)\\n else:\\n anns_dict[image_id].append(ann)\\n \\n for img in imgs:\\n image_id = img['id']\\n imgs_dict[image_id] = img['file_name']\\n\\n return imgs_dict, anns_dict\"\n },\n {\n \"identifier\": \"COCOA_Fusion_dataset\",\n \"path\": \"data/dataloader_COCOA.py\",\n \"snippet\": \"class COCOA_Fusion_dataset(torch.utils.data.Dataset):\\n def __init__(self, config, mode):\\n super(COCOA_Fusion_dataset, self).__init__()\\n self.config = config\\n self.mode = mode\\n self.root_path = config.root_path\\n \\n # Load Fusion dataset \\n self.data_info = pickle.load(open(os.path.join(self.root_path, \\\"fusion_{}.pkl\\\".format(self.mode)), \\\"rb\\\"))\\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \\\"c2f_seg_{}_list.txt\\\".format(self.mode)), dtype=np.str, encoding='utf-8')\\n \\n if mode==\\\"train\\\":\\n train_label = cvb.load(os.path.join(self.root_path, \\\"COCO_amodal_train2014_with_classes.json\\\"))\\n self.anns_dict = train_label[\\\"annotations\\\"]\\n self.img_root_path = os.path.join(self.root_path, \\\"train2014\\\")\\n elif mode==\\\"test\\\":\\n val_label = cvb.load(os.path.join(self.root_path, \\\"COCO_amodal_val2014_with_classes.json\\\"))\\n self.anns_dict = val_label[\\\"annotations\\\"]\\n self.img_root_path = os.path.join(self.root_path, \\\"val2014\\\")\\n \\n self.dtype = torch.float32\\n self.enlarge_coef = 2\\n self.patch_h = 256\\n self.patch_w = 256\\n self.device = \\\"cpu\\\"\\n\\n \\n def __len__(self):\\n return self.label_info.shape[0]\\n\\n def __getitem__(self, index):\\n return self.load_item(index)\\n \\n def load_item(self, index):\\n # predicted vm\\n if len(self.label_info[index].split(\\\",\\\"))==3:\\n dataset_name, image_id, anno_id = self.label_info[index].split(\\\",\\\")\\n image_id, anno_id = int(image_id), int(anno_id)\\n if self.mode==\\\"train\\\":\\n img_path = os.path.join(self.img_root_path, \\\"COCO_{}2014_{}.jpg\\\".format(self.mode, str(image_id).zfill(12)))\\n elif self.mode==\\\"test\\\":\\n img_path = os.path.join(self.img_root_path, \\\"COCO_val2014_{}.jpg\\\".format(str(image_id).zfill(12)))\\n img = np.array(Image.open(img_path))\\n if len(img.shape)==2:\\n img = np.repeat(img[:, :, np.newaxis], 3, axis=2)\\n instances = self.data_info[\\\"{}_{}\\\".format(dataset_name, image_id)][anno_id]\\n segmentation = instances[\\\"pred_visible_mask\\\"]\\n height, weight = segmentation[\\\"size\\\"]\\n # occlude_rate = instances[\\\"occlude_rate\\\"]\\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\\n fm_no_crop = mask_utils.decode([instances[\\\"gt_full_mask\\\"]]).astype(bool)\\n vm_no_crop_gt = mask_utils.decode([instances[\\\"gt_visible_mask\\\"]]).astype(bool)\\n\\n bbox = instances[\\\"pred_visible_mask_bbox\\\"]\\n y_min, x_min, w, h = bbox\\n y_max, x_max = y_min + w, x_min + h\\n x_center = (x_min + x_max) // 2\\n y_center = (y_min + y_max) // 2\\n x_len = int((x_max - x_min) * self.enlarge_coef)\\n y_len = int((y_max - y_min) * self.enlarge_coef)\\n x_min = max(0, x_center - x_len // 2)\\n x_max = min(height, x_center + x_len // 2)\\n y_min = max(0, y_center - y_len // 2)\\n y_max = min(weight, y_center + y_len // 2)\\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\\n # import pdb;pdb.set_trace()\\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n\\n h, w = vm_crop.shape[:2]\\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop = m[np.newaxis, ...]\\n\\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop = img_\\n\\n h, w = vm_crop_gt.shape[:2]\\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop_gt = m[np.newaxis, ...]\\n\\n # data augmentation\\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\\n\\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \\n fm_crop = m[np.newaxis, ...]\\n # if self.mode==\\\"test\\\":\\n # loss_mask = mask_utils.decode([instances[\\\"loss_mask\\\"]]).astype(bool)[...,0]\\n # else:\\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\\n loss_mask[loss_mask==255]=0\\n loss_mask = 1-loss_mask.astype(bool)\\n\\n vm_no_crop = vm_no_crop[np.newaxis, ...]\\n fm_no_crop = fm_no_crop[np.newaxis, ...]\\n\\n obj_position = np.array([x_min, x_max, y_min, y_max])\\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\\n counts = np.array([1])\\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\\n\\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\\n\\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n\\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n img = torch.from_numpy(np.array(img)).to(self.dtype).to(self.device)\\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\\n \\n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\\n # occlude_rate = torch.from_numpy(np.array(occlude_rate)).to(self.dtype).to(self.device)\\n \\n if self.mode==\\\"train\\\":\\n meta = {\\n # \\\"vm_no_crop\\\": vm_no_crop,\\n # \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop\\\": vm_crop_aug,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n # \\\"vm_crop_gt\\\": vm_crop_gt,\\n # \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n # \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n # \\\"img_no_crop\\\": img,\\n }\\n elif self.mode==\\\"test\\\":\\n meta = {\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n # \\\"occlude_rate\\\":occlude_rate\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n # \\\"img_no_crop\\\": img,\\n }\\n return meta\\n # gt vm\\n elif len(self.label_info[index].split(\\\",\\\"))==2:\\n anno_id, img_path = self.label_info[index].split(\\\",\\\")\\n anno_id = int(anno_id)\\n img = cv2.imread(img_path, cv2.IMREAD_COLOR)\\n height, width, _ = img.shape\\n\\n ann = self.anns_dict[anno_id]\\n img_id = ann[\\\"image_id\\\"]\\n # category_id = ann[\\\"category_id\\\"]\\n\\n full_mask = ann[\\\"segmentation\\\"]\\n fm_no_crop = mask_utils.decode(full_mask)[...,np.newaxis]\\n\\n visible_mask = ann[\\\"visible_mask\\\"]\\n vm_no_crop = mask_utils.decode(visible_mask)[...,np.newaxis]\\n\\n if np.sum(vm_no_crop)==0:\\n counts = np.array([0])\\n else:\\n counts = np.array([1])\\n y_min, x_min, w, h = ann[\\\"bbox\\\"]\\n y_max, x_max = y_min + w, x_min + h\\n y_min, x_min, y_max, x_max = int(y_min), int(x_min), int(y_max), int(x_max) \\n\\n x_center = (x_min + x_max) // 2\\n y_center = (y_min + y_max) // 2\\n x_len = int((x_max - x_min) * self.enlarge_coef)\\n y_len = int((y_max - y_min) * self.enlarge_coef)\\n x_min = max(0, x_center - x_len // 2)\\n x_max = min(height, x_center + x_len // 2)\\n y_min = max(0, y_center - y_len // 2)\\n y_max = min(width, y_center + y_len // 2)\\n \\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\\n\\n h, w = vm_crop.shape[:2]\\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop = m[np.newaxis, ...]\\n\\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop = img_\\n\\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \\n fm_crop = m[np.newaxis, ...]\\n\\n obj_position = np.array([x_min, x_max, y_min, y_max])\\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\\n\\n # full_pad = ((0, max(375-height, 0)), (0, max(1242-width, 0)))\\n # vm_no_crop = np.pad(vm_no_crop, full_pad)[:375, :1242]\\n # fm_no_crop = np.pad(fm_no_crop, full_pad)[:375, :1242]\\n vm_no_crop = vm_no_crop[np.newaxis, ...]\\n fm_no_crop = fm_no_crop[np.newaxis, ...]\\n\\n loss_mask = fm_no_crop-vm_no_crop\\n loss_mask[loss_mask==255]=0\\n loss_mask = 1-loss_mask.astype(bool)\\n # data augmentation\\n vm_crop_aug = self.data_augmentation(vm_crop[0])[np.newaxis, ...]\\n \\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\\n\\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\\n\\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\\n vm_crop_aug = torch.from_numpy(vm_crop_aug).to(self.dtype).to(self.device)\\n img_crop = torch.from_numpy(img_crop).to(self.dtype).to(self.device)\\n img = torch.from_numpy(img).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n \\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\\n \\n img_id = torch.from_numpy(np.array(img_id)).to(self.dtype).to(self.device)\\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\\n # category_id = torch.from_numpy(np.array(category_id)).to(self.dtype).to(self.device)\\n if self.mode==\\\"train\\\":\\n meta = {\\n # \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop_aug,\\n \\\"vm_crop_gt\\\": vm_crop,\\n # \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n # \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\": counts,\\n \\\"img_id\\\": img_id,\\n \\\"anno_id\\\": anno_id,\\n # \\\"category_id\\\": category_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n # \\\"img_no_crop\\\": img\\n }\\n elif self.mode==\\\"test\\\":\\n meta = {\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_no_crop_gt\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop_gt\\\": vm_crop,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": img_id,\\n \\\"anno_id\\\": anno_id,\\n # \\\"category_id\\\": category_id,\\n # for vq\\n # \\\"mask_crop\\\": fm_crop\\n \\\"img_no_crop\\\": img,\\n }\\n return meta\\n \\n @staticmethod\\n def collate_fn(batch):\\n keys = batch[0].keys()\\n res = {}\\n for k in keys:\\n temp_ = []\\n for b in batch:\\n if b[k] is not None:\\n temp_.append(b[k])\\n if len(temp_) > 0:\\n res[k] = default_collate(temp_)\\n else:\\n res[k] = None\\n\\n return res\\n\\n def create_iterator(self, batch_size):\\n while True:\\n sample_loader = DataLoader(\\n dataset=self,\\n batch_size=batch_size,\\n drop_last=True,\\n collate_fn=self.collate_fn\\n )\\n\\n for item in sample_loader:\\n yield item\\n\\n def polys_to_mask(self, polygons, height, width):\\n rles = mask_utils.frPyObjects(polygons, height, width)\\n rle = mask_utils.merge(rles)\\n mask = mask_utils.decode(rle)\\n return mask\\n\\n # def data_augmentation(self, mask):\\n # return mask\\n \\n def data_augmentation(self, mask):\\n mask = mask.astype(np.float)\\n rdv = random.random()\\n n_repeat = random.randint(1, 4)\\n if rdv <= 0.2:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n elif rdv > 0.2 and rdv <0.9:\\n rdv_1 = random.random()\\n rdv_2 = random.random()\\n for i in range(n_repeat):\\n w = random.randint(5, 13)\\n h = random.randint(5, 13)\\n kernel = np.ones((w, h), dtype=np.uint8)\\n if rdv_1 <= 0.6:\\n mask = cv2.dilate(mask, kernel, 1)\\n elif rdv_1 > 0.6 and rdv_1 <= 1.0:\\n mask = cv2.erode(mask, kernel, 1)\\n if rdv_2 <= 0.2:\\n mask = cv2.GaussianBlur(mask, (35,35), 11)\\n else:\\n mask = mask\\n return (mask>0.5)\\n \\n def make_json_dict(self, imgs, anns):\\n imgs_dict = {}\\n anns_dict = {}\\n for ann in anns:\\n image_id = ann[\\\"image_id\\\"]\\n if not image_id in anns_dict:\\n anns_dict[image_id] = []\\n anns_dict[image_id].append(ann)\\n else:\\n anns_dict[image_id].append(ann)\\n \\n for img in imgs:\\n image_id = img['id']\\n imgs_dict[image_id] = img['file_name']\\n\\n return imgs_dict, anns_dict\"\n },\n {\n \"identifier\": \"COCOA_VRSP\",\n \"path\": \"data/dataloader_COCOA.py\",\n \"snippet\": \"class COCOA_VRSP(torch.utils.data.Dataset):\\n def __init__(self, config, mode):\\n super(COCOA_VRSP, self).__init__()\\n self.config = config\\n self.mode = mode\\n self.data_info = pickle.load(open(os.path.join(self.root_path, \\\"fusion_{}.pkl\\\".format(self.mode)), \\\"rb\\\"))\\n self.label_info = np.genfromtxt(os.path.join(self.root_path, \\\"c2f_seg_{}_list.txt\\\".format(self.mode)), dtype=np.str, encoding='utf-8')\\n \\n if self.mode==\\\"train\\\":\\n self.img_root_path = os.path.join(self.root_path, \\\"train2014\\\")\\n elif self.mode==\\\"test\\\":\\n self.img_root_path = os.path.join(self.root_path, \\\"val2014\\\")\\n\\n self.dtype = torch.float32\\n self.enlarge_coef = 2\\n self.patch_h = 256\\n self.patch_w = 256\\n self.device = \\\"cpu\\\"\\n\\n \\n def __len__(self):\\n return self.label_info.shape[0]\\n\\n def __getitem__(self, index):\\n return self.load_item(index)\\n \\n def generate_heatmap(self, mask, kernel, sigma):\\n heatmap = cv2.GaussianBlur(mask, kernel, sigma)\\n am = np.amax(heatmap)\\n heatmap /= am / 1\\n return heatmap\\n \\n def load_item(self, index):\\n image_id, anno_id = self.label_info[index].split(\\\"_\\\")\\n image_id, anno_id = int(image_id), int(anno_id)\\n if self.mode==\\\"train\\\":\\n img_path = os.path.join(self.img_root_path, \\\"COCO_{}2014_{}.jpg\\\".format(self.mode, str(image_id).zfill(12)))\\n elif self.mode==\\\"test\\\":\\n img_path = os.path.join(self.img_root_path, \\\"COCO_val2014_{}.jpg\\\".format(str(image_id).zfill(12)))\\n img = np.array(Image.open(img_path))\\n if len(img.shape)==2:\\n img = np.repeat(img[:, :, np.newaxis], 3, axis=2)\\n instances = self.data_info[image_id][anno_id]\\n segmentation = instances[\\\"pred_visible_mask\\\"]\\n height, weight = segmentation[\\\"size\\\"]\\n occlude_rate = instances[\\\"occlude_rate\\\"]\\n vm_no_crop = mask_utils.decode([segmentation]).astype(bool)\\n fm_no_crop = mask_utils.decode([instances[\\\"gt_full_mask\\\"]]).astype(bool)\\n vm_no_crop_gt = mask_utils.decode([instances[\\\"gt_visible_mask\\\"]]).astype(bool)\\n\\n bbox = instances[\\\"pred_visible_mask_bbox\\\"]\\n y_min, x_min, w, h = bbox\\n y_max, x_max = y_min + w, x_min + h\\n x_center = (x_min + x_max) // 2\\n y_center = (y_min + y_max) // 2\\n x_len = int((x_max - x_min) * self.enlarge_coef)\\n y_len = int((y_max - y_min) * self.enlarge_coef)\\n x_min = max(0, x_center - x_len // 2)\\n x_max = min(height, x_center + x_len // 2)\\n y_min = max(0, y_center - y_len // 2)\\n y_max = min(weight, y_center + y_len // 2)\\n x_min, x_max, y_min, y_max = int(x_min), int(x_max), int(y_min), int(y_max)\\n \\n x_center_crop = x_center - x_min\\n y_center_crop = y_center - y_min\\n\\n vm_crop = vm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n fm_crop = fm_no_crop[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n img_crop = img[x_min:x_max+1, y_min:y_max+1]\\n vm_crop_gt = vm_no_crop_gt[x_min:x_max+1, y_min:y_max+1, 0].astype(bool)\\n\\n h, w = vm_crop.shape[:2]\\n m = transform.rescale(vm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop = m[np.newaxis, ...]\\n\\n center_crop = np.zeros_like(vm_crop[0])\\n x_center_crop = int(x_center_crop*self.patch_h/h)\\n y_center_crop = int(y_center_crop*self.patch_w/w)\\n center_crop[x_center_crop: x_center_crop+1, y_center_crop: y_center_crop+1]=1\\n center_crop = self.generate_heatmap(center_crop.astype(np.float), (35, 35), 9)\\n center_crop = center_crop[np.newaxis, ...]\\n\\n img_ = transform.rescale(img_crop, (self.patch_h/h, self.patch_w/w, 1))\\n cur_h, cur_w = img_.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)), (0, 0))\\n img_ = np.pad(img_, to_pad)[:self.patch_h, :self.patch_w, :3]\\n img_crop = img_\\n\\n h, w = vm_crop_gt.shape[:2]\\n m = transform.rescale(vm_crop_gt, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w]\\n vm_crop_gt = m[np.newaxis, ...]\\n\\n m = transform.rescale(fm_crop, (self.patch_h/h, self.patch_w/w))\\n cur_h, cur_w = m.shape[:2]\\n to_pad = ((0, max(self.patch_h-cur_h, 0)), (0, max(self.patch_w-cur_w, 0)))\\n m = np.pad(m, to_pad)[:self.patch_h, :self.patch_w] \\n fm_crop = m[np.newaxis, ...]\\n\\n loss_mask = fm_no_crop.astype(int)-vm_no_crop_gt.astype(int)\\n loss_mask[loss_mask==255]=0\\n loss_mask = 1-loss_mask.astype(bool)\\n\\n vm_no_crop = vm_no_crop[np.newaxis, ...]\\n fm_no_crop = fm_no_crop[np.newaxis, ...]\\n\\n obj_position = np.array([x_min, x_max, y_min, y_max])\\n vm_pad = np.array([max(self.patch_h-cur_h, 0), max(self.patch_w-cur_w, 0)])\\n vm_scale = np.array([self.patch_h/h, self.patch_w/w])\\n counts = np.array([1])\\n\\n counts = torch.from_numpy(counts).to(self.dtype).to(self.device)\\n\\n obj_position = torch.from_numpy(obj_position).to(self.dtype).to(self.device)\\n vm_pad = torch.from_numpy(vm_pad).to(self.dtype).to(self.device)\\n vm_scale = torch.from_numpy(vm_scale).to(self.dtype).to(self.device)\\n\\n fm_crop = torch.from_numpy(fm_crop).to(self.dtype).to(self.device)\\n fm_no_crop = torch.from_numpy(np.array(fm_no_crop)).to(self.dtype).to(self.device)\\n vm_crop = torch.from_numpy(vm_crop).to(self.dtype).to(self.device)\\n vm_crop_gt = torch.from_numpy(vm_crop_gt).to(self.dtype).to(self.device)\\n vm_no_crop = torch.from_numpy(np.array(vm_no_crop)).to(self.dtype).to(self.device)\\n center_crop = torch.from_numpy(np.array(center_crop)).to(self.dtype).to(self.device)\\n \\n img_crop = torch.from_numpy(np.array(img_crop)).to(self.dtype).to(self.device)\\n img = torch.from_numpy(np.array(img)).to(self.dtype).to(self.device)\\n\\n loss_mask = torch.from_numpy(np.array(loss_mask)).to(self.dtype).to(self.device)\\n \\n image_id = torch.from_numpy(np.array(image_id)).to(self.dtype).to(self.device)\\n anno_id = torch.from_numpy(np.array(anno_id)).to(self.dtype).to(self.device)\\n occlude_rate = torch.from_numpy(np.array(occlude_rate)).to(self.dtype).to(self.device)\\n \\n if self.mode==\\\"train\\\":\\n meta = {\\n # \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_crop\\\": vm_crop,\\n # \\\"vm_crop_gt\\\": vm_crop_gt,\\n # \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"center_crop\\\": center_crop,\\n # \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n \\\"img_no_crop\\\": img,\\n }\\n elif self.mode==\\\"test\\\":\\n meta = {\\n \\\"vm_no_crop\\\": vm_no_crop,\\n \\\"vm_no_crop_gt\\\": vm_no_crop_gt,\\n \\\"vm_crop\\\": vm_crop,\\n \\\"vm_crop_gt\\\": vm_crop_gt,\\n \\\"fm_no_crop\\\": fm_no_crop,\\n \\\"fm_crop\\\": fm_crop,\\n \\\"img_crop\\\": img_crop,\\n \\\"center_crop\\\": center_crop,\\n \\\"loss_mask\\\": loss_mask,\\n \\\"obj_position\\\": obj_position,\\n \\\"vm_pad\\\": vm_pad,\\n \\\"vm_scale\\\": vm_scale,\\n \\\"counts\\\":counts,\\n \\\"img_id\\\": image_id,\\n \\\"anno_id\\\": anno_id,\\n \\\"occlude_rate\\\":occlude_rate,\\n # # for vq\\n # \\\"mask_crop\\\": fm_crop,\\n \\\"img\\\": img,\\n }\\n return meta\\n\\n @staticmethod\\n def collate_fn(batch):\\n keys = batch[0].keys()\\n res = {}\\n for k in keys:\\n temp_ = []\\n for b in batch:\\n if b[k] is not None:\\n temp_.append(b[k])\\n if len(temp_) > 0:\\n res[k] = default_collate(temp_)\\n else:\\n res[k] = None\\n\\n return res\\n\\n def create_iterator(self, batch_size):\\n while True:\\n sample_loader = DataLoader(\\n dataset=self,\\n batch_size=batch_size,\\n drop_last=True,\\n collate_fn=self.collate_fn\\n )\\n\\n for item in sample_loader:\\n yield item\\n\\n def polys_to_mask(self, polygons, height, width):\\n rles = mask_utils.frPyObjects(polygons, height, width)\\n rle = mask_utils.merge(rles)\\n mask = mask_utils.decode(rle)\\n return mask\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from data.dataloader_Fishbowl import FishBowl\nfrom data.dataloader_MOViD_A import MOViD_A\nfrom data.dataloader_KINS import Kins_Fusion_dataset, KINS_Aisformer_VRSP_Intersection\nfrom data.dataloader_COCOA import COCOA_Fusion_dataset, COCOA_VRSP"},"token_num":{"kind":"number","value":21265,"string":"21,265"},"cropped_code":{"kind":"string","value":"\ndef load_dataset(config, args, mode):\n if mode==\"train\":\n if args.dataset==\"KINS\":\n train_dataset = Kins_Fusion_dataset(config, mode='train')\n test_dataset = Kins_Fusion_dataset(config, mode='test')\n elif args.dataset==\"COCOA\":\n train_dataset = COCOA_Fusion_dataset(config, mode='train')\n test_dataset = COCOA_Fusion_dataset(config, mode='test')\n elif args.dataset==\"Fishbowl\":\n train_dataset = FishBowl(config, mode='train')\n test_dataset = FishBowl(config, mode='test')\n elif args.dataset==\"MOViD_A\":\n"},"all_code":{"kind":"string","value":"\ndef load_dataset(config, args, mode):\n if mode==\"train\":\n if args.dataset==\"KINS\":\n train_dataset = Kins_Fusion_dataset(config, mode='train')\n test_dataset = Kins_Fusion_dataset(config, mode='test')\n elif args.dataset==\"COCOA\":\n train_dataset = COCOA_Fusion_dataset(config, mode='train')\n test_dataset = COCOA_Fusion_dataset(config, mode='test')\n elif args.dataset==\"Fishbowl\":\n train_dataset = FishBowl(config, mode='train')\n test_dataset = FishBowl(config, mode='test')\n elif args.dataset==\"MOViD_A\":"},"next_line":{"kind":"string","value":" train_dataset = MOViD_A(config, mode='train')"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-21 04:25:47+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5672,"cells":{"repo_name":{"kind":"string","value":"alipay/PainlessInferenceAcceleration"},"file_path":{"kind":"string","value":"pia/lookahead/models/qwen/modeling_qwen.py"},"context":{"kind":"list like","value":[{"identifier":"LookaheadPreTrainedModel","path":"pia/lookahead/common/pretrained_model.py","snippet":"class LookaheadPreTrainedModel(PreTrainedModel):\n _batch_generation = False\n _stream_generation = False\n\n def __init__(self, config):\n super().__init__(config=config)\n\n def _get_generation_mode(\n self, generation_config: GenerationConfig, assistant_model: Optional[\"PreTrainedModel\"]\n ) -> GenerationMode:\n \"\"\"\n Returns the generation mode triggered by a [`GenerationConfig`] instance.\n \"\"\"\n if generation_config.constraints is not None or generation_config.force_words_ids is not None:\n generation_mode = GenerationMode.CONSTRAINED_BEAM_SEARCH\n elif generation_config.num_beams == 1:\n if generation_config.do_sample is False:\n if (\n generation_config.top_k is not None\n and generation_config.top_k > 1\n and generation_config.penalty_alpha is not None\n and generation_config.penalty_alpha > 0\n ):\n generation_mode = GenerationMode.CONTRASTIVE_SEARCH\n elif generation_config.use_cache \\\n and hasattr(generation_config, 'decoding_kwargs') \\\n and generation_config.decoding_kwargs.get('use_lookahead', False) \\\n and generation_config.decoding_kwargs.get('decoding_length', 64) > 1 \\\n and generation_config.decoding_kwargs.get('branch_length', 12) > 0:\n generation_mode = GenerationMode.LOOKAHEAD_GENERATION\n else:\n generation_mode = GenerationMode.GREEDY_SEARCH\n else:\n if generation_config.use_cache \\\n and hasattr(generation_config, 'decoding_kwargs') \\\n and generation_config.decoding_kwargs.get('use_lookahead', False) \\\n and generation_config.decoding_kwargs.get('decoding_length', 64) > 1 \\\n and generation_config.decoding_kwargs.get('branch_length', 12) > 0:\n generation_mode = GenerationMode.LOOKAHEAD_GENERATION\n else:\n generation_mode = GenerationMode.SAMPLE\n else:\n if generation_config.num_beam_groups > 1:\n generation_mode = GenerationMode.GROUP_BEAM_SEARCH\n elif generation_config.do_sample is True:\n generation_mode = GenerationMode.BEAM_SAMPLE\n else:\n generation_mode = GenerationMode.BEAM_SEARCH\n\n # Assisted generation may extend some generation modes\n if assistant_model is not None:\n if generation_mode in (\"greedy_search\", \"sample\"):\n generation_mode = GenerationMode.ASSISTED_GENERATION\n else:\n raise ValueError(\n \"You've set `assistant_model`, which triggers assisted generate. Currently, assisted generate \"\n \"is only supported with Greedy Search and Sample.\"\n )\n return generation_mode\n\n @torch.no_grad()\n def generate(\n self,\n inputs: Optional[torch.Tensor] = None,\n generation_config: Optional[GenerationConfig] = None,\n logits_processor: Optional[LogitsProcessorList] = None,\n stopping_criteria: Optional[StoppingCriteriaList] = None,\n prefix_allowed_tokens_fn: Optional[Callable[[int, torch.Tensor], List[int]]] = None,\n synced_gpus: Optional[bool] = None,\n assistant_model: Optional[\"PreTrainedModel\"] = None,\n streamer: Optional[\"BaseStreamer\"] = None,\n **kwargs,\n ) -> Union[GenerateOutput, torch.LongTensor]:\n r\"\"\"\n\n Generates sequences of token ids for models with a language modeling head.\n\n <Tip warning={true}>\n\n Most generation-controlling parameters are set in `generation_config` which, if not passed, will be set to the\n model's default generation configuration. You can override any `generation_config` by passing the corresponding\n parameters to generate(), e.g. `.generate(inputs, num_beams=4, do_sample=True)`.\n\n For an overview of generation strategies and code examples, check out the [following\n guide](../generation_strategies).\n\n </Tip>\n\n Parameters:\n inputs (`torch.Tensor` of varying shape depending on the modality, *optional*):\n The sequence used as a prompt for the generation or as model inputs to the encoder. If `None` the\n method initializes it with `bos_token_id` and a batch size of 1. For decoder-only models `inputs`\n should of in the format of `input_ids`. For encoder-decoder models *inputs* can represent any of\n `input_ids`, `input_values`, `input_features`, or `pixel_values`.\n generation_config (`~generation.GenerationConfig`, *optional*):\n The generation configuration to be used as base parametrization for the generation call. `**kwargs`\n passed to generate matching the attributes of `generation_config` will override them. If\n `generation_config` is not provided, the default will be used, which had the following loading\n priority: 1) from the `generation_config.json` model file, if it exists; 2) from the model\n configuration. Please note that unspecified parameters will inherit [`~generation.GenerationConfig`]'s\n default values, whose documentation should be checked to parameterize generation.\n logits_processor (`LogitsProcessorList`, *optional*):\n Custom logits processors that complement the default logits processors built from arguments and\n generation config. If a logit processor is passed that is already created with the arguments or a\n generation config an error is thrown. This feature is intended for advanced users.\n stopping_criteria (`StoppingCriteriaList`, *optional*):\n Custom stopping criteria that complement the default stopping criteria built from arguments and a\n generation config. If a stopping criteria is passed that is already created with the arguments or a\n generation config an error is thrown. This feature is intended for advanced users.\n prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], List[int]]`, *optional*):\n If provided, this function constraints the beam search to allowed tokens only at each step. If not\n provided no constraint is applied. This function takes 2 arguments: the batch ID `batch_id` and\n `input_ids`. It has to return a list with the allowed tokens for the next generation step conditioned\n on the batch ID `batch_id` and the previously generated tokens `inputs_ids`. This argument is useful\n for constrained generation conditioned on the prefix, as described in [Autoregressive Entity\n Retrieval](https://arxiv.org/abs/2010.00904).\n synced_gpus (`bool`, *optional*):\n Whether to continue running the while loop until max_length. Unless overridden this flag will be set to\n `True` under DeepSpeed ZeRO Stage 3 multiple GPUs environment to avoid hanging if one GPU finished\n generating before other GPUs. Otherwise it'll be set to `False`.\n assistant_model (`PreTrainedModel`, *optional*):\n An assistant model that can be used to accelerate generation. The assistant model must have the exact\n same tokenizer. The acceleration is achieved when forecasting candidate tokens with the assistent model\n is much faster than running generation with the model you're calling generate from. As such, the\n assistant model should be much smaller.\n streamer (`BaseStreamer`, *optional*):\n Streamer object that will be used to stream the generated sequences. Generated tokens are passed\n through `streamer.put(token_ids)` and the streamer is responsible for any further processing.\n kwargs (`Dict[str, Any]`, *optional*):\n Ad hoc parametrization of `generate_config` and/or additional model-specific kwargs that will be\n forwarded to the `forward` function of the model. If the model is an encoder-decoder model, encoder\n specific kwargs should not be prefixed and decoder specific kwargs should be prefixed with *decoder_*.\n\n Return:\n [`~utils.ModelOutput`] or `torch.LongTensor`: A [`~utils.ModelOutput`] (if `return_dict_in_generate=True`\n or when `config.return_dict_in_generate=True`) or a `torch.FloatTensor`.\n\n If the model is *not* an encoder-decoder model (`model.config.is_encoder_decoder=False`), the possible\n [`~utils.ModelOutput`] types are:\n\n - [`~generation.GreedySearchDecoderOnlyOutput`],\n - [`~generation.SampleDecoderOnlyOutput`],\n - [`~generation.BeamSearchDecoderOnlyOutput`],\n - [`~generation.BeamSampleDecoderOnlyOutput`]\n\n If the model is an encoder-decoder model (`model.config.is_encoder_decoder=True`), the possible\n [`~utils.ModelOutput`] types are:\n\n - [`~generation.GreedySearchEncoderDecoderOutput`],\n - [`~generation.SampleEncoderDecoderOutput`],\n - [`~generation.BeamSearchEncoderDecoderOutput`],\n - [`~generation.BeamSampleEncoderDecoderOutput`]\n \"\"\"\n\n if synced_gpus is None:\n # if is_deepspeed_zero3_enabled() and dist.get_world_size() > 1:\n # synced_gpus = True\n # else:\n # synced_gpus = False\n synced_gpus = False\n\n # 1. Handle `generation_config` and kwargs that might update it, and validate the `.generate()` call\n self._validate_model_class()\n\n # priority: `generation_config` argument > `model.generation_config` (the default generation config)\n if generation_config is None:\n # legacy: users may modify the model configuration to control generation -- update the generation config\n # model attribute accordingly, if it was created from the model config\n if self.generation_config._from_model_config:\n new_generation_config = GenerationConfig.from_model_config(self.config)\n if new_generation_config != self.generation_config:\n # warnings.warn(\n # \"You have modified the pretrained model configuration to control generation. This is a\"\n # \" deprecated strategy to control generation and will be removed soon, in a future version.\"\n # \" Please use a generation configuration file (see\"\n # \" https://huggingface.co/docs/transformers/main_classes/text_generation )\"\n # )\n self.generation_config = new_generation_config\n generation_config = self.generation_config\n\n generation_config = copy.deepcopy(generation_config)\n model_kwargs = generation_config.update(**kwargs) # All unused kwargs must be model kwargs\n generation_config.validate()\n self._validate_model_kwargs(model_kwargs.copy())\n if not hasattr(generation_config, 'decoding_kwargs'):\n generation_config.decoding_kwargs = model_kwargs.get('decoding_kwargs', {})\n\n # 2. Set generation parameters if not already defined\n logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()\n stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()\n\n if generation_config.pad_token_id is None and generation_config.eos_token_id is not None:\n if model_kwargs.get(\"attention_mask\", None) is None:\n logger.warning(\n \"The attention mask and the pad token id were not set. As a consequence, you may observe \"\n \"unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\"\n )\n eos_token_id = generation_config.eos_token_id\n if isinstance(eos_token_id, list):\n eos_token_id = eos_token_id[0]\n logger.warning(f\"Setting `pad_token_id` to `eos_token_id`:{eos_token_id} for open-end generation.\")\n generation_config.pad_token_id = eos_token_id\n\n # 3. Define model inputs\n # inputs_tensor has to be defined\n # model_input_name is defined if model-specific keyword input is passed\n # otherwise model_input_name is None\n # all model-specific keyword inputs are removed from `model_kwargs`\n inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs(\n inputs, generation_config.bos_token_id, model_kwargs\n )\n batch_size = inputs_tensor.shape[0]\n\n # 4. Define other model kwargs\n model_kwargs[\"output_attentions\"] = generation_config.output_attentions\n model_kwargs[\"output_hidden_states\"] = generation_config.output_hidden_states\n # decoder-only models with inputs_embeds forwarding must use caching (otherwise we can't detect whether we are\n # generating the first new token or not, and we only want to use the embeddings for the first new token)\n if not self.config.is_encoder_decoder and model_input_name == \"inputs_embeds\":\n model_kwargs[\"use_cache\"] = True\n else:\n model_kwargs[\"use_cache\"] = generation_config.use_cache\n\n accepts_attention_mask = \"attention_mask\" in set(inspect.signature(self.forward).parameters.keys())\n requires_attention_mask = \"encoder_outputs\" not in model_kwargs\n\n if model_kwargs.get(\"attention_mask\", None) is None and requires_attention_mask and accepts_attention_mask:\n model_kwargs[\"attention_mask\"] = self._prepare_attention_mask_for_generation(\n inputs_tensor, generation_config.pad_token_id, generation_config.eos_token_id\n )\n\n # decoder-only models should use left-padding for generation\n if not self.config.is_encoder_decoder:\n # If `input_ids` was given, check if the last id in any sequence is `pad_token_id`\n # Note: If using, `inputs_embeds` this check does not work, because we want to be more hands-off.\n if (\n generation_config.pad_token_id is not None\n and len(inputs_tensor.shape) == 2\n and torch.sum(inputs_tensor[:, -1] == generation_config.pad_token_id) > 0\n ):\n logger.warning(\n \"A decoder-only architecture is being used, but right-padding was detected! For correct \"\n \"generation results, please set `padding_side='left'` when initializing the tokenizer.\"\n )\n\n if self.config.is_encoder_decoder and \"encoder_outputs\" not in model_kwargs:\n # if model is encoder decoder encoder_outputs are created\n # and added to `model_kwargs`\n model_kwargs = self._prepare_encoder_decoder_kwargs_for_generation(\n inputs_tensor, model_kwargs, model_input_name\n )\n\n # 5. Prepare `input_ids` which will be used for auto-regressive generation\n if self.config.is_encoder_decoder:\n input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation(\n batch_size=batch_size,\n model_input_name=model_input_name,\n model_kwargs=model_kwargs,\n decoder_start_token_id=generation_config.decoder_start_token_id,\n bos_token_id=generation_config.bos_token_id,\n device=inputs_tensor.device,\n )\n else:\n input_ids = inputs_tensor if model_input_name == \"input_ids\" else model_kwargs.pop(\"input_ids\")\n\n if streamer is not None:\n streamer.put(input_ids.cpu())\n\n # 6. Prepare `max_length` depending on other stopping criteria.\n input_ids_length = input_ids.shape[-1]\n has_default_max_length = kwargs.get(\"max_length\") is None and generation_config.max_length is not None\n if generation_config.max_new_tokens is not None:\n if not has_default_max_length:\n logger.warning(\n f\"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(=\"\n f\"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. \"\n \"Please refer to the documentation for more information. \"\n \"(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)\"\n )\n generation_config.max_length = generation_config.max_new_tokens + input_ids_length\n\n # 7. determine generation mode\n generation_mode = self._get_generation_mode(generation_config, assistant_model)\n\n if streamer is not None and (generation_config.num_beams > 1):\n raise ValueError(\n \"`streamer` cannot be used with beam search (yet!). Make sure that `num_beams` is set to 1.\"\n )\n\n if self.device.type != input_ids.device.type:\n warnings.warn(\n \"You are calling .generate() with the `input_ids` being on a device type different\"\n f\" than your model's device. `input_ids` is on {input_ids.device.type}, whereas the model\"\n f\" is on {self.device.type}. You may experience unexpected behaviors or slower generation.\"\n \" Please make sure that you have put `input_ids` to the\"\n f\" correct device by calling for example input_ids = input_ids.to('{self.device.type}') before\"\n \" running `.generate()`.\",\n UserWarning,\n )\n\n # 8. prepare distribution pre_processing samplers\n logits_processor = self._get_logits_processor(\n generation_config=generation_config,\n input_ids_seq_length=input_ids_length,\n encoder_input_ids=inputs_tensor,\n prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,\n logits_processor=logits_processor,\n )\n\n # 9. prepare stopping criteria\n stopping_criteria = self._get_stopping_criteria(\n generation_config=generation_config, stopping_criteria=stopping_criteria\n )\n\n decoding_kwargs = generation_config.decoding_kwargs if hasattr(generation_config, 'decoding_kwargs') else {}\n decoding_kwargs['generation_mode'] = generation_mode\n decoding_kwargs['do_sample'] = generation_config.do_sample\n decoding_kwargs['inputs_embeds_position'] = generation_config.inputs_embeds_position if hasattr(generation_config, 'inputs_embeds_position') else 0\n decoding_kwargs['max_length'] = generation_config.max_length\n if generation_mode == GenerationMode.LOOKAHEAD_GENERATION:\n decoding_length = decoding_kwargs.get('decoding_length', 64)\n decoding_kwargs['decoding_max_length'] = generation_config.max_length + decoding_length + 1\n else:\n decoding_kwargs['decoding_max_length'] = generation_config.max_length\n model_kwargs['decoding_kwargs'] = decoding_kwargs\n\n # 10. go into different generation modes\n if generation_mode == GenerationMode.ASSISTED_GENERATION:\n if generation_config.num_return_sequences > 1:\n raise ValueError(\n \"num_return_sequences has to be 1 when doing assisted generate, \"\n f\"but is {generation_config.num_return_sequences}.\"\n )\n if batch_size > 1:\n raise ValueError(\"assisted generate is only supported for batch_size = 1\")\n if not model_kwargs[\"use_cache\"]:\n raise ValueError(\"assisted generate requires `use_cache=True`\")\n\n # 11. If the assistant model is an encoder-decoder, prepare its encoder outputs\n if assistant_model.config.is_encoder_decoder:\n assistant_model_kwargs = copy.deepcopy(model_kwargs)\n inputs_tensor, model_input_name, assistant_model_kwargs = assistant_model._prepare_model_inputs(\n inputs_tensor, assistant_model.generation_config.bos_token_id, assistant_model_kwargs\n )\n assistant_model_kwargs = assistant_model._prepare_encoder_decoder_kwargs_for_generation(\n inputs_tensor, assistant_model_kwargs, model_input_name\n )\n model_kwargs[\"assistant_encoder_outputs\"] = assistant_model_kwargs[\"encoder_outputs\"]\n\n # 12. run assisted generate\n return self.assisted_decoding(\n input_ids,\n assistant_model=assistant_model,\n do_sample=generation_config.do_sample,\n logits_processor=logits_processor,\n logits_warper=self._get_logits_warper(generation_config) if generation_config.do_sample else None,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n streamer=streamer,\n **model_kwargs,\n )\n if generation_mode == GenerationMode.GREEDY_SEARCH:\n # 11. run greedy search\n return self.greedy_search(\n input_ids,\n logits_processor=logits_processor,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n streamer=streamer,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.LOOKAHEAD_GENERATION:\n # 11. run greedy search\n return self.lookahead_generation(\n input_ids,\n logits_processor=logits_processor,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n streamer=streamer,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.CONTRASTIVE_SEARCH:\n if not model_kwargs[\"use_cache\"]:\n raise ValueError(\"Contrastive search requires `use_cache=True`\")\n\n return self.contrastive_search(\n input_ids,\n top_k=generation_config.top_k,\n penalty_alpha=generation_config.penalty_alpha,\n logits_processor=logits_processor,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n streamer=streamer,\n sequential=generation_config.low_memory,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.SAMPLE:\n # 11. prepare logits warper\n logits_warper = self._get_logits_warper(generation_config)\n\n # 12. expand input_ids with `num_return_sequences` additional sequences per batch\n input_ids, model_kwargs = self._expand_inputs_for_generation(\n input_ids=input_ids,\n expand_size=generation_config.num_return_sequences,\n is_encoder_decoder=self.config.is_encoder_decoder,\n **model_kwargs,\n )\n\n # 13. run sample\n return self.sample(\n input_ids,\n logits_processor=logits_processor,\n logits_warper=logits_warper,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n streamer=streamer,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.BEAM_SEARCH:\n # 11. prepare beam search scorer\n beam_scorer = BeamSearchScorer(\n batch_size=batch_size,\n num_beams=generation_config.num_beams,\n device=inputs_tensor.device,\n length_penalty=generation_config.length_penalty,\n do_early_stopping=generation_config.early_stopping,\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\n max_length=generation_config.max_length,\n )\n # 12. interleave input_ids with `num_beams` additional sequences per batch\n input_ids, model_kwargs = self._expand_inputs_for_generation(\n input_ids=input_ids,\n expand_size=generation_config.num_beams,\n is_encoder_decoder=self.config.is_encoder_decoder,\n **model_kwargs,\n )\n # 13. run beam search\n return self.beam_search(\n input_ids,\n beam_scorer,\n logits_processor=logits_processor,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.BEAM_SAMPLE:\n # 11. prepare logits warper\n logits_warper = self._get_logits_warper(generation_config)\n\n # 12. prepare beam search scorer\n beam_scorer = BeamSearchScorer(\n batch_size=batch_size,\n num_beams=generation_config.num_beams,\n device=inputs_tensor.device,\n length_penalty=generation_config.length_penalty,\n do_early_stopping=generation_config.early_stopping,\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\n max_length=generation_config.max_length,\n )\n\n # 13. interleave input_ids with `num_beams` additional sequences per batch\n input_ids, model_kwargs = self._expand_inputs_for_generation(\n input_ids=input_ids,\n expand_size=generation_config.num_beams,\n is_encoder_decoder=self.config.is_encoder_decoder,\n **model_kwargs,\n )\n\n # 14. run beam sample\n return self.beam_sample(\n input_ids,\n beam_scorer,\n logits_processor=logits_processor,\n logits_warper=logits_warper,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.GROUP_BEAM_SEARCH:\n # 11. prepare beam search scorer\n beam_scorer = BeamSearchScorer(\n batch_size=batch_size,\n num_beams=generation_config.num_beams,\n device=inputs_tensor.device,\n length_penalty=generation_config.length_penalty,\n do_early_stopping=generation_config.early_stopping,\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\n num_beam_groups=generation_config.num_beam_groups,\n max_length=generation_config.max_length,\n )\n # 12. interleave input_ids with `num_beams` additional sequences per batch\n input_ids, model_kwargs = self._expand_inputs_for_generation(\n input_ids=input_ids,\n expand_size=generation_config.num_beams,\n is_encoder_decoder=self.config.is_encoder_decoder,\n **model_kwargs,\n )\n # 13. run beam search\n return self.group_beam_search(\n input_ids,\n beam_scorer,\n logits_processor=logits_processor,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n **model_kwargs,\n )\n\n elif generation_mode == GenerationMode.CONSTRAINED_BEAM_SEARCH:\n final_constraints = []\n if generation_config.constraints is not None:\n final_constraints = generation_config.constraints\n\n if generation_config.force_words_ids is not None:\n\n def typeerror():\n raise ValueError(\n \"`force_words_ids` has to either be a `List[List[List[int]]]` or `List[List[int]]`\"\n f\"of positive integers, but is {generation_config.force_words_ids}.\"\n )\n\n if (\n not isinstance(generation_config.force_words_ids, list)\n or len(generation_config.force_words_ids) == 0\n ):\n typeerror()\n\n for word_ids in generation_config.force_words_ids:\n if isinstance(word_ids[0], list):\n if not isinstance(word_ids, list) or len(word_ids) == 0:\n typeerror()\n if any(not isinstance(token_ids, list) for token_ids in word_ids):\n typeerror()\n if any(\n any((not isinstance(token_id, int) or token_id < 0) for token_id in token_ids)\n for token_ids in word_ids\n ):\n typeerror()\n\n constraint = DisjunctiveConstraint(word_ids)\n else:\n if not isinstance(word_ids, list) or len(word_ids) == 0:\n typeerror()\n if any((not isinstance(token_id, int) or token_id < 0) for token_id in word_ids):\n typeerror()\n\n constraint = PhrasalConstraint(word_ids)\n final_constraints.append(constraint)\n\n # 11. prepare beam search scorer\n constrained_beam_scorer = ConstrainedBeamSearchScorer(\n constraints=final_constraints,\n batch_size=batch_size,\n num_beams=generation_config.num_beams,\n device=inputs_tensor.device,\n length_penalty=generation_config.length_penalty,\n do_early_stopping=generation_config.early_stopping,\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\n max_length=generation_config.max_length,\n )\n # 12. interleave input_ids with `num_beams` additional sequences per batch\n input_ids, model_kwargs = self._expand_inputs_for_generation(\n input_ids=input_ids,\n expand_size=generation_config.num_beams,\n is_encoder_decoder=self.config.is_encoder_decoder,\n **model_kwargs,\n )\n # 13. run beam search\n return self.constrained_beam_search(\n input_ids,\n constrained_beam_scorer=constrained_beam_scorer,\n logits_processor=logits_processor,\n stopping_criteria=stopping_criteria,\n pad_token_id=generation_config.pad_token_id,\n eos_token_id=generation_config.eos_token_id,\n output_scores=generation_config.output_scores,\n return_dict_in_generate=generation_config.return_dict_in_generate,\n synced_gpus=synced_gpus,\n **model_kwargs,\n )\n\n def lookahead_prepare_inputs_for_generation(self,\n input_ids,\n past_key_values=None,\n attention_mask=None,\n inputs_embeds=None,\n **kwargs):\n position_ids = kwargs.get(\"position_ids\", None)\n\n decoding_kwargs = kwargs.get('decoding_kwargs', {})\n decoding_length = decoding_kwargs.get('decoding_length', 64)\n branch_length = decoding_kwargs.get('branch_length', 12)\n decoding_mode = decoding_kwargs.get('decoding_mode', 'hier')\n max_length = decoding_kwargs.get('max_length', 2048)\n update_branch_length = min(branch_length, max_length - input_ids.size(-1))\n assert update_branch_length > 0, f'{branch_length=} {max_length=} {input_ids.size(-1)=} {update_branch_length=}'\n\n if past_key_values is None:\n if inputs_embeds is not None and input_ids is not None:\n model_inputs = {\"inputs_embeds\": inputs_embeds, \"input_ids\": input_ids}\n length = input_ids.size(1)\n elif input_ids is not None:\n model_inputs = {\"input_ids\": input_ids}\n length = input_ids.size(1)\n elif inputs_embeds is not None:\n model_inputs = {\"inputs_embeds\": inputs_embeds}\n length = input_ids.size(1)\n else:\n raise ValueError('either input_ids or inputs_embeds is not None')\n update_attention_mask = attention_mask[:, :, :length, :length]\n\n model_inputs.update(\n {\"past_key_values\": past_key_values,\n \"use_cache\": kwargs.get(\"use_cache\"),\n \"attention_mask\": update_attention_mask,\n \"decoding_kwargs\": decoding_kwargs\n })\n\n if position_ids is not None:\n model_inputs[\"position_ids\"] = self._get_position_ids(position_ids, encoding=True, length=length)\n\n else:\n decoding_qids = input_ids[0, -2:].tolist()\n # decoding_qids = decoding_kwargs['input_id_list'][0][-2:]\n min_input_size = 0\n min_output_size = max(decoding_length // 2, 1)\n\n if decoding_mode in ('hier', 'par', 'one'):\n decoding_mode = decoding_mode + '_mix'\n fmt, mode = decoding_mode.split('_')\n method_name = fmt + '_get'\n\n decoding_ids, decoding_masks, sizes = getattr(self.lookahead_cache, method_name)(decoding_qids,\n decoding_length=decoding_length,\n branch_length=update_branch_length,\n min_input_size=min_input_size,\n min_output_size=min_output_size,\n mode=mode,\n idx=0)\n\n decoding_input_ids = torch.tensor([decoding_ids], dtype=torch.long, device=input_ids.device)\n prefix_length = input_ids.size(-1) - 1\n fresh_length = len(decoding_ids)\n ppl = prefix_length + fresh_length\n assert ppl <= attention_mask.size(2), \\\n f'{max_length=} {update_branch_length=} {prefix_length=} {fresh_length=} {attention_mask.shape=}'\n prefix_mask_tensor = attention_mask[:, :, prefix_length:ppl, :prefix_length]\n decoding_mask_tensor = torch.from_numpy(decoding_masks[None, None]).to(\n dtype=attention_mask.dtype, device=attention_mask.device)\n decoding_attention_mask = torch.cat([prefix_mask_tensor, decoding_mask_tensor], dim=3)\n\n decoding_kwargs.update({'decoding_qids': decoding_qids,\n 'decoding_ids': decoding_ids,\n 'decoding_masks': decoding_masks,\n 'sizes': sizes,\n })\n model_inputs = {'decoding_kwargs': decoding_kwargs}\n\n model_inputs.update(\n {\n \"input_ids\": decoding_input_ids,\n \"past_key_values\": past_key_values,\n \"use_cache\": kwargs.get(\"use_cache\"),\n \"attention_mask\": decoding_attention_mask\n }\n )\n if position_ids is not None:\n indices = torch.sum(decoding_attention_mask, dim=3).squeeze(1)[0]\n model_inputs[\"position_ids\"] = self._get_position_ids(position_ids, indices=indices, encoding=False)\n\n return model_inputs\n\n def _get_position_ids(self, full_position_ids, indices=None, length=None, encoding=True):\n if encoding:\n return full_position_ids[..., :length]\n else:\n return full_position_ids[..., indices]\n\n def _lookahead_update_model_kwargs_for_generation(\n self,\n outputs: ModelOutput,\n model_kwargs: Dict[str, Any],\n is_encoder_decoder: bool = False,\n standardize_cache_format: bool = False,\n logits_processor: Optional[LogitsProcessorList] = None,\n input_ids: Optional[torch.Tensor] = None,\n ) -> Dict[str, Any]:\n # update past_key_values\n model_kwargs[\"past_key_values\"] = self._extract_past_from_model_output(\n outputs, standardize_cache_format=standardize_cache_format\n )\n\n decoding_kwargs = model_kwargs['decoding_kwargs']\n decoding_ids = decoding_kwargs.get('decoding_ids', [])\n if len(decoding_ids) <= 1:\n next_token_logits = outputs.logits[:, -1:, :]\n # pre-process distribution\n # next_tokens_scores = logits_processor(input_ids, next_token_logits)\n bs, nt, nv = next_token_logits.shape\n next_tokens_scores = logits_processor(input_ids, next_token_logits.squeeze(1)).unsqueeze(1)\n\n if decoding_kwargs.get('do_sample', False):\n probs = nn.functional.softmax(next_tokens_scores, dim=-1)\n next_tokens = torch.multinomial(probs.view(bs * nt, nv), num_samples=1).view(bs, nt)\n else:\n next_tokens = torch.argmax(next_tokens_scores, dim=-1, keepdim=False).long()\n model_kwargs['next_tokens'] = next_tokens\n model_kwargs['next_tokens_scores'] = next_tokens_scores\n next_token_list = next_tokens.tolist()\n model_kwargs['next_token_list'] = next_token_list\n decoding_kwargs['input_id_list'][0].extend(next_token_list[0])\n decoding_kwargs['dls'].append(1)\n decoding_kwargs['edls'].append(1)\n if decoding_kwargs.get('debug_lookahead', False):\n decoding_qids = decoding_kwargs.get('decoding_qids', [])\n print(f'size:0 query:{decoding_qids} next_token:{next_token_list[0]}')\n else:\n # TODO: accurate logit_processor\n # next_tokens_scores = logits_processor(input_ids, outputs.logits)\n bs, nt, nv = outputs.logits.shape\n next_tokens_scores = logits_processor(input_ids.repeat(1, nt).view(bs * nt, -1),\n outputs.logits.view(bs * nt, -1)).view(bs, nt, -1)\n\n if decoding_kwargs.get('do_sample', False):\n probs = nn.functional.softmax(next_tokens_scores, dim=-1)\n bs, nt, nv = probs.shape\n next_tokens = torch.multinomial(probs.view(bs * nt, nv), num_samples=1).view(bs, nt)\n else:\n next_tokens = torch.argmax(next_tokens_scores, dim=-1, keepdim=False).long()\n\n next_token_list = next_tokens.tolist()[0]\n decoding_ids = decoding_kwargs['decoding_ids'][1:]\n decoding_mask = decoding_kwargs['decoding_masks']\n sizes = decoding_kwargs['sizes']\n\n max_match_index = 0\n max_match_count = 0\n max_decoding_ids_slice = None\n max_next_token_slice = None\n \n for i in range(len(decoding_ids)):\n mask_indices = np.nonzero(decoding_mask[i + 1, 1:])[0]\n decoding_ids_slice = [decoding_ids[j] for j in mask_indices] \n next_token_slice = [next_token_list[0]] + [next_token_list[j + 1] for j in mask_indices]\n \n c = len(decoding_ids_slice)\n for j, p in enumerate(decoding_ids_slice):\n if next_token_slice[j] != p:\n c = j\n break\n if c > max_match_count:\n max_match_count = c\n max_match_index = i\n if c >= max_match_count:\n max_decoding_ids_slice = decoding_ids_slice\n max_next_token_slice = next_token_slice\n # if decoding_kwargs['eos'] in decoding_ids:\n # max_match_count = 0\n\n prefix_plus_count = input_ids.size(-1)\n match_idx = np.nonzero(decoding_mask[max_match_index + 1, 1:])[0][:max_match_count]\n if len(decoding_ids) != max_match_count:\n past = model_kwargs[\"past_key_values\"]\n device = past[0][0].device\n kv_idx = torch.tensor(match_idx + prefix_plus_count, dtype=torch.long, device=device)\n model_kwargs[\"past_key_values\"] = self._update_cache(past,\n kv_idx,\n prefix_and_next_count=prefix_plus_count,\n max_match_count=max_match_count,\n max_match_index=max_match_index)\n\n next_token_list = [next_token_list[0:1] + [next_token_list[x + 1] for x in match_idx]]\n next_tokens = torch.tensor(next_token_list, dtype=torch.long, device=input_ids.device)\n model_kwargs['next_tokens'] = next_tokens\n model_kwargs['next_token_list'] = next_token_list\n decoding_kwargs['input_id_list'][0].extend(next_token_list[0])\n decoding_kwargs['dls'].append(len(decoding_ids))\n decoding_kwargs['edls'].append(max_match_count + 1)\n if decoding_kwargs.get('debug_lookahead', False):\n lengths = np.sum(decoding_mask, axis=1) - 1\n l = np.concatenate([lengths[:-1][(lengths[1:] - lengths[:-1]) <= 0], lengths[-1:]], axis=0)\n ls = ','.join(l.astype(np.str_))\n decoding_qids = decoding_kwargs['decoding_qids']\n size_str = ','.join([str(x) for x in sizes])\n print(\n f'decoding_length:{len(decoding_ids)+1} accept_length:{max_match_count+1} '\n f'query:{decoding_qids} source:{size_str} lengths:{ls} index:{max_match_index} '\n f'branch_token:{max_decoding_ids_slice} next_token:{max_next_token_slice}')\n\n return model_kwargs\n\n def _update_cache(self, past_key_values, kv_idx, prefix_and_next_count=None, max_match_count=None,\n max_match_index=None):\n update_past_key_values = []\n for k, v in past_key_values:\n if max_match_index + 1 == max_match_count:\n k = k[:, :, :prefix_and_next_count + max_match_count]\n v = v[:, :, :prefix_and_next_count + max_match_count]\n else:\n k = torch.concat([k[:, :, :prefix_and_next_count], k[:, :, kv_idx]], 2)\n v = torch.concat([v[:, :, :prefix_and_next_count], v[:, :, kv_idx]], 2)\n update_past_key_values.append((k, v))\n return tuple(update_past_key_values)\n\n def lookahead_generation(\n self,\n input_ids: torch.LongTensor,\n logits_processor: Optional[LogitsProcessorList] = None,\n stopping_criteria: Optional[StoppingCriteriaList] = None,\n max_length: Optional[int] = None,\n pad_token_id: Optional[int] = None,\n eos_token_id: Optional[Union[int, List[int]]] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n output_scores: Optional[bool] = None,\n return_dict_in_generate: Optional[bool] = None,\n synced_gpus: bool = False,\n streamer: Optional[\"BaseStreamer\"] = None,\n **model_kwargs,\n ) -> Union[GreedySearchOutput, torch.LongTensor]:\n r\"\"\"\n Generates sequences of token ids for models with a language modeling head using **greedy decoding** and can be\n used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.\n\n <Tip warning={true}>\n\n In most cases, you do not need to call [`~generation.GenerationMixin.greedy_search`] directly. Use generate()\n instead. For an overview of generation strategies and code examples, check the [following\n guide](../generation_strategies).\n\n </Tip>\n\n\n Parameters:\n input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):\n The sequence used as a prompt for the generation.\n logits_processor (`LogitsProcessorList`, *optional*):\n An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]\n used to modify the prediction scores of the language modeling head applied at each generation step.\n stopping_criteria (`StoppingCriteriaList`, *optional*):\n An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]\n used to tell if the generation loop should stop.\n\n max_length (`int`, *optional*, defaults to 20):\n **DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated\n tokens. The maximum length of the sequence to be generated.\n pad_token_id (`int`, *optional*):\n The id of the *padding* token.\n eos_token_id (`Union[int, List[int]]`, *optional*):\n The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.\n output_attentions (`bool`, *optional*, defaults to `False`):\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under\n returned tensors for more details.\n output_hidden_states (`bool`, *optional*, defaults to `False`):\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors\n for more details.\n output_scores (`bool`, *optional*, defaults to `False`):\n Whether or not to return the prediction scores. See `scores` under returned tensors for more details.\n return_dict_in_generate (`bool`, *optional*, defaults to `False`):\n Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\n synced_gpus (`bool`, *optional*, defaults to `False`):\n Whether to continue running the while loop until max_length (needed for ZeRO stage 3)\n streamer (`BaseStreamer`, *optional*):\n Streamer object that will be used to stream the generated sequences. Generated tokens are passed\n through `streamer.put(token_ids)` and the streamer is responsible for any further processing.\n model_kwargs:\n Additional model specific keyword arguments will be forwarded to the `forward` function of the model.\n If model is an encoder-decoder model the kwargs should include `encoder_outputs`.\n\n Return:\n [`~generation.GreedySearchDecoderOnlyOutput`], [`~generation.GreedySearchEncoderDecoderOutput`] or\n `torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a\n [`~generation.GreedySearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and\n `return_dict_in_generate=True` or a [`~generation.GreedySearchEncoderDecoderOutput`] if\n `model.config.is_encoder_decoder=True`.\n\n Examples:\n\n ```python\n >>> from transformers import (\n ... AutoTokenizer,\n ... AutoModelForCausalLM,\n ... LogitsProcessorList,\n ... MinLengthLogitsProcessor,\n ... StoppingCriteriaList,\n ... MaxLengthCriteria,\n ... )\n\n >>> tokenizer = AutoTokenizer.from_pretrained(\"gpt2\")\n >>> model = AutoModelForCausalLM.from_pretrained(\"gpt2\")\n\n >>> # set pad_token_id to eos_token_id because GPT2 does not have a PAD token\n >>> model.generation_config.pad_token_id = model.generation_config.eos_token_id\n\n >>> input_prompt = \"It might be possible to\"\n >>> input_ids = tokenizer(input_prompt, return_tensors=\"pt\").input_ids\n\n >>> # instantiate logits processors\n >>> logits_processor = LogitsProcessorList(\n ... [\n ... MinLengthLogitsProcessor(10, eos_token_id=model.generation_config.eos_token_id),\n ... ]\n ... )\n >>> stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])\n\n >>> outputs = model.greedy_search(\n ... input_ids, logits_processor=logits_processor, stopping_criteria=stopping_criteria\n ... )\n\n >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)\n [\"It might be possible to get a better understanding of the nature of the problem, but it's not\"]\n ```\"\"\"\n # init values\n\n if not hasattr(self, 'lookahead_cache'):\n self.lookahead_cache = LookaheadCache()\n\n logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()\n stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()\n if max_length is not None:\n warnings.warn(\n \"`max_length` is deprecated in this function, use\"\n \" `stopping_criteria=StoppingCriteriaList([MaxLengthCriteria(max_length=max_length)])` instead.\",\n UserWarning,\n )\n stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)\n pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id\n eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id\n if isinstance(eos_token_id, int):\n eos_token_id = [eos_token_id]\n eos_token_id_tensor = torch.tensor(eos_token_id, device=input_ids.device) if eos_token_id is not None else None\n output_scores = output_scores if output_scores is not None else self.generation_config.output_scores\n output_attentions = (\n output_attentions if output_attentions is not None else self.generation_config.output_attentions\n )\n output_hidden_states = (\n output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states\n )\n return_dict_in_generate = (\n return_dict_in_generate\n if return_dict_in_generate is not None\n else self.generation_config.return_dict_in_generate\n )\n\n # init attention / hidden states / scores tuples\n scores = () if (return_dict_in_generate and output_scores) else None\n decoder_attentions = () if (return_dict_in_generate and output_attentions) else None\n cross_attentions = () if (return_dict_in_generate and output_attentions) else None\n decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None\n\n # if model is an encoder-decoder, retrieve encoder attention weights and hidden states\n if return_dict_in_generate and self.config.is_encoder_decoder:\n encoder_attentions = model_kwargs[\"encoder_outputs\"].get(\"attentions\") if output_attentions else None\n encoder_hidden_states = (\n model_kwargs[\"encoder_outputs\"].get(\"hidden_states\") if output_hidden_states else None\n )\n\n decoding_kwargs = model_kwargs['decoding_kwargs']\n decoding_kwargs.update({\n 'eos': eos_token_id[0] if eos_token_id is not None else 2,\n 'edls': [],\n 'dls': [],\n 'fts': []\n })\n\n decoding_length = decoding_kwargs.get('decoding_length', 64)\n stop_max_length = stopping_criteria.max_length\n decoding_max_length = stop_max_length + decoding_length + 1\n attention_mask = model_kwargs.get('attention_mask', None)\n input_device = input_ids.device\n if attention_mask is None:\n bs = input_ids.size(0)\n full_attention_mask = torch.tril(\n torch.ones((bs, 1, decoding_max_length, decoding_max_length), dtype=torch.long, device=input_device),\n 0)\n elif len(attention_mask.shape) == 2:\n # from [bs, src_len] to [bs,1,max_len,max_len]\n bs, src_len = attention_mask.shape\n pad_len = decoding_max_length - src_len\n attention_mask = attention_mask.long()\n if pad_len > 0:\n pad_mask = torch.ones((bs, pad_len), dtype=torch.long, device=attention_mask.device)\n attention_mask = torch.cat([attention_mask, pad_mask], 1)\n full_attention_mask = torch.tril(attention_mask[:, None, None].expand(-1, -1, decoding_max_length, -1), 0)\n elif len(attention_mask.shape) == 4:\n bs, _, src_len, tgt_len = attention_mask.shape\n attention_mask = attention_mask.long()\n if src_len < decoding_max_length or tgt_len < decoding_max_length:\n full_attention_mask = torch.tril(\n torch.ones((bs, 1, decoding_max_length, decoding_max_length), dtype=torch.long,\n device=input_device),\n 0)\n full_attention_mask[:, :, :src_len, :tgt_len] = attention_mask\n else:\n full_attention_mask = attention_mask\n else:\n raise ValueError(f'unsupport attention_mask.shape:{attention_mask.shape}')\n model_kwargs['attention_mask'] = full_attention_mask\n decoding_kwargs['max_length'] = stop_max_length\n decoding_kwargs['decoding_max_length'] = decoding_max_length\n\n # keep track of which sequences are already finished\n unfinished_sequences = torch.ones(input_ids.shape[0], dtype=torch.long, device=input_ids.device)\n\n assert input_ids.size(0) == 1\n input_id_list = input_ids[0].tolist()\n decoding_kwargs['input_id_list'] = [input_id_list]\n branch_length = decoding_kwargs.get('branch_length', 12)\n self.lookahead_cache.put(input_id_list[1:], branch_length=branch_length + 1, mode='input', idx=0)\n ts = time.time()\n\n this_peer_finished = False # used by synced_gpus only\n while True:\n if synced_gpus:\n # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.\n # The following logic allows an early break if all peers finished generating their sequence\n this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)\n # send 0.0 if we finished, 1.0 otherwise\n dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)\n # did all peers finish? the reduced sum will be 0.0 then\n if this_peer_finished_flag.item() == 0.0:\n break\n\n # prepare model inputs\n model_inputs = self.lookahead_prepare_inputs_for_generation(input_ids, **model_kwargs)\n decoding_kwargs = model_inputs.pop('decoding_kwargs', {})\n\n # forward pass to get next token\n outputs = self(\n **model_inputs,\n return_dict=True,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n )\n\n if synced_gpus and this_peer_finished:\n continue # don't waste resources running the code we don't need\n\n model_kwargs['decoding_kwargs'] = decoding_kwargs\n model_kwargs = self._lookahead_update_model_kwargs_for_generation(\n outputs,\n model_kwargs,\n is_encoder_decoder=self.config.is_encoder_decoder,\n input_ids=input_ids,\n logits_processor=logits_processor\n )\n\n next_tokens = model_kwargs['next_tokens']\n next_tokens_scores = model_kwargs['next_tokens_scores']\n next_token_list = model_kwargs['next_token_list']\n\n # finished sentences should have their next token be a padding token\n if eos_token_id is not None:\n if pad_token_id is None:\n raise ValueError(\"If `eos_token_id` is defined, make sure that `pad_token_id` is defined.\")\n next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)\n\n # update generated ids, model inputs, and length for next step\n input_ids = torch.cat([input_ids, next_tokens], dim=-1)\n if streamer is not None:\n streamer.put(next_token_list)\n\n self.lookahead_cache.stream_put(next_token_list[0], branch_length=branch_length + 1, final=False,\n mode='output', idx=0)\n\n # Store scores, attentions and hidden_states when required\n if return_dict_in_generate:\n if output_scores:\n scores += (next_tokens_scores,)\n if output_attentions:\n decoder_attentions += (\n (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)\n )\n if self.config.is_encoder_decoder:\n cross_attentions += (outputs.cross_attentions,)\n\n if output_hidden_states:\n decoder_hidden_states += (\n (outputs.decoder_hidden_states,)\n if self.config.is_encoder_decoder\n else (outputs.hidden_states,)\n )\n\n # if eos_token was found in one sentence, set sentence to finished\n if eos_token_id_tensor is not None:\n # unfinished_sequences = unfinished_sequences.mul(\n # next_tokens.tile(eos_token_id_tensor.shape[0], 1).ne(eos_token_id_tensor.unsqueeze(1)).prod(dim=0)\n # )\n unfinished_sequences = unfinished_sequences.mul(\n next_tokens[:, :, None].ne(eos_token_id_tensor).prod(dim=2).prod(dim=1))\n\n # stop when each sentence is finished\n if unfinished_sequences.max() == 0:\n this_peer_finished = True\n\n # stop if we exceed the maximum length\n if stopping_criteria(input_ids, scores):\n this_peer_finished = True\n\n te = time.time()\n model_kwargs['decoding_kwargs']['fts'].append(te - ts)\n ts = te\n if this_peer_finished and not synced_gpus:\n self.lookahead_cache.stream_put([], branch_length=branch_length + 1, final=True,\n mode='output', idx=0)\n break\n\n if streamer is not None:\n streamer.end()\n\n if return_dict_in_generate:\n if self.config.is_encoder_decoder:\n return GreedySearchEncoderDecoderOutput(\n sequences=input_ids,\n scores=scores,\n encoder_attentions=encoder_attentions,\n encoder_hidden_states=encoder_hidden_states,\n decoder_attentions=decoder_attentions,\n cross_attentions=cross_attentions,\n decoder_hidden_states=decoder_hidden_states,\n )\n else:\n kwargs = {'dls': model_kwargs['decoding_kwargs']['dls'],\n 'edls': model_kwargs['decoding_kwargs']['edls'],\n 'fts': model_kwargs['decoding_kwargs']['fts']}\n return LookaheadDecoderOnlyOutput(\n sequences=input_ids,\n scores=scores,\n attentions=decoder_attentions,\n hidden_states=decoder_hidden_states,\n kwargs=kwargs\n )\n else:\n return input_ids\n\n def _validate_model_kwargs(self, model_kwargs: Dict[str, Any]):\n \"\"\"Validates model kwargs for generation. Generate argument typos will also be caught here.\"\"\"\n # Excludes arguments that are handled before calling any model function\n if self.config.is_encoder_decoder:\n for key in [\"decoder_input_ids\"]:\n model_kwargs.pop(key, None)\n\n unused_model_args = []\n model_args = set(inspect.signature(self.prepare_inputs_for_generation).parameters)\n # `kwargs`/`model_kwargs` is often used to handle optional forward pass inputs like `attention_mask`. If\n # `prepare_inputs_for_generation` doesn't accept them, then a stricter check can be made ;)\n if \"kwargs\" in model_args or \"model_kwargs\" in model_args:\n model_args |= set(inspect.signature(self.forward).parameters)\n\n # Encoder-Decoder models may also need Encoder arguments from `model_kwargs`\n if self.config.is_encoder_decoder:\n base_model = getattr(self, self.base_model_prefix, None)\n\n # allow encoder kwargs\n encoder = getattr(self, \"encoder\", None)\n # `MusicgenForConditionalGeneration` has `text_encoder` and `audio_encoder`.\n # Also, it has `base_model_prefix = \"encoder_decoder\"` but there is no `self.encoder_decoder`\n # TODO: A better way to handle this.\n if encoder is None and base_model is not None:\n encoder = getattr(base_model, \"encoder\", None)\n\n if encoder is not None:\n encoder_model_args = set(inspect.signature(encoder.forward).parameters)\n model_args |= encoder_model_args\n\n # allow decoder kwargs\n decoder = getattr(self, \"decoder\", None)\n if decoder is None and base_model is not None:\n decoder = getattr(base_model, \"decoder\", None)\n\n if decoder is not None:\n decoder_model_args = set(inspect.signature(decoder.forward).parameters)\n model_args |= {f\"decoder_{x}\" for x in decoder_model_args}\n\n decoding_kwargs = ['decoding_kwargs','stop_words_ids']\n for key, value in model_kwargs.items():\n if value is not None and key not in model_args and key not in decoding_kwargs:\n unused_model_args.append(key)\n\n if unused_model_args:\n raise ValueError(\n f\"The following `model_kwargs` are not used by the model: {unused_model_args} (note: typos in the\"\n \" generate arguments will also show up in this list)\"\n )"},{"identifier":"QWenConfig","path":"pia/lookahead/models/qwen/configuration_qwen.py","snippet":"class QWenConfig(PretrainedConfig):\n model_type = \"qwen\"\n keys_to_ignore_at_inference = [\"past_key_values\"]\n\n def __init__(\n self,\n vocab_size=151936,\n hidden_size=4096,\n num_hidden_layers=32,\n num_attention_heads=32,\n emb_dropout_prob=0.0,\n attn_dropout_prob=0.0,\n layer_norm_epsilon=1e-6,\n initializer_range=0.02,\n max_position_embeddings=8192,\n scale_attn_weights=True,\n use_cache=True,\n bf16=False,\n fp16=False,\n fp32=False,\n kv_channels=128,\n rotary_pct=1.0,\n rotary_emb_base=10000,\n use_dynamic_ntk=True,\n use_logn_attn=True,\n use_flash_attn=\"auto\",\n intermediate_size=22016,\n no_bias=True,\n tie_word_embeddings=False,\n **kwargs,\n ):\n self.vocab_size = vocab_size\n self.hidden_size = hidden_size\n self.intermediate_size = intermediate_size\n self.num_hidden_layers = num_hidden_layers\n self.num_attention_heads = num_attention_heads\n self.emb_dropout_prob = emb_dropout_prob\n self.attn_dropout_prob = attn_dropout_prob\n self.layer_norm_epsilon = layer_norm_epsilon\n self.initializer_range = initializer_range\n self.scale_attn_weights = scale_attn_weights\n self.use_cache = use_cache\n self.max_position_embeddings = max_position_embeddings\n self.bf16 = bf16\n self.fp16 = fp16\n self.fp32 = fp32\n self.kv_channels = kv_channels\n self.rotary_pct = rotary_pct\n self.rotary_emb_base = rotary_emb_base\n self.use_dynamic_ntk = use_dynamic_ntk\n self.use_logn_attn = use_logn_attn\n self.use_flash_attn = use_flash_attn\n self.no_bias = no_bias\n super().__init__(\n tie_word_embeddings=tie_word_embeddings,\n **kwargs\n )"},{"identifier":"HistoryType","path":"pia/lookahead/models/qwen/qwen_generation_utils.py","snippet":"def pad_batch(batch: BatchTokensType, pad_id: int, seq_length: int) -> BatchTokensType:\ndef get_ltor_masks_and_position_ids(\n data,\n eod_token,\n reset_position_ids,\n reset_attention_mask,\n eod_mask_loss,\n):\ndef get_batch(context_tokens: torch.LongTensor, eod_id: int):\ndef get_stop_words_ids(chat_format, tokenizer):\ndef make_context(\n tokenizer: PreTrainedTokenizer,\n query: str,\n history: List[Tuple[str, str]] = None,\n system: str = \"\",\n max_window_size: int = 6144,\n chat_format: str = \"chatml\",\n):\n def _tokenize_str(role, content):\ndef _decode_default(\n tokens: List[int],\n *,\n stop_words: List[str],\n eod_words: List[str],\n tokenizer: PreTrainedTokenizer,\n raw_text_len: int,\n verbose: bool = False,\n return_end_reason: bool = False,\n errors: str = 'replace',\n):\ndef _decode_chatml(\n tokens: List[int],\n *,\n stop_words: List[str],\n eod_token_ids: List[int],\n tokenizer: PreTrainedTokenizer,\n raw_text_len: int,\n context_length: int,\n verbose: bool = False,\n return_end_reason: bool = False,\n errors: str = 'replace'\n):\ndef decode_tokens(\n tokens: Union[torch.LongTensor, TokensType],\n tokenizer: PreTrainedTokenizer,\n raw_text_len: int,\n context_length: int,\n chat_format: str,\n verbose: bool = False,\n return_end_reason: bool = False,\n errors: str = \"replace\",\n) -> str:\n def __init__(self, stop_words_ids: Iterable[Iterable[int]], eos_token_id: int):\n def __call__(\n self, input_ids: torch.LongTensor, scores: torch.FloatTensor\n ) -> torch.FloatTensor:\n def _tokens_match(self, prev_tokens: torch.LongTensor, tokens: List[int]) -> bool:\n def _calc_stopped_samples(self, prev_input_ids: Iterable[int]) -> Iterable[int]:\ndef top_k_logits(logits, top_k=0, top_p=0.0, filter_value=-float(\"Inf\")):\ndef switch(val1, val2, boolean):\nclass StopWordsLogitsProcessor(LogitsProcessor):"}],"string":"[\n {\n \"identifier\": \"LookaheadPreTrainedModel\",\n \"path\": \"pia/lookahead/common/pretrained_model.py\",\n \"snippet\": \"class LookaheadPreTrainedModel(PreTrainedModel):\\n _batch_generation = False\\n _stream_generation = False\\n\\n def __init__(self, config):\\n super().__init__(config=config)\\n\\n def _get_generation_mode(\\n self, generation_config: GenerationConfig, assistant_model: Optional[\\\"PreTrainedModel\\\"]\\n ) -> GenerationMode:\\n \\\"\\\"\\\"\\n Returns the generation mode triggered by a [`GenerationConfig`] instance.\\n \\\"\\\"\\\"\\n if generation_config.constraints is not None or generation_config.force_words_ids is not None:\\n generation_mode = GenerationMode.CONSTRAINED_BEAM_SEARCH\\n elif generation_config.num_beams == 1:\\n if generation_config.do_sample is False:\\n if (\\n generation_config.top_k is not None\\n and generation_config.top_k > 1\\n and generation_config.penalty_alpha is not None\\n and generation_config.penalty_alpha > 0\\n ):\\n generation_mode = GenerationMode.CONTRASTIVE_SEARCH\\n elif generation_config.use_cache \\\\\\n and hasattr(generation_config, 'decoding_kwargs') \\\\\\n and generation_config.decoding_kwargs.get('use_lookahead', False) \\\\\\n and generation_config.decoding_kwargs.get('decoding_length', 64) > 1 \\\\\\n and generation_config.decoding_kwargs.get('branch_length', 12) > 0:\\n generation_mode = GenerationMode.LOOKAHEAD_GENERATION\\n else:\\n generation_mode = GenerationMode.GREEDY_SEARCH\\n else:\\n if generation_config.use_cache \\\\\\n and hasattr(generation_config, 'decoding_kwargs') \\\\\\n and generation_config.decoding_kwargs.get('use_lookahead', False) \\\\\\n and generation_config.decoding_kwargs.get('decoding_length', 64) > 1 \\\\\\n and generation_config.decoding_kwargs.get('branch_length', 12) > 0:\\n generation_mode = GenerationMode.LOOKAHEAD_GENERATION\\n else:\\n generation_mode = GenerationMode.SAMPLE\\n else:\\n if generation_config.num_beam_groups > 1:\\n generation_mode = GenerationMode.GROUP_BEAM_SEARCH\\n elif generation_config.do_sample is True:\\n generation_mode = GenerationMode.BEAM_SAMPLE\\n else:\\n generation_mode = GenerationMode.BEAM_SEARCH\\n\\n # Assisted generation may extend some generation modes\\n if assistant_model is not None:\\n if generation_mode in (\\\"greedy_search\\\", \\\"sample\\\"):\\n generation_mode = GenerationMode.ASSISTED_GENERATION\\n else:\\n raise ValueError(\\n \\\"You've set `assistant_model`, which triggers assisted generate. Currently, assisted generate \\\"\\n \\\"is only supported with Greedy Search and Sample.\\\"\\n )\\n return generation_mode\\n\\n @torch.no_grad()\\n def generate(\\n self,\\n inputs: Optional[torch.Tensor] = None,\\n generation_config: Optional[GenerationConfig] = None,\\n logits_processor: Optional[LogitsProcessorList] = None,\\n stopping_criteria: Optional[StoppingCriteriaList] = None,\\n prefix_allowed_tokens_fn: Optional[Callable[[int, torch.Tensor], List[int]]] = None,\\n synced_gpus: Optional[bool] = None,\\n assistant_model: Optional[\\\"PreTrainedModel\\\"] = None,\\n streamer: Optional[\\\"BaseStreamer\\\"] = None,\\n **kwargs,\\n ) -> Union[GenerateOutput, torch.LongTensor]:\\n r\\\"\\\"\\\"\\n\\n Generates sequences of token ids for models with a language modeling head.\\n\\n <Tip warning={true}>\\n\\n Most generation-controlling parameters are set in `generation_config` which, if not passed, will be set to the\\n model's default generation configuration. You can override any `generation_config` by passing the corresponding\\n parameters to generate(), e.g. `.generate(inputs, num_beams=4, do_sample=True)`.\\n\\n For an overview of generation strategies and code examples, check out the [following\\n guide](../generation_strategies).\\n\\n </Tip>\\n\\n Parameters:\\n inputs (`torch.Tensor` of varying shape depending on the modality, *optional*):\\n The sequence used as a prompt for the generation or as model inputs to the encoder. If `None` the\\n method initializes it with `bos_token_id` and a batch size of 1. For decoder-only models `inputs`\\n should of in the format of `input_ids`. For encoder-decoder models *inputs* can represent any of\\n `input_ids`, `input_values`, `input_features`, or `pixel_values`.\\n generation_config (`~generation.GenerationConfig`, *optional*):\\n The generation configuration to be used as base parametrization for the generation call. `**kwargs`\\n passed to generate matching the attributes of `generation_config` will override them. If\\n `generation_config` is not provided, the default will be used, which had the following loading\\n priority: 1) from the `generation_config.json` model file, if it exists; 2) from the model\\n configuration. Please note that unspecified parameters will inherit [`~generation.GenerationConfig`]'s\\n default values, whose documentation should be checked to parameterize generation.\\n logits_processor (`LogitsProcessorList`, *optional*):\\n Custom logits processors that complement the default logits processors built from arguments and\\n generation config. If a logit processor is passed that is already created with the arguments or a\\n generation config an error is thrown. This feature is intended for advanced users.\\n stopping_criteria (`StoppingCriteriaList`, *optional*):\\n Custom stopping criteria that complement the default stopping criteria built from arguments and a\\n generation config. If a stopping criteria is passed that is already created with the arguments or a\\n generation config an error is thrown. This feature is intended for advanced users.\\n prefix_allowed_tokens_fn (`Callable[[int, torch.Tensor], List[int]]`, *optional*):\\n If provided, this function constraints the beam search to allowed tokens only at each step. If not\\n provided no constraint is applied. This function takes 2 arguments: the batch ID `batch_id` and\\n `input_ids`. It has to return a list with the allowed tokens for the next generation step conditioned\\n on the batch ID `batch_id` and the previously generated tokens `inputs_ids`. This argument is useful\\n for constrained generation conditioned on the prefix, as described in [Autoregressive Entity\\n Retrieval](https://arxiv.org/abs/2010.00904).\\n synced_gpus (`bool`, *optional*):\\n Whether to continue running the while loop until max_length. Unless overridden this flag will be set to\\n `True` under DeepSpeed ZeRO Stage 3 multiple GPUs environment to avoid hanging if one GPU finished\\n generating before other GPUs. Otherwise it'll be set to `False`.\\n assistant_model (`PreTrainedModel`, *optional*):\\n An assistant model that can be used to accelerate generation. The assistant model must have the exact\\n same tokenizer. The acceleration is achieved when forecasting candidate tokens with the assistent model\\n is much faster than running generation with the model you're calling generate from. As such, the\\n assistant model should be much smaller.\\n streamer (`BaseStreamer`, *optional*):\\n Streamer object that will be used to stream the generated sequences. Generated tokens are passed\\n through `streamer.put(token_ids)` and the streamer is responsible for any further processing.\\n kwargs (`Dict[str, Any]`, *optional*):\\n Ad hoc parametrization of `generate_config` and/or additional model-specific kwargs that will be\\n forwarded to the `forward` function of the model. If the model is an encoder-decoder model, encoder\\n specific kwargs should not be prefixed and decoder specific kwargs should be prefixed with *decoder_*.\\n\\n Return:\\n [`~utils.ModelOutput`] or `torch.LongTensor`: A [`~utils.ModelOutput`] (if `return_dict_in_generate=True`\\n or when `config.return_dict_in_generate=True`) or a `torch.FloatTensor`.\\n\\n If the model is *not* an encoder-decoder model (`model.config.is_encoder_decoder=False`), the possible\\n [`~utils.ModelOutput`] types are:\\n\\n - [`~generation.GreedySearchDecoderOnlyOutput`],\\n - [`~generation.SampleDecoderOnlyOutput`],\\n - [`~generation.BeamSearchDecoderOnlyOutput`],\\n - [`~generation.BeamSampleDecoderOnlyOutput`]\\n\\n If the model is an encoder-decoder model (`model.config.is_encoder_decoder=True`), the possible\\n [`~utils.ModelOutput`] types are:\\n\\n - [`~generation.GreedySearchEncoderDecoderOutput`],\\n - [`~generation.SampleEncoderDecoderOutput`],\\n - [`~generation.BeamSearchEncoderDecoderOutput`],\\n - [`~generation.BeamSampleEncoderDecoderOutput`]\\n \\\"\\\"\\\"\\n\\n if synced_gpus is None:\\n # if is_deepspeed_zero3_enabled() and dist.get_world_size() > 1:\\n # synced_gpus = True\\n # else:\\n # synced_gpus = False\\n synced_gpus = False\\n\\n # 1. Handle `generation_config` and kwargs that might update it, and validate the `.generate()` call\\n self._validate_model_class()\\n\\n # priority: `generation_config` argument > `model.generation_config` (the default generation config)\\n if generation_config is None:\\n # legacy: users may modify the model configuration to control generation -- update the generation config\\n # model attribute accordingly, if it was created from the model config\\n if self.generation_config._from_model_config:\\n new_generation_config = GenerationConfig.from_model_config(self.config)\\n if new_generation_config != self.generation_config:\\n # warnings.warn(\\n # \\\"You have modified the pretrained model configuration to control generation. This is a\\\"\\n # \\\" deprecated strategy to control generation and will be removed soon, in a future version.\\\"\\n # \\\" Please use a generation configuration file (see\\\"\\n # \\\" https://huggingface.co/docs/transformers/main_classes/text_generation )\\\"\\n # )\\n self.generation_config = new_generation_config\\n generation_config = self.generation_config\\n\\n generation_config = copy.deepcopy(generation_config)\\n model_kwargs = generation_config.update(**kwargs) # All unused kwargs must be model kwargs\\n generation_config.validate()\\n self._validate_model_kwargs(model_kwargs.copy())\\n if not hasattr(generation_config, 'decoding_kwargs'):\\n generation_config.decoding_kwargs = model_kwargs.get('decoding_kwargs', {})\\n\\n # 2. Set generation parameters if not already defined\\n logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()\\n stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()\\n\\n if generation_config.pad_token_id is None and generation_config.eos_token_id is not None:\\n if model_kwargs.get(\\\"attention_mask\\\", None) is None:\\n logger.warning(\\n \\\"The attention mask and the pad token id were not set. As a consequence, you may observe \\\"\\n \\\"unexpected behavior. Please pass your input's `attention_mask` to obtain reliable results.\\\"\\n )\\n eos_token_id = generation_config.eos_token_id\\n if isinstance(eos_token_id, list):\\n eos_token_id = eos_token_id[0]\\n logger.warning(f\\\"Setting `pad_token_id` to `eos_token_id`:{eos_token_id} for open-end generation.\\\")\\n generation_config.pad_token_id = eos_token_id\\n\\n # 3. Define model inputs\\n # inputs_tensor has to be defined\\n # model_input_name is defined if model-specific keyword input is passed\\n # otherwise model_input_name is None\\n # all model-specific keyword inputs are removed from `model_kwargs`\\n inputs_tensor, model_input_name, model_kwargs = self._prepare_model_inputs(\\n inputs, generation_config.bos_token_id, model_kwargs\\n )\\n batch_size = inputs_tensor.shape[0]\\n\\n # 4. Define other model kwargs\\n model_kwargs[\\\"output_attentions\\\"] = generation_config.output_attentions\\n model_kwargs[\\\"output_hidden_states\\\"] = generation_config.output_hidden_states\\n # decoder-only models with inputs_embeds forwarding must use caching (otherwise we can't detect whether we are\\n # generating the first new token or not, and we only want to use the embeddings for the first new token)\\n if not self.config.is_encoder_decoder and model_input_name == \\\"inputs_embeds\\\":\\n model_kwargs[\\\"use_cache\\\"] = True\\n else:\\n model_kwargs[\\\"use_cache\\\"] = generation_config.use_cache\\n\\n accepts_attention_mask = \\\"attention_mask\\\" in set(inspect.signature(self.forward).parameters.keys())\\n requires_attention_mask = \\\"encoder_outputs\\\" not in model_kwargs\\n\\n if model_kwargs.get(\\\"attention_mask\\\", None) is None and requires_attention_mask and accepts_attention_mask:\\n model_kwargs[\\\"attention_mask\\\"] = self._prepare_attention_mask_for_generation(\\n inputs_tensor, generation_config.pad_token_id, generation_config.eos_token_id\\n )\\n\\n # decoder-only models should use left-padding for generation\\n if not self.config.is_encoder_decoder:\\n # If `input_ids` was given, check if the last id in any sequence is `pad_token_id`\\n # Note: If using, `inputs_embeds` this check does not work, because we want to be more hands-off.\\n if (\\n generation_config.pad_token_id is not None\\n and len(inputs_tensor.shape) == 2\\n and torch.sum(inputs_tensor[:, -1] == generation_config.pad_token_id) > 0\\n ):\\n logger.warning(\\n \\\"A decoder-only architecture is being used, but right-padding was detected! For correct \\\"\\n \\\"generation results, please set `padding_side='left'` when initializing the tokenizer.\\\"\\n )\\n\\n if self.config.is_encoder_decoder and \\\"encoder_outputs\\\" not in model_kwargs:\\n # if model is encoder decoder encoder_outputs are created\\n # and added to `model_kwargs`\\n model_kwargs = self._prepare_encoder_decoder_kwargs_for_generation(\\n inputs_tensor, model_kwargs, model_input_name\\n )\\n\\n # 5. Prepare `input_ids` which will be used for auto-regressive generation\\n if self.config.is_encoder_decoder:\\n input_ids, model_kwargs = self._prepare_decoder_input_ids_for_generation(\\n batch_size=batch_size,\\n model_input_name=model_input_name,\\n model_kwargs=model_kwargs,\\n decoder_start_token_id=generation_config.decoder_start_token_id,\\n bos_token_id=generation_config.bos_token_id,\\n device=inputs_tensor.device,\\n )\\n else:\\n input_ids = inputs_tensor if model_input_name == \\\"input_ids\\\" else model_kwargs.pop(\\\"input_ids\\\")\\n\\n if streamer is not None:\\n streamer.put(input_ids.cpu())\\n\\n # 6. Prepare `max_length` depending on other stopping criteria.\\n input_ids_length = input_ids.shape[-1]\\n has_default_max_length = kwargs.get(\\\"max_length\\\") is None and generation_config.max_length is not None\\n if generation_config.max_new_tokens is not None:\\n if not has_default_max_length:\\n logger.warning(\\n f\\\"Both `max_new_tokens` (={generation_config.max_new_tokens}) and `max_length`(=\\\"\\n f\\\"{generation_config.max_length}) seem to have been set. `max_new_tokens` will take precedence. \\\"\\n \\\"Please refer to the documentation for more information. \\\"\\n \\\"(https://huggingface.co/docs/transformers/main/en/main_classes/text_generation)\\\"\\n )\\n generation_config.max_length = generation_config.max_new_tokens + input_ids_length\\n\\n # 7. determine generation mode\\n generation_mode = self._get_generation_mode(generation_config, assistant_model)\\n\\n if streamer is not None and (generation_config.num_beams > 1):\\n raise ValueError(\\n \\\"`streamer` cannot be used with beam search (yet!). Make sure that `num_beams` is set to 1.\\\"\\n )\\n\\n if self.device.type != input_ids.device.type:\\n warnings.warn(\\n \\\"You are calling .generate() with the `input_ids` being on a device type different\\\"\\n f\\\" than your model's device. `input_ids` is on {input_ids.device.type}, whereas the model\\\"\\n f\\\" is on {self.device.type}. You may experience unexpected behaviors or slower generation.\\\"\\n \\\" Please make sure that you have put `input_ids` to the\\\"\\n f\\\" correct device by calling for example input_ids = input_ids.to('{self.device.type}') before\\\"\\n \\\" running `.generate()`.\\\",\\n UserWarning,\\n )\\n\\n # 8. prepare distribution pre_processing samplers\\n logits_processor = self._get_logits_processor(\\n generation_config=generation_config,\\n input_ids_seq_length=input_ids_length,\\n encoder_input_ids=inputs_tensor,\\n prefix_allowed_tokens_fn=prefix_allowed_tokens_fn,\\n logits_processor=logits_processor,\\n )\\n\\n # 9. prepare stopping criteria\\n stopping_criteria = self._get_stopping_criteria(\\n generation_config=generation_config, stopping_criteria=stopping_criteria\\n )\\n\\n decoding_kwargs = generation_config.decoding_kwargs if hasattr(generation_config, 'decoding_kwargs') else {}\\n decoding_kwargs['generation_mode'] = generation_mode\\n decoding_kwargs['do_sample'] = generation_config.do_sample\\n decoding_kwargs['inputs_embeds_position'] = generation_config.inputs_embeds_position if hasattr(generation_config, 'inputs_embeds_position') else 0\\n decoding_kwargs['max_length'] = generation_config.max_length\\n if generation_mode == GenerationMode.LOOKAHEAD_GENERATION:\\n decoding_length = decoding_kwargs.get('decoding_length', 64)\\n decoding_kwargs['decoding_max_length'] = generation_config.max_length + decoding_length + 1\\n else:\\n decoding_kwargs['decoding_max_length'] = generation_config.max_length\\n model_kwargs['decoding_kwargs'] = decoding_kwargs\\n\\n # 10. go into different generation modes\\n if generation_mode == GenerationMode.ASSISTED_GENERATION:\\n if generation_config.num_return_sequences > 1:\\n raise ValueError(\\n \\\"num_return_sequences has to be 1 when doing assisted generate, \\\"\\n f\\\"but is {generation_config.num_return_sequences}.\\\"\\n )\\n if batch_size > 1:\\n raise ValueError(\\\"assisted generate is only supported for batch_size = 1\\\")\\n if not model_kwargs[\\\"use_cache\\\"]:\\n raise ValueError(\\\"assisted generate requires `use_cache=True`\\\")\\n\\n # 11. If the assistant model is an encoder-decoder, prepare its encoder outputs\\n if assistant_model.config.is_encoder_decoder:\\n assistant_model_kwargs = copy.deepcopy(model_kwargs)\\n inputs_tensor, model_input_name, assistant_model_kwargs = assistant_model._prepare_model_inputs(\\n inputs_tensor, assistant_model.generation_config.bos_token_id, assistant_model_kwargs\\n )\\n assistant_model_kwargs = assistant_model._prepare_encoder_decoder_kwargs_for_generation(\\n inputs_tensor, assistant_model_kwargs, model_input_name\\n )\\n model_kwargs[\\\"assistant_encoder_outputs\\\"] = assistant_model_kwargs[\\\"encoder_outputs\\\"]\\n\\n # 12. run assisted generate\\n return self.assisted_decoding(\\n input_ids,\\n assistant_model=assistant_model,\\n do_sample=generation_config.do_sample,\\n logits_processor=logits_processor,\\n logits_warper=self._get_logits_warper(generation_config) if generation_config.do_sample else None,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n streamer=streamer,\\n **model_kwargs,\\n )\\n if generation_mode == GenerationMode.GREEDY_SEARCH:\\n # 11. run greedy search\\n return self.greedy_search(\\n input_ids,\\n logits_processor=logits_processor,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n streamer=streamer,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.LOOKAHEAD_GENERATION:\\n # 11. run greedy search\\n return self.lookahead_generation(\\n input_ids,\\n logits_processor=logits_processor,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n streamer=streamer,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.CONTRASTIVE_SEARCH:\\n if not model_kwargs[\\\"use_cache\\\"]:\\n raise ValueError(\\\"Contrastive search requires `use_cache=True`\\\")\\n\\n return self.contrastive_search(\\n input_ids,\\n top_k=generation_config.top_k,\\n penalty_alpha=generation_config.penalty_alpha,\\n logits_processor=logits_processor,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n streamer=streamer,\\n sequential=generation_config.low_memory,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.SAMPLE:\\n # 11. prepare logits warper\\n logits_warper = self._get_logits_warper(generation_config)\\n\\n # 12. expand input_ids with `num_return_sequences` additional sequences per batch\\n input_ids, model_kwargs = self._expand_inputs_for_generation(\\n input_ids=input_ids,\\n expand_size=generation_config.num_return_sequences,\\n is_encoder_decoder=self.config.is_encoder_decoder,\\n **model_kwargs,\\n )\\n\\n # 13. run sample\\n return self.sample(\\n input_ids,\\n logits_processor=logits_processor,\\n logits_warper=logits_warper,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n streamer=streamer,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.BEAM_SEARCH:\\n # 11. prepare beam search scorer\\n beam_scorer = BeamSearchScorer(\\n batch_size=batch_size,\\n num_beams=generation_config.num_beams,\\n device=inputs_tensor.device,\\n length_penalty=generation_config.length_penalty,\\n do_early_stopping=generation_config.early_stopping,\\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\\n max_length=generation_config.max_length,\\n )\\n # 12. interleave input_ids with `num_beams` additional sequences per batch\\n input_ids, model_kwargs = self._expand_inputs_for_generation(\\n input_ids=input_ids,\\n expand_size=generation_config.num_beams,\\n is_encoder_decoder=self.config.is_encoder_decoder,\\n **model_kwargs,\\n )\\n # 13. run beam search\\n return self.beam_search(\\n input_ids,\\n beam_scorer,\\n logits_processor=logits_processor,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.BEAM_SAMPLE:\\n # 11. prepare logits warper\\n logits_warper = self._get_logits_warper(generation_config)\\n\\n # 12. prepare beam search scorer\\n beam_scorer = BeamSearchScorer(\\n batch_size=batch_size,\\n num_beams=generation_config.num_beams,\\n device=inputs_tensor.device,\\n length_penalty=generation_config.length_penalty,\\n do_early_stopping=generation_config.early_stopping,\\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\\n max_length=generation_config.max_length,\\n )\\n\\n # 13. interleave input_ids with `num_beams` additional sequences per batch\\n input_ids, model_kwargs = self._expand_inputs_for_generation(\\n input_ids=input_ids,\\n expand_size=generation_config.num_beams,\\n is_encoder_decoder=self.config.is_encoder_decoder,\\n **model_kwargs,\\n )\\n\\n # 14. run beam sample\\n return self.beam_sample(\\n input_ids,\\n beam_scorer,\\n logits_processor=logits_processor,\\n logits_warper=logits_warper,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.GROUP_BEAM_SEARCH:\\n # 11. prepare beam search scorer\\n beam_scorer = BeamSearchScorer(\\n batch_size=batch_size,\\n num_beams=generation_config.num_beams,\\n device=inputs_tensor.device,\\n length_penalty=generation_config.length_penalty,\\n do_early_stopping=generation_config.early_stopping,\\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\\n num_beam_groups=generation_config.num_beam_groups,\\n max_length=generation_config.max_length,\\n )\\n # 12. interleave input_ids with `num_beams` additional sequences per batch\\n input_ids, model_kwargs = self._expand_inputs_for_generation(\\n input_ids=input_ids,\\n expand_size=generation_config.num_beams,\\n is_encoder_decoder=self.config.is_encoder_decoder,\\n **model_kwargs,\\n )\\n # 13. run beam search\\n return self.group_beam_search(\\n input_ids,\\n beam_scorer,\\n logits_processor=logits_processor,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n **model_kwargs,\\n )\\n\\n elif generation_mode == GenerationMode.CONSTRAINED_BEAM_SEARCH:\\n final_constraints = []\\n if generation_config.constraints is not None:\\n final_constraints = generation_config.constraints\\n\\n if generation_config.force_words_ids is not None:\\n\\n def typeerror():\\n raise ValueError(\\n \\\"`force_words_ids` has to either be a `List[List[List[int]]]` or `List[List[int]]`\\\"\\n f\\\"of positive integers, but is {generation_config.force_words_ids}.\\\"\\n )\\n\\n if (\\n not isinstance(generation_config.force_words_ids, list)\\n or len(generation_config.force_words_ids) == 0\\n ):\\n typeerror()\\n\\n for word_ids in generation_config.force_words_ids:\\n if isinstance(word_ids[0], list):\\n if not isinstance(word_ids, list) or len(word_ids) == 0:\\n typeerror()\\n if any(not isinstance(token_ids, list) for token_ids in word_ids):\\n typeerror()\\n if any(\\n any((not isinstance(token_id, int) or token_id < 0) for token_id in token_ids)\\n for token_ids in word_ids\\n ):\\n typeerror()\\n\\n constraint = DisjunctiveConstraint(word_ids)\\n else:\\n if not isinstance(word_ids, list) or len(word_ids) == 0:\\n typeerror()\\n if any((not isinstance(token_id, int) or token_id < 0) for token_id in word_ids):\\n typeerror()\\n\\n constraint = PhrasalConstraint(word_ids)\\n final_constraints.append(constraint)\\n\\n # 11. prepare beam search scorer\\n constrained_beam_scorer = ConstrainedBeamSearchScorer(\\n constraints=final_constraints,\\n batch_size=batch_size,\\n num_beams=generation_config.num_beams,\\n device=inputs_tensor.device,\\n length_penalty=generation_config.length_penalty,\\n do_early_stopping=generation_config.early_stopping,\\n num_beam_hyps_to_keep=generation_config.num_return_sequences,\\n max_length=generation_config.max_length,\\n )\\n # 12. interleave input_ids with `num_beams` additional sequences per batch\\n input_ids, model_kwargs = self._expand_inputs_for_generation(\\n input_ids=input_ids,\\n expand_size=generation_config.num_beams,\\n is_encoder_decoder=self.config.is_encoder_decoder,\\n **model_kwargs,\\n )\\n # 13. run beam search\\n return self.constrained_beam_search(\\n input_ids,\\n constrained_beam_scorer=constrained_beam_scorer,\\n logits_processor=logits_processor,\\n stopping_criteria=stopping_criteria,\\n pad_token_id=generation_config.pad_token_id,\\n eos_token_id=generation_config.eos_token_id,\\n output_scores=generation_config.output_scores,\\n return_dict_in_generate=generation_config.return_dict_in_generate,\\n synced_gpus=synced_gpus,\\n **model_kwargs,\\n )\\n\\n def lookahead_prepare_inputs_for_generation(self,\\n input_ids,\\n past_key_values=None,\\n attention_mask=None,\\n inputs_embeds=None,\\n **kwargs):\\n position_ids = kwargs.get(\\\"position_ids\\\", None)\\n\\n decoding_kwargs = kwargs.get('decoding_kwargs', {})\\n decoding_length = decoding_kwargs.get('decoding_length', 64)\\n branch_length = decoding_kwargs.get('branch_length', 12)\\n decoding_mode = decoding_kwargs.get('decoding_mode', 'hier')\\n max_length = decoding_kwargs.get('max_length', 2048)\\n update_branch_length = min(branch_length, max_length - input_ids.size(-1))\\n assert update_branch_length > 0, f'{branch_length=} {max_length=} {input_ids.size(-1)=} {update_branch_length=}'\\n\\n if past_key_values is None:\\n if inputs_embeds is not None and input_ids is not None:\\n model_inputs = {\\\"inputs_embeds\\\": inputs_embeds, \\\"input_ids\\\": input_ids}\\n length = input_ids.size(1)\\n elif input_ids is not None:\\n model_inputs = {\\\"input_ids\\\": input_ids}\\n length = input_ids.size(1)\\n elif inputs_embeds is not None:\\n model_inputs = {\\\"inputs_embeds\\\": inputs_embeds}\\n length = input_ids.size(1)\\n else:\\n raise ValueError('either input_ids or inputs_embeds is not None')\\n update_attention_mask = attention_mask[:, :, :length, :length]\\n\\n model_inputs.update(\\n {\\\"past_key_values\\\": past_key_values,\\n \\\"use_cache\\\": kwargs.get(\\\"use_cache\\\"),\\n \\\"attention_mask\\\": update_attention_mask,\\n \\\"decoding_kwargs\\\": decoding_kwargs\\n })\\n\\n if position_ids is not None:\\n model_inputs[\\\"position_ids\\\"] = self._get_position_ids(position_ids, encoding=True, length=length)\\n\\n else:\\n decoding_qids = input_ids[0, -2:].tolist()\\n # decoding_qids = decoding_kwargs['input_id_list'][0][-2:]\\n min_input_size = 0\\n min_output_size = max(decoding_length // 2, 1)\\n\\n if decoding_mode in ('hier', 'par', 'one'):\\n decoding_mode = decoding_mode + '_mix'\\n fmt, mode = decoding_mode.split('_')\\n method_name = fmt + '_get'\\n\\n decoding_ids, decoding_masks, sizes = getattr(self.lookahead_cache, method_name)(decoding_qids,\\n decoding_length=decoding_length,\\n branch_length=update_branch_length,\\n min_input_size=min_input_size,\\n min_output_size=min_output_size,\\n mode=mode,\\n idx=0)\\n\\n decoding_input_ids = torch.tensor([decoding_ids], dtype=torch.long, device=input_ids.device)\\n prefix_length = input_ids.size(-1) - 1\\n fresh_length = len(decoding_ids)\\n ppl = prefix_length + fresh_length\\n assert ppl <= attention_mask.size(2), \\\\\\n f'{max_length=} {update_branch_length=} {prefix_length=} {fresh_length=} {attention_mask.shape=}'\\n prefix_mask_tensor = attention_mask[:, :, prefix_length:ppl, :prefix_length]\\n decoding_mask_tensor = torch.from_numpy(decoding_masks[None, None]).to(\\n dtype=attention_mask.dtype, device=attention_mask.device)\\n decoding_attention_mask = torch.cat([prefix_mask_tensor, decoding_mask_tensor], dim=3)\\n\\n decoding_kwargs.update({'decoding_qids': decoding_qids,\\n 'decoding_ids': decoding_ids,\\n 'decoding_masks': decoding_masks,\\n 'sizes': sizes,\\n })\\n model_inputs = {'decoding_kwargs': decoding_kwargs}\\n\\n model_inputs.update(\\n {\\n \\\"input_ids\\\": decoding_input_ids,\\n \\\"past_key_values\\\": past_key_values,\\n \\\"use_cache\\\": kwargs.get(\\\"use_cache\\\"),\\n \\\"attention_mask\\\": decoding_attention_mask\\n }\\n )\\n if position_ids is not None:\\n indices = torch.sum(decoding_attention_mask, dim=3).squeeze(1)[0]\\n model_inputs[\\\"position_ids\\\"] = self._get_position_ids(position_ids, indices=indices, encoding=False)\\n\\n return model_inputs\\n\\n def _get_position_ids(self, full_position_ids, indices=None, length=None, encoding=True):\\n if encoding:\\n return full_position_ids[..., :length]\\n else:\\n return full_position_ids[..., indices]\\n\\n def _lookahead_update_model_kwargs_for_generation(\\n self,\\n outputs: ModelOutput,\\n model_kwargs: Dict[str, Any],\\n is_encoder_decoder: bool = False,\\n standardize_cache_format: bool = False,\\n logits_processor: Optional[LogitsProcessorList] = None,\\n input_ids: Optional[torch.Tensor] = None,\\n ) -> Dict[str, Any]:\\n # update past_key_values\\n model_kwargs[\\\"past_key_values\\\"] = self._extract_past_from_model_output(\\n outputs, standardize_cache_format=standardize_cache_format\\n )\\n\\n decoding_kwargs = model_kwargs['decoding_kwargs']\\n decoding_ids = decoding_kwargs.get('decoding_ids', [])\\n if len(decoding_ids) <= 1:\\n next_token_logits = outputs.logits[:, -1:, :]\\n # pre-process distribution\\n # next_tokens_scores = logits_processor(input_ids, next_token_logits)\\n bs, nt, nv = next_token_logits.shape\\n next_tokens_scores = logits_processor(input_ids, next_token_logits.squeeze(1)).unsqueeze(1)\\n\\n if decoding_kwargs.get('do_sample', False):\\n probs = nn.functional.softmax(next_tokens_scores, dim=-1)\\n next_tokens = torch.multinomial(probs.view(bs * nt, nv), num_samples=1).view(bs, nt)\\n else:\\n next_tokens = torch.argmax(next_tokens_scores, dim=-1, keepdim=False).long()\\n model_kwargs['next_tokens'] = next_tokens\\n model_kwargs['next_tokens_scores'] = next_tokens_scores\\n next_token_list = next_tokens.tolist()\\n model_kwargs['next_token_list'] = next_token_list\\n decoding_kwargs['input_id_list'][0].extend(next_token_list[0])\\n decoding_kwargs['dls'].append(1)\\n decoding_kwargs['edls'].append(1)\\n if decoding_kwargs.get('debug_lookahead', False):\\n decoding_qids = decoding_kwargs.get('decoding_qids', [])\\n print(f'size:0 query:{decoding_qids} next_token:{next_token_list[0]}')\\n else:\\n # TODO: accurate logit_processor\\n # next_tokens_scores = logits_processor(input_ids, outputs.logits)\\n bs, nt, nv = outputs.logits.shape\\n next_tokens_scores = logits_processor(input_ids.repeat(1, nt).view(bs * nt, -1),\\n outputs.logits.view(bs * nt, -1)).view(bs, nt, -1)\\n\\n if decoding_kwargs.get('do_sample', False):\\n probs = nn.functional.softmax(next_tokens_scores, dim=-1)\\n bs, nt, nv = probs.shape\\n next_tokens = torch.multinomial(probs.view(bs * nt, nv), num_samples=1).view(bs, nt)\\n else:\\n next_tokens = torch.argmax(next_tokens_scores, dim=-1, keepdim=False).long()\\n\\n next_token_list = next_tokens.tolist()[0]\\n decoding_ids = decoding_kwargs['decoding_ids'][1:]\\n decoding_mask = decoding_kwargs['decoding_masks']\\n sizes = decoding_kwargs['sizes']\\n\\n max_match_index = 0\\n max_match_count = 0\\n max_decoding_ids_slice = None\\n max_next_token_slice = None\\n \\n for i in range(len(decoding_ids)):\\n mask_indices = np.nonzero(decoding_mask[i + 1, 1:])[0]\\n decoding_ids_slice = [decoding_ids[j] for j in mask_indices] \\n next_token_slice = [next_token_list[0]] + [next_token_list[j + 1] for j in mask_indices]\\n \\n c = len(decoding_ids_slice)\\n for j, p in enumerate(decoding_ids_slice):\\n if next_token_slice[j] != p:\\n c = j\\n break\\n if c > max_match_count:\\n max_match_count = c\\n max_match_index = i\\n if c >= max_match_count:\\n max_decoding_ids_slice = decoding_ids_slice\\n max_next_token_slice = next_token_slice\\n # if decoding_kwargs['eos'] in decoding_ids:\\n # max_match_count = 0\\n\\n prefix_plus_count = input_ids.size(-1)\\n match_idx = np.nonzero(decoding_mask[max_match_index + 1, 1:])[0][:max_match_count]\\n if len(decoding_ids) != max_match_count:\\n past = model_kwargs[\\\"past_key_values\\\"]\\n device = past[0][0].device\\n kv_idx = torch.tensor(match_idx + prefix_plus_count, dtype=torch.long, device=device)\\n model_kwargs[\\\"past_key_values\\\"] = self._update_cache(past,\\n kv_idx,\\n prefix_and_next_count=prefix_plus_count,\\n max_match_count=max_match_count,\\n max_match_index=max_match_index)\\n\\n next_token_list = [next_token_list[0:1] + [next_token_list[x + 1] for x in match_idx]]\\n next_tokens = torch.tensor(next_token_list, dtype=torch.long, device=input_ids.device)\\n model_kwargs['next_tokens'] = next_tokens\\n model_kwargs['next_token_list'] = next_token_list\\n decoding_kwargs['input_id_list'][0].extend(next_token_list[0])\\n decoding_kwargs['dls'].append(len(decoding_ids))\\n decoding_kwargs['edls'].append(max_match_count + 1)\\n if decoding_kwargs.get('debug_lookahead', False):\\n lengths = np.sum(decoding_mask, axis=1) - 1\\n l = np.concatenate([lengths[:-1][(lengths[1:] - lengths[:-1]) <= 0], lengths[-1:]], axis=0)\\n ls = ','.join(l.astype(np.str_))\\n decoding_qids = decoding_kwargs['decoding_qids']\\n size_str = ','.join([str(x) for x in sizes])\\n print(\\n f'decoding_length:{len(decoding_ids)+1} accept_length:{max_match_count+1} '\\n f'query:{decoding_qids} source:{size_str} lengths:{ls} index:{max_match_index} '\\n f'branch_token:{max_decoding_ids_slice} next_token:{max_next_token_slice}')\\n\\n return model_kwargs\\n\\n def _update_cache(self, past_key_values, kv_idx, prefix_and_next_count=None, max_match_count=None,\\n max_match_index=None):\\n update_past_key_values = []\\n for k, v in past_key_values:\\n if max_match_index + 1 == max_match_count:\\n k = k[:, :, :prefix_and_next_count + max_match_count]\\n v = v[:, :, :prefix_and_next_count + max_match_count]\\n else:\\n k = torch.concat([k[:, :, :prefix_and_next_count], k[:, :, kv_idx]], 2)\\n v = torch.concat([v[:, :, :prefix_and_next_count], v[:, :, kv_idx]], 2)\\n update_past_key_values.append((k, v))\\n return tuple(update_past_key_values)\\n\\n def lookahead_generation(\\n self,\\n input_ids: torch.LongTensor,\\n logits_processor: Optional[LogitsProcessorList] = None,\\n stopping_criteria: Optional[StoppingCriteriaList] = None,\\n max_length: Optional[int] = None,\\n pad_token_id: Optional[int] = None,\\n eos_token_id: Optional[Union[int, List[int]]] = None,\\n output_attentions: Optional[bool] = None,\\n output_hidden_states: Optional[bool] = None,\\n output_scores: Optional[bool] = None,\\n return_dict_in_generate: Optional[bool] = None,\\n synced_gpus: bool = False,\\n streamer: Optional[\\\"BaseStreamer\\\"] = None,\\n **model_kwargs,\\n ) -> Union[GreedySearchOutput, torch.LongTensor]:\\n r\\\"\\\"\\\"\\n Generates sequences of token ids for models with a language modeling head using **greedy decoding** and can be\\n used for text-decoder, text-to-text, speech-to-text, and vision-to-text models.\\n\\n <Tip warning={true}>\\n\\n In most cases, you do not need to call [`~generation.GenerationMixin.greedy_search`] directly. Use generate()\\n instead. For an overview of generation strategies and code examples, check the [following\\n guide](../generation_strategies).\\n\\n </Tip>\\n\\n\\n Parameters:\\n input_ids (`torch.LongTensor` of shape `(batch_size, sequence_length)`):\\n The sequence used as a prompt for the generation.\\n logits_processor (`LogitsProcessorList`, *optional*):\\n An instance of [`LogitsProcessorList`]. List of instances of class derived from [`LogitsProcessor`]\\n used to modify the prediction scores of the language modeling head applied at each generation step.\\n stopping_criteria (`StoppingCriteriaList`, *optional*):\\n An instance of [`StoppingCriteriaList`]. List of instances of class derived from [`StoppingCriteria`]\\n used to tell if the generation loop should stop.\\n\\n max_length (`int`, *optional*, defaults to 20):\\n **DEPRECATED**. Use `logits_processor` or `stopping_criteria` directly to cap the number of generated\\n tokens. The maximum length of the sequence to be generated.\\n pad_token_id (`int`, *optional*):\\n The id of the *padding* token.\\n eos_token_id (`Union[int, List[int]]`, *optional*):\\n The id of the *end-of-sequence* token. Optionally, use a list to set multiple *end-of-sequence* tokens.\\n output_attentions (`bool`, *optional*, defaults to `False`):\\n Whether or not to return the attentions tensors of all attention layers. See `attentions` under\\n returned tensors for more details.\\n output_hidden_states (`bool`, *optional*, defaults to `False`):\\n Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors\\n for more details.\\n output_scores (`bool`, *optional*, defaults to `False`):\\n Whether or not to return the prediction scores. See `scores` under returned tensors for more details.\\n return_dict_in_generate (`bool`, *optional*, defaults to `False`):\\n Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.\\n synced_gpus (`bool`, *optional*, defaults to `False`):\\n Whether to continue running the while loop until max_length (needed for ZeRO stage 3)\\n streamer (`BaseStreamer`, *optional*):\\n Streamer object that will be used to stream the generated sequences. Generated tokens are passed\\n through `streamer.put(token_ids)` and the streamer is responsible for any further processing.\\n model_kwargs:\\n Additional model specific keyword arguments will be forwarded to the `forward` function of the model.\\n If model is an encoder-decoder model the kwargs should include `encoder_outputs`.\\n\\n Return:\\n [`~generation.GreedySearchDecoderOnlyOutput`], [`~generation.GreedySearchEncoderDecoderOutput`] or\\n `torch.LongTensor`: A `torch.LongTensor` containing the generated tokens (default behaviour) or a\\n [`~generation.GreedySearchDecoderOnlyOutput`] if `model.config.is_encoder_decoder=False` and\\n `return_dict_in_generate=True` or a [`~generation.GreedySearchEncoderDecoderOutput`] if\\n `model.config.is_encoder_decoder=True`.\\n\\n Examples:\\n\\n ```python\\n >>> from transformers import (\\n ... AutoTokenizer,\\n ... AutoModelForCausalLM,\\n ... LogitsProcessorList,\\n ... MinLengthLogitsProcessor,\\n ... StoppingCriteriaList,\\n ... MaxLengthCriteria,\\n ... )\\n\\n >>> tokenizer = AutoTokenizer.from_pretrained(\\\"gpt2\\\")\\n >>> model = AutoModelForCausalLM.from_pretrained(\\\"gpt2\\\")\\n\\n >>> # set pad_token_id to eos_token_id because GPT2 does not have a PAD token\\n >>> model.generation_config.pad_token_id = model.generation_config.eos_token_id\\n\\n >>> input_prompt = \\\"It might be possible to\\\"\\n >>> input_ids = tokenizer(input_prompt, return_tensors=\\\"pt\\\").input_ids\\n\\n >>> # instantiate logits processors\\n >>> logits_processor = LogitsProcessorList(\\n ... [\\n ... MinLengthLogitsProcessor(10, eos_token_id=model.generation_config.eos_token_id),\\n ... ]\\n ... )\\n >>> stopping_criteria = StoppingCriteriaList([MaxLengthCriteria(max_length=20)])\\n\\n >>> outputs = model.greedy_search(\\n ... input_ids, logits_processor=logits_processor, stopping_criteria=stopping_criteria\\n ... )\\n\\n >>> tokenizer.batch_decode(outputs, skip_special_tokens=True)\\n [\\\"It might be possible to get a better understanding of the nature of the problem, but it's not\\\"]\\n ```\\\"\\\"\\\"\\n # init values\\n\\n if not hasattr(self, 'lookahead_cache'):\\n self.lookahead_cache = LookaheadCache()\\n\\n logits_processor = logits_processor if logits_processor is not None else LogitsProcessorList()\\n stopping_criteria = stopping_criteria if stopping_criteria is not None else StoppingCriteriaList()\\n if max_length is not None:\\n warnings.warn(\\n \\\"`max_length` is deprecated in this function, use\\\"\\n \\\" `stopping_criteria=StoppingCriteriaList([MaxLengthCriteria(max_length=max_length)])` instead.\\\",\\n UserWarning,\\n )\\n stopping_criteria = validate_stopping_criteria(stopping_criteria, max_length)\\n pad_token_id = pad_token_id if pad_token_id is not None else self.generation_config.pad_token_id\\n eos_token_id = eos_token_id if eos_token_id is not None else self.generation_config.eos_token_id\\n if isinstance(eos_token_id, int):\\n eos_token_id = [eos_token_id]\\n eos_token_id_tensor = torch.tensor(eos_token_id, device=input_ids.device) if eos_token_id is not None else None\\n output_scores = output_scores if output_scores is not None else self.generation_config.output_scores\\n output_attentions = (\\n output_attentions if output_attentions is not None else self.generation_config.output_attentions\\n )\\n output_hidden_states = (\\n output_hidden_states if output_hidden_states is not None else self.generation_config.output_hidden_states\\n )\\n return_dict_in_generate = (\\n return_dict_in_generate\\n if return_dict_in_generate is not None\\n else self.generation_config.return_dict_in_generate\\n )\\n\\n # init attention / hidden states / scores tuples\\n scores = () if (return_dict_in_generate and output_scores) else None\\n decoder_attentions = () if (return_dict_in_generate and output_attentions) else None\\n cross_attentions = () if (return_dict_in_generate and output_attentions) else None\\n decoder_hidden_states = () if (return_dict_in_generate and output_hidden_states) else None\\n\\n # if model is an encoder-decoder, retrieve encoder attention weights and hidden states\\n if return_dict_in_generate and self.config.is_encoder_decoder:\\n encoder_attentions = model_kwargs[\\\"encoder_outputs\\\"].get(\\\"attentions\\\") if output_attentions else None\\n encoder_hidden_states = (\\n model_kwargs[\\\"encoder_outputs\\\"].get(\\\"hidden_states\\\") if output_hidden_states else None\\n )\\n\\n decoding_kwargs = model_kwargs['decoding_kwargs']\\n decoding_kwargs.update({\\n 'eos': eos_token_id[0] if eos_token_id is not None else 2,\\n 'edls': [],\\n 'dls': [],\\n 'fts': []\\n })\\n\\n decoding_length = decoding_kwargs.get('decoding_length', 64)\\n stop_max_length = stopping_criteria.max_length\\n decoding_max_length = stop_max_length + decoding_length + 1\\n attention_mask = model_kwargs.get('attention_mask', None)\\n input_device = input_ids.device\\n if attention_mask is None:\\n bs = input_ids.size(0)\\n full_attention_mask = torch.tril(\\n torch.ones((bs, 1, decoding_max_length, decoding_max_length), dtype=torch.long, device=input_device),\\n 0)\\n elif len(attention_mask.shape) == 2:\\n # from [bs, src_len] to [bs,1,max_len,max_len]\\n bs, src_len = attention_mask.shape\\n pad_len = decoding_max_length - src_len\\n attention_mask = attention_mask.long()\\n if pad_len > 0:\\n pad_mask = torch.ones((bs, pad_len), dtype=torch.long, device=attention_mask.device)\\n attention_mask = torch.cat([attention_mask, pad_mask], 1)\\n full_attention_mask = torch.tril(attention_mask[:, None, None].expand(-1, -1, decoding_max_length, -1), 0)\\n elif len(attention_mask.shape) == 4:\\n bs, _, src_len, tgt_len = attention_mask.shape\\n attention_mask = attention_mask.long()\\n if src_len < decoding_max_length or tgt_len < decoding_max_length:\\n full_attention_mask = torch.tril(\\n torch.ones((bs, 1, decoding_max_length, decoding_max_length), dtype=torch.long,\\n device=input_device),\\n 0)\\n full_attention_mask[:, :, :src_len, :tgt_len] = attention_mask\\n else:\\n full_attention_mask = attention_mask\\n else:\\n raise ValueError(f'unsupport attention_mask.shape:{attention_mask.shape}')\\n model_kwargs['attention_mask'] = full_attention_mask\\n decoding_kwargs['max_length'] = stop_max_length\\n decoding_kwargs['decoding_max_length'] = decoding_max_length\\n\\n # keep track of which sequences are already finished\\n unfinished_sequences = torch.ones(input_ids.shape[0], dtype=torch.long, device=input_ids.device)\\n\\n assert input_ids.size(0) == 1\\n input_id_list = input_ids[0].tolist()\\n decoding_kwargs['input_id_list'] = [input_id_list]\\n branch_length = decoding_kwargs.get('branch_length', 12)\\n self.lookahead_cache.put(input_id_list[1:], branch_length=branch_length + 1, mode='input', idx=0)\\n ts = time.time()\\n\\n this_peer_finished = False # used by synced_gpus only\\n while True:\\n if synced_gpus:\\n # Under synced_gpus the `forward` call must continue until all gpus complete their sequence.\\n # The following logic allows an early break if all peers finished generating their sequence\\n this_peer_finished_flag = torch.tensor(0.0 if this_peer_finished else 1.0).to(input_ids.device)\\n # send 0.0 if we finished, 1.0 otherwise\\n dist.all_reduce(this_peer_finished_flag, op=dist.ReduceOp.SUM)\\n # did all peers finish? the reduced sum will be 0.0 then\\n if this_peer_finished_flag.item() == 0.0:\\n break\\n\\n # prepare model inputs\\n model_inputs = self.lookahead_prepare_inputs_for_generation(input_ids, **model_kwargs)\\n decoding_kwargs = model_inputs.pop('decoding_kwargs', {})\\n\\n # forward pass to get next token\\n outputs = self(\\n **model_inputs,\\n return_dict=True,\\n output_attentions=output_attentions,\\n output_hidden_states=output_hidden_states,\\n )\\n\\n if synced_gpus and this_peer_finished:\\n continue # don't waste resources running the code we don't need\\n\\n model_kwargs['decoding_kwargs'] = decoding_kwargs\\n model_kwargs = self._lookahead_update_model_kwargs_for_generation(\\n outputs,\\n model_kwargs,\\n is_encoder_decoder=self.config.is_encoder_decoder,\\n input_ids=input_ids,\\n logits_processor=logits_processor\\n )\\n\\n next_tokens = model_kwargs['next_tokens']\\n next_tokens_scores = model_kwargs['next_tokens_scores']\\n next_token_list = model_kwargs['next_token_list']\\n\\n # finished sentences should have their next token be a padding token\\n if eos_token_id is not None:\\n if pad_token_id is None:\\n raise ValueError(\\\"If `eos_token_id` is defined, make sure that `pad_token_id` is defined.\\\")\\n next_tokens = next_tokens * unfinished_sequences + pad_token_id * (1 - unfinished_sequences)\\n\\n # update generated ids, model inputs, and length for next step\\n input_ids = torch.cat([input_ids, next_tokens], dim=-1)\\n if streamer is not None:\\n streamer.put(next_token_list)\\n\\n self.lookahead_cache.stream_put(next_token_list[0], branch_length=branch_length + 1, final=False,\\n mode='output', idx=0)\\n\\n # Store scores, attentions and hidden_states when required\\n if return_dict_in_generate:\\n if output_scores:\\n scores += (next_tokens_scores,)\\n if output_attentions:\\n decoder_attentions += (\\n (outputs.decoder_attentions,) if self.config.is_encoder_decoder else (outputs.attentions,)\\n )\\n if self.config.is_encoder_decoder:\\n cross_attentions += (outputs.cross_attentions,)\\n\\n if output_hidden_states:\\n decoder_hidden_states += (\\n (outputs.decoder_hidden_states,)\\n if self.config.is_encoder_decoder\\n else (outputs.hidden_states,)\\n )\\n\\n # if eos_token was found in one sentence, set sentence to finished\\n if eos_token_id_tensor is not None:\\n # unfinished_sequences = unfinished_sequences.mul(\\n # next_tokens.tile(eos_token_id_tensor.shape[0], 1).ne(eos_token_id_tensor.unsqueeze(1)).prod(dim=0)\\n # )\\n unfinished_sequences = unfinished_sequences.mul(\\n next_tokens[:, :, None].ne(eos_token_id_tensor).prod(dim=2).prod(dim=1))\\n\\n # stop when each sentence is finished\\n if unfinished_sequences.max() == 0:\\n this_peer_finished = True\\n\\n # stop if we exceed the maximum length\\n if stopping_criteria(input_ids, scores):\\n this_peer_finished = True\\n\\n te = time.time()\\n model_kwargs['decoding_kwargs']['fts'].append(te - ts)\\n ts = te\\n if this_peer_finished and not synced_gpus:\\n self.lookahead_cache.stream_put([], branch_length=branch_length + 1, final=True,\\n mode='output', idx=0)\\n break\\n\\n if streamer is not None:\\n streamer.end()\\n\\n if return_dict_in_generate:\\n if self.config.is_encoder_decoder:\\n return GreedySearchEncoderDecoderOutput(\\n sequences=input_ids,\\n scores=scores,\\n encoder_attentions=encoder_attentions,\\n encoder_hidden_states=encoder_hidden_states,\\n decoder_attentions=decoder_attentions,\\n cross_attentions=cross_attentions,\\n decoder_hidden_states=decoder_hidden_states,\\n )\\n else:\\n kwargs = {'dls': model_kwargs['decoding_kwargs']['dls'],\\n 'edls': model_kwargs['decoding_kwargs']['edls'],\\n 'fts': model_kwargs['decoding_kwargs']['fts']}\\n return LookaheadDecoderOnlyOutput(\\n sequences=input_ids,\\n scores=scores,\\n attentions=decoder_attentions,\\n hidden_states=decoder_hidden_states,\\n kwargs=kwargs\\n )\\n else:\\n return input_ids\\n\\n def _validate_model_kwargs(self, model_kwargs: Dict[str, Any]):\\n \\\"\\\"\\\"Validates model kwargs for generation. Generate argument typos will also be caught here.\\\"\\\"\\\"\\n # Excludes arguments that are handled before calling any model function\\n if self.config.is_encoder_decoder:\\n for key in [\\\"decoder_input_ids\\\"]:\\n model_kwargs.pop(key, None)\\n\\n unused_model_args = []\\n model_args = set(inspect.signature(self.prepare_inputs_for_generation).parameters)\\n # `kwargs`/`model_kwargs` is often used to handle optional forward pass inputs like `attention_mask`. If\\n # `prepare_inputs_for_generation` doesn't accept them, then a stricter check can be made ;)\\n if \\\"kwargs\\\" in model_args or \\\"model_kwargs\\\" in model_args:\\n model_args |= set(inspect.signature(self.forward).parameters)\\n\\n # Encoder-Decoder models may also need Encoder arguments from `model_kwargs`\\n if self.config.is_encoder_decoder:\\n base_model = getattr(self, self.base_model_prefix, None)\\n\\n # allow encoder kwargs\\n encoder = getattr(self, \\\"encoder\\\", None)\\n # `MusicgenForConditionalGeneration` has `text_encoder` and `audio_encoder`.\\n # Also, it has `base_model_prefix = \\\"encoder_decoder\\\"` but there is no `self.encoder_decoder`\\n # TODO: A better way to handle this.\\n if encoder is None and base_model is not None:\\n encoder = getattr(base_model, \\\"encoder\\\", None)\\n\\n if encoder is not None:\\n encoder_model_args = set(inspect.signature(encoder.forward).parameters)\\n model_args |= encoder_model_args\\n\\n # allow decoder kwargs\\n decoder = getattr(self, \\\"decoder\\\", None)\\n if decoder is None and base_model is not None:\\n decoder = getattr(base_model, \\\"decoder\\\", None)\\n\\n if decoder is not None:\\n decoder_model_args = set(inspect.signature(decoder.forward).parameters)\\n model_args |= {f\\\"decoder_{x}\\\" for x in decoder_model_args}\\n\\n decoding_kwargs = ['decoding_kwargs','stop_words_ids']\\n for key, value in model_kwargs.items():\\n if value is not None and key not in model_args and key not in decoding_kwargs:\\n unused_model_args.append(key)\\n\\n if unused_model_args:\\n raise ValueError(\\n f\\\"The following `model_kwargs` are not used by the model: {unused_model_args} (note: typos in the\\\"\\n \\\" generate arguments will also show up in this list)\\\"\\n )\"\n },\n {\n \"identifier\": \"QWenConfig\",\n \"path\": \"pia/lookahead/models/qwen/configuration_qwen.py\",\n \"snippet\": \"class QWenConfig(PretrainedConfig):\\n model_type = \\\"qwen\\\"\\n keys_to_ignore_at_inference = [\\\"past_key_values\\\"]\\n\\n def __init__(\\n self,\\n vocab_size=151936,\\n hidden_size=4096,\\n num_hidden_layers=32,\\n num_attention_heads=32,\\n emb_dropout_prob=0.0,\\n attn_dropout_prob=0.0,\\n layer_norm_epsilon=1e-6,\\n initializer_range=0.02,\\n max_position_embeddings=8192,\\n scale_attn_weights=True,\\n use_cache=True,\\n bf16=False,\\n fp16=False,\\n fp32=False,\\n kv_channels=128,\\n rotary_pct=1.0,\\n rotary_emb_base=10000,\\n use_dynamic_ntk=True,\\n use_logn_attn=True,\\n use_flash_attn=\\\"auto\\\",\\n intermediate_size=22016,\\n no_bias=True,\\n tie_word_embeddings=False,\\n **kwargs,\\n ):\\n self.vocab_size = vocab_size\\n self.hidden_size = hidden_size\\n self.intermediate_size = intermediate_size\\n self.num_hidden_layers = num_hidden_layers\\n self.num_attention_heads = num_attention_heads\\n self.emb_dropout_prob = emb_dropout_prob\\n self.attn_dropout_prob = attn_dropout_prob\\n self.layer_norm_epsilon = layer_norm_epsilon\\n self.initializer_range = initializer_range\\n self.scale_attn_weights = scale_attn_weights\\n self.use_cache = use_cache\\n self.max_position_embeddings = max_position_embeddings\\n self.bf16 = bf16\\n self.fp16 = fp16\\n self.fp32 = fp32\\n self.kv_channels = kv_channels\\n self.rotary_pct = rotary_pct\\n self.rotary_emb_base = rotary_emb_base\\n self.use_dynamic_ntk = use_dynamic_ntk\\n self.use_logn_attn = use_logn_attn\\n self.use_flash_attn = use_flash_attn\\n self.no_bias = no_bias\\n super().__init__(\\n tie_word_embeddings=tie_word_embeddings,\\n **kwargs\\n )\"\n },\n {\n \"identifier\": \"HistoryType\",\n \"path\": \"pia/lookahead/models/qwen/qwen_generation_utils.py\",\n \"snippet\": \"def pad_batch(batch: BatchTokensType, pad_id: int, seq_length: int) -> BatchTokensType:\\ndef get_ltor_masks_and_position_ids(\\n data,\\n eod_token,\\n reset_position_ids,\\n reset_attention_mask,\\n eod_mask_loss,\\n):\\ndef get_batch(context_tokens: torch.LongTensor, eod_id: int):\\ndef get_stop_words_ids(chat_format, tokenizer):\\ndef make_context(\\n tokenizer: PreTrainedTokenizer,\\n query: str,\\n history: List[Tuple[str, str]] = None,\\n system: str = \\\"\\\",\\n max_window_size: int = 6144,\\n chat_format: str = \\\"chatml\\\",\\n):\\n def _tokenize_str(role, content):\\ndef _decode_default(\\n tokens: List[int],\\n *,\\n stop_words: List[str],\\n eod_words: List[str],\\n tokenizer: PreTrainedTokenizer,\\n raw_text_len: int,\\n verbose: bool = False,\\n return_end_reason: bool = False,\\n errors: str = 'replace',\\n):\\ndef _decode_chatml(\\n tokens: List[int],\\n *,\\n stop_words: List[str],\\n eod_token_ids: List[int],\\n tokenizer: PreTrainedTokenizer,\\n raw_text_len: int,\\n context_length: int,\\n verbose: bool = False,\\n return_end_reason: bool = False,\\n errors: str = 'replace'\\n):\\ndef decode_tokens(\\n tokens: Union[torch.LongTensor, TokensType],\\n tokenizer: PreTrainedTokenizer,\\n raw_text_len: int,\\n context_length: int,\\n chat_format: str,\\n verbose: bool = False,\\n return_end_reason: bool = False,\\n errors: str = \\\"replace\\\",\\n) -> str:\\n def __init__(self, stop_words_ids: Iterable[Iterable[int]], eos_token_id: int):\\n def __call__(\\n self, input_ids: torch.LongTensor, scores: torch.FloatTensor\\n ) -> torch.FloatTensor:\\n def _tokens_match(self, prev_tokens: torch.LongTensor, tokens: List[int]) -> bool:\\n def _calc_stopped_samples(self, prev_input_ids: Iterable[int]) -> Iterable[int]:\\ndef top_k_logits(logits, top_k=0, top_p=0.0, filter_value=-float(\\\"Inf\\\")):\\ndef switch(val1, val2, boolean):\\nclass StopWordsLogitsProcessor(LogitsProcessor):\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import importlib\nimport math\nimport torch\nimport torch.nn.functional as F\nimport torch.utils.checkpoint\n import flash_attn\nfrom typing import TYPE_CHECKING, Optional, Tuple, Union, List, Any, Generator\nfrom torch.cuda.amp import autocast\nfrom torch.nn import CrossEntropyLoss\nfrom transformers import PreTrainedTokenizer, GenerationConfig\nfrom transformers.generation.logits_process import LogitsProcessorList\nfrom transformers.modeling_outputs import (\n BaseModelOutputWithPast,\n CausalLMOutputWithPast,\n)\nfrom pia.lookahead.common.pretrained_model import LookaheadPreTrainedModel\nfrom transformers.utils import logging\n from einops import rearrange\nfrom torch import nn\nfrom .configuration_qwen import QWenConfig\nfrom .qwen_generation_utils import (\n HistoryType,\n make_context,\n decode_tokens,\n get_stop_words_ids,\n StopWordsLogitsProcessor,\n)\n from flash_attn.layers.rotary import apply_rotary_emb_func as __apply_rotary_emb_func\n from flash_attn.ops.rms_norm import rms_norm as __rms_norm\n from flash_attn.flash_attn_interface import flash_attn_unpadded_func as __flash_attn_unpadded_func\n from flash_attn.flash_attn_interface import flash_attn_varlen_func as __flash_attn_unpadded_func\n from flash_attn.flash_attn_interface import flash_attn_unpadded_func as __flash_attn_unpadded_func\n from transformers_stream_generator.main import NewGenerationMixin, StreamGenerationConfig\n from einops import rearrange\n from einops import rearrange"},"token_num":{"kind":"number","value":17805,"string":"17,805"},"cropped_code":{"kind":"string","value":" position_ids = position_ids[:, -1].unsqueeze(-1)\n else:\n position_ids = None\n\n if inputs_embeds is not None and past_key_values is None:\n model_inputs = {\"inputs_embeds\": inputs_embeds}\n else:\n model_inputs = {\"input_ids\": input_ids}\n\n model_inputs.update(\n {\n \"past_key_values\": past_key_values,\n \"use_cache\": kwargs.get(\"use_cache\"),\n \"position_ids\": position_ids,\n \"attention_mask\": attention_mask,\n \"token_type_ids\": token_type_ids,\n }\n )\n return model_inputs\n\n def forward(\n self,\n input_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n token_type_ids: Optional[torch.LongTensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n head_mask: Optional[torch.FloatTensor] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.Tensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n labels: Optional[torch.LongTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n ) -> Union[Tuple, CausalLMOutputWithPast]:\n\n return_dict = (\n return_dict if return_dict is not None else self.config.use_return_dict\n )\n\n transformer_outputs = self.transformer(\n input_ids,\n past_key_values=past_key_values,\n attention_mask=attention_mask,\n token_type_ids=token_type_ids,\n position_ids=position_ids,\n head_mask=head_mask,\n inputs_embeds=inputs_embeds,\n encoder_hidden_states=encoder_hidden_states,\n encoder_attention_mask=encoder_attention_mask,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n )\n hidden_states = transformer_outputs[0]\n\n lm_logits = self.lm_head(hidden_states)\n\n loss = None\n if labels is not None:\n labels = labels.to(lm_logits.device)\n shift_logits = lm_logits[..., :-1, :].contiguous()\n shift_labels = labels[..., 1:].contiguous()\n loss_fct = CrossEntropyLoss()\n loss = loss_fct(\n shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)\n )\n\n if not return_dict:\n output = (lm_logits,) + transformer_outputs[1:]\n return ((loss,) + output) if loss is not None else output\n\n return CausalLMOutputWithPast(\n loss=loss,\n logits=lm_logits,\n past_key_values=transformer_outputs.past_key_values,\n hidden_states=transformer_outputs.hidden_states,\n attentions=transformer_outputs.attentions,\n )\n\n @staticmethod\n def _reorder_cache(\n past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor\n ) -> Tuple[Tuple[torch.Tensor]]:\n\n return tuple(\n tuple(\n past_state.index_select(0, beam_idx.to(past_state.device))\n for past_state in layer_past\n )\n for layer_past in past_key_values\n )\n\n def chat(\n self,\n tokenizer: PreTrainedTokenizer,\n query: str,\n history: Optional[HistoryType],\n system: str = \"You are a helpful assistant.\",\n append_history: bool = True,\n stream: Optional[bool] = _SENTINEL,\n stop_words_ids: Optional[List[List[int]]] = None,\n generation_config: Optional[GenerationConfig] = None,\n **kwargs,\n ) -> Tuple[str, HistoryType]:\n generation_config = generation_config if generation_config is not None else self.generation_config\n\n assert stream is _SENTINEL, _ERROR_STREAM_IN_CHAT\n assert generation_config.chat_format == 'chatml', _ERROR_BAD_CHAT_FORMAT\n if history is None:\n history = []\n if stop_words_ids is None:\n stop_words_ids = []\n\n max_window_size = kwargs.get('max_window_size', None)\n if max_window_size is None:\n max_window_size = generation_config.max_window_size\n"},"all_code":{"kind":"string","value":"# Copyright (c) Alibaba Cloud.\n#\n# This source code is licensed under the license found in the\n# LICENSE file in the root directory of this source tree.\n\n\n\nif TYPE_CHECKING:\n pass\n# from transformers.modeling_utils import PreTrainedModel\n\ntry:\nexcept ImportError:\n rearrange = None\n\nSUPPORT_CUDA = torch.cuda.is_available()\nSUPPORT_BF16 = SUPPORT_CUDA and torch.cuda.is_bf16_supported()\nSUPPORT_FP16 = SUPPORT_CUDA and torch.cuda.get_device_capability(0)[0] >= 7\n\n\nlogger = logging.get_logger(__name__)\n\n_CHECKPOINT_FOR_DOC = \"qwen\"\n_CONFIG_FOR_DOC = \"QWenConfig\"\n\nQWen_PRETRAINED_MODEL_ARCHIVE_LIST = [\"qwen-7b\"]\n\n_ERROR_BAD_CHAT_FORMAT = \"\"\"\\\nWe detect you are probably using the pretrained model (rather than chat model) for chatting, since the chat_format in generation_config is not \"chatml\".\nIf you are directly using the model downloaded from Huggingface, please make sure you are using our \"Qwen/Qwen-7B-Chat\" Huggingface model (rather than \"Qwen/Qwen-7B\") when you call model.chat().\n我们检测到您可能在使用预训练模型（而非chat模型）进行多轮chat，因为您当前在generation_config指定的chat_format，并未设置为我们在对话中所支持的\"chatml\"格式。\n如果您在直接使用我们从Huggingface提供的模型，请确保您在调用model.chat()时，使用的是\"Qwen/Qwen-7B-Chat\"模型（而非\"Qwen/Qwen-7B\"预训练模型）。\n\"\"\"\n\n_SENTINEL = object()\n_ERROR_STREAM_IN_CHAT = \"\"\"\\\nPass argument `stream` to model.chat() is buggy, deprecated, and marked for removal. Please use model.chat_stream(...) instead of model.chat(..., stream=True).\n向model.chat()传入参数stream的用法可能存在Bug，该用法已被废弃，将在未来被移除。请使用model.chat_stream(...)代替model.chat(..., stream=True)。\n\"\"\"\n\n_ERROR_INPUT_CPU_QUERY_WITH_FLASH_ATTN_ACTIVATED = \"\"\"\\\nWe detect you have activated flash attention support, but running model computation on CPU. Please make sure that your input data has been placed on GPU. If you actually want to run CPU computation, please following the readme and set device_map=\"cpu\" to disable flash attention when loading the model (calling AutoModelForCausalLM.from_pretrained).\n检测到您的模型已激活了flash attention支持，但正在执行CPU运算任务。如使用flash attention，请您确认模型输入已经传到GPU上。如果您确认要执行CPU运算，请您在载入模型（调用AutoModelForCausalLM.from_pretrained）时，按照readme说法，指定device_map=\"cpu\"以禁用flash attention。\n\"\"\"\n\napply_rotary_emb_func = None\nrms_norm = None\nflash_attn_unpadded_func = None\n\n\ndef _import_flash_attn():\n global apply_rotary_emb_func, rms_norm, flash_attn_unpadded_func\n try:\n apply_rotary_emb_func = __apply_rotary_emb_func\n except ImportError:\n logger.warn(\n \"Warning: import flash_attn rotary fail, please install FlashAttention rotary to get higher efficiency \"\n \"https://github.com/Dao-AILab/flash-attention/tree/main/csrc/rotary\"\n )\n\n try:\n rms_norm = __rms_norm\n except ImportError:\n logger.warn(\n \"Warning: import flash_attn rms_norm fail, please install FlashAttention layer_norm to get higher efficiency \"\n \"https://github.com/Dao-AILab/flash-attention/tree/main/csrc/layer_norm\"\n )\n\n try:\n if not hasattr(flash_attn, '__version__'):\n else:\n if int(flash_attn.__version__.split(\".\")[0]) >= 2:\n else:\n flash_attn_unpadded_func = __flash_attn_unpadded_func\n except ImportError:\n logger.warn(\n \"Warning: import flash_attn fail, please install FlashAttention to get higher efficiency \"\n \"https://github.com/Dao-AILab/flash-attention\"\n )\n\n\nclass FlashSelfAttention(torch.nn.Module):\n def __init__(\n self,\n causal=False,\n softmax_scale=None,\n attention_dropout=0.0,\n ):\n super().__init__()\n assert flash_attn_unpadded_func is not None, (\n \"Please install FlashAttention first, \" \"e.g., with pip install flash-attn\"\n )\n assert (\n rearrange is not None\n ), \"Please install einops first, e.g., with pip install einops\"\n self.causal = causal\n self.softmax_scale = softmax_scale\n self.dropout_p = attention_dropout\n\n def forward(self, q, k, v):\n assert all((i.dtype in [torch.float16, torch.bfloat16] for i in (q, k, v)))\n assert all((i.is_cuda for i in (q, k, v)))\n batch_size, seqlen_q = q.shape[0], q.shape[1]\n seqlen_k = k.shape[1]\n\n q, k, v = [rearrange(x, \"b s ... -> (b s) ...\") for x in [q, k, v]]\n cu_seqlens_q = torch.arange(\n 0,\n (batch_size + 1) * seqlen_q,\n step=seqlen_q,\n dtype=torch.int32,\n device=q.device,\n )\n\n if self.training:\n assert seqlen_k == seqlen_q\n\n is_causal = self.causal\n cu_seqlens_k = cu_seqlens_q\n else:\n is_causal = seqlen_q == seqlen_k\n cu_seqlens_k = torch.arange(\n 0,\n (batch_size + 1) * seqlen_k,\n step=seqlen_k,\n dtype=torch.int32,\n device=q.device,\n )\n self.dropout_p = 0\n\n output = flash_attn_unpadded_func(\n q,\n k,\n v,\n cu_seqlens_q,\n cu_seqlens_k,\n seqlen_q,\n seqlen_k,\n self.dropout_p,\n softmax_scale=self.softmax_scale,\n causal=is_causal,\n )\n\n new_shape = (batch_size, output.shape[0] // batch_size) + output.shape[1:]\n output = output.view(new_shape)\n return output\n\n\nclass QWenAttention(nn.Module):\n def __init__(self, config):\n super().__init__()\n\n self.register_buffer(\"masked_bias\", torch.tensor(-1e4), persistent=False)\n self.seq_length = config.seq_length\n\n self.hidden_size = config.hidden_size\n self.split_size = config.hidden_size\n self.num_heads = config.num_attention_heads\n self.head_dim = self.hidden_size // self.num_heads\n\n # self.use_flash_attn = config.use_flash_attn\n self.use_flash_attn = False\n self.scale_attn_weights = True\n\n self.projection_size = config.kv_channels * config.num_attention_heads\n\n assert self.projection_size % config.num_attention_heads == 0\n self.hidden_size_per_attention_head = (\n self.projection_size // config.num_attention_heads\n )\n\n self.c_attn = nn.Linear(config.hidden_size, 3 * self.projection_size)\n\n self.c_proj = nn.Linear(\n config.hidden_size, self.projection_size, bias=not config.no_bias\n )\n\n self.is_fp32 = not (config.bf16 or config.fp16)\n if (\n self.use_flash_attn\n and flash_attn_unpadded_func is not None\n and not self.is_fp32\n ):\n self.core_attention_flash = FlashSelfAttention(\n causal=True, attention_dropout=config.attn_dropout_prob\n )\n self.bf16 = config.bf16\n\n self.use_dynamic_ntk = config.use_dynamic_ntk\n self.use_logn_attn = config.use_logn_attn\n\n logn_list = [\n math.log(i, self.seq_length) if i > self.seq_length else 1\n for i in range(1, 32768)\n ]\n self.logn_tensor = torch.tensor(logn_list)[None, :, None, None]\n\n self.attn_dropout = nn.Dropout(config.attn_dropout_prob)\n\n def _attn(self, query, key, value, registered_causal_mask, attention_mask=None, head_mask=None):\n attn_weights = torch.matmul(query, key.transpose(-1, -2))\n\n if self.scale_attn_weights:\n attn_weights = attn_weights / torch.full(\n [],\n value.size(-1) ** 0.5,\n dtype=attn_weights.dtype,\n device=attn_weights.device,\n )\n\n query_length, key_length = query.size(-2), key.size(-2)\n causal_mask = registered_causal_mask[\n :, :, key_length - query_length: key_length, :key_length\n ]\n mask_value = torch.finfo(attn_weights.dtype).min\n mask_value = torch.full([], mask_value, dtype=attn_weights.dtype).to(\n attn_weights.device\n )\n attn_weights = torch.where(\n causal_mask, attn_weights.to(attn_weights.dtype), mask_value\n )\n\n attn_weights = nn.functional.softmax(attn_weights, dim=-1)\n\n attn_weights = attn_weights.type(value.dtype)\n attn_weights = self.attn_dropout(attn_weights)\n\n if head_mask is not None:\n attn_weights = attn_weights * head_mask\n\n attn_output = torch.matmul(attn_weights, value)\n attn_output = attn_output.transpose(1, 2)\n\n return attn_output, attn_weights\n\n def _upcast_and_reordered_attn(\n self, query, key, value, registered_causal_mask, attention_mask=None, head_mask=None\n ):\n bsz, num_heads, q_seq_len, dk = query.size()\n _, _, k_seq_len, _ = key.size()\n\n attn_weights = torch.empty(\n bsz * num_heads,\n q_seq_len,\n k_seq_len,\n dtype=torch.float32,\n device=query.device,\n )\n\n scale_factor = 1.0\n if self.scale_attn_weights:\n scale_factor /= float(value.size(-1)) ** 0.5\n\n with autocast(enabled=False):\n q, k = query.reshape(-1, q_seq_len, dk), key.transpose(-1, -2).reshape(\n -1, dk, k_seq_len\n )\n attn_weights = torch.baddbmm(\n attn_weights, q.float(), k.float(), beta=0, alpha=scale_factor\n )\n attn_weights = attn_weights.reshape(bsz, num_heads, q_seq_len, k_seq_len)\n\n query_length, key_length = query.size(-2), key.size(-2)\n causal_mask = registered_causal_mask[\n :, :, key_length - query_length: key_length, :key_length\n ]\n mask_value = torch.finfo(attn_weights.dtype).min\n mask_value = torch.tensor(mask_value, dtype=attn_weights.dtype).to(\n attn_weights.device\n )\n attn_weights = torch.where(causal_mask, attn_weights, mask_value)\n\n if attention_mask is not None:\n attn_weights = attn_weights + attention_mask\n\n attn_weights = nn.functional.softmax(attn_weights, dim=-1)\n\n if attn_weights.dtype != torch.float32:\n raise RuntimeError(\n \"Error with upcasting, attn_weights does not have dtype torch.float32\"\n )\n attn_weights = attn_weights.type(value.dtype)\n attn_weights = self.attn_dropout(attn_weights)\n\n if head_mask is not None:\n attn_weights = attn_weights * head_mask\n\n attn_output = torch.matmul(attn_weights, value)\n\n return attn_output, attn_weights\n\n def _split_heads(self, tensor, num_heads, attn_head_size):\n new_shape = tensor.size()[:-1] + (num_heads, attn_head_size)\n tensor = tensor.view(new_shape)\n return tensor\n\n def _merge_heads(self, tensor, num_heads, attn_head_size):\n tensor = tensor.contiguous()\n new_shape = tensor.size()[:-2] + (num_heads * attn_head_size,)\n return tensor.view(new_shape)\n\n def forward(\n self,\n hidden_states: Optional[Tuple[torch.FloatTensor]],\n rotary_pos_emb: Optional[List[torch.Tensor]] = None,\n registered_causal_mask: Optional[torch.Tensor] = None,\n layer_past: Optional[Tuple[torch.Tensor]] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n head_mask: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.Tensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n output_attentions: Optional[bool] = False,\n use_cache: Optional[bool] = False,\n ):\n\n mixed_x_layer = self.c_attn(hidden_states)\n\n query, key, value = mixed_x_layer.split(self.split_size, dim=2)\n\n query = self._split_heads(query, self.num_heads, self.head_dim)\n key = self._split_heads(key, self.num_heads, self.head_dim)\n value = self._split_heads(value, self.num_heads, self.head_dim)\n\n if rotary_pos_emb is not None:\n cur_len = query.shape[1]\n rotary_pos_emb = [i[:, -cur_len:, :, :] for i in rotary_pos_emb]\n rotary_pos_emb = (rotary_pos_emb,) * 2\n q_pos_emb, k_pos_emb = rotary_pos_emb\n # Slice the pos emb for current inference\n query = apply_rotary_pos_emb(query, q_pos_emb)\n key = apply_rotary_pos_emb(key, k_pos_emb)\n\n if layer_past is not None:\n past_key, past_value = layer_past[0], layer_past[1]\n key = torch.cat((past_key, key), dim=1)\n value = torch.cat((past_value, value), dim=1)\n\n if use_cache:\n present = (key, value)\n else:\n present = None\n\n if self.use_logn_attn and not self.training:\n if self.logn_tensor.device != query.device or self.logn_tensor.dtype != query.dtype:\n self.logn_tensor = self.logn_tensor.to(query.device).type_as(query)\n seq_start = key.size(1) - query.size(1)\n seq_end = key.size(1)\n logn_tensor = self.logn_tensor[:, seq_start:seq_end, :, :]\n query = query * logn_tensor.expand_as(query)\n\n if (\n self.use_flash_attn\n and flash_attn_unpadded_func is not None\n and not self.is_fp32\n and query.is_cuda\n ):\n q, k, v = query, key, value\n context_layer = self.core_attention_flash(q, k, v)\n\n # b s h d -> b s (h d)\n context_layer = context_layer.flatten(2, 3).contiguous()\n\n else:\n query = query.permute(0, 2, 1, 3)\n key = key.permute(0, 2, 1, 3)\n value = value.permute(0, 2, 1, 3)\n if (\n registered_causal_mask is None\n and self.use_flash_attn\n and flash_attn_unpadded_func is not None\n and not self.is_fp32\n and not query.is_cuda\n ):\n raise Exception(_ERROR_INPUT_CPU_QUERY_WITH_FLASH_ATTN_ACTIVATED)\n attn_output, attn_weight = self._attn(\n query, key, value, registered_causal_mask, attention_mask, head_mask\n )\n context_layer = self._merge_heads(\n attn_output, self.num_heads, self.head_dim\n )\n\n attn_output = self.c_proj(context_layer)\n\n outputs = (attn_output, present)\n if output_attentions:\n if (\n self.use_flash_attn\n and flash_attn_unpadded_func is not None\n and not self.is_fp32\n ):\n raise ValueError(\"Cannot output attentions while using flash-attn\")\n else:\n outputs += (attn_weight,)\n\n return outputs\n\n\nclass QWenMLP(nn.Module):\n def __init__(self, config):\n super().__init__()\n self.w1 = nn.Linear(\n config.hidden_size, config.intermediate_size // 2, bias=not config.no_bias\n )\n self.w2 = nn.Linear(\n config.hidden_size, config.intermediate_size // 2, bias=not config.no_bias\n )\n ff_dim_in = config.intermediate_size // 2\n self.c_proj = nn.Linear(ff_dim_in, config.hidden_size, bias=not config.no_bias)\n\n def forward(self, hidden_states):\n a1 = self.w1(hidden_states)\n a2 = self.w2(hidden_states)\n intermediate_parallel = a1 * F.silu(a2)\n output = self.c_proj(intermediate_parallel)\n return output\n\n\nclass QWenBlock(nn.Module):\n def __init__(self, config):\n super().__init__()\n hidden_size = config.hidden_size\n self.bf16 = config.bf16\n\n self.ln_1 = RMSNorm(\n hidden_size,\n eps=config.layer_norm_epsilon,\n )\n self.attn = QWenAttention(config)\n self.ln_2 = RMSNorm(\n hidden_size,\n eps=config.layer_norm_epsilon,\n )\n\n self.mlp = QWenMLP(config)\n\n def forward(\n self,\n hidden_states: Optional[Tuple[torch.FloatTensor]],\n rotary_pos_emb: Optional[List[torch.Tensor]] = None,\n registered_causal_mask: Optional[torch.Tensor] = None,\n layer_past: Optional[Tuple[torch.Tensor]] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n head_mask: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.Tensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n use_cache: Optional[bool] = False,\n output_attentions: Optional[bool] = False,\n ):\n layernorm_output = self.ln_1(hidden_states)\n\n attn_outputs = self.attn(\n layernorm_output,\n rotary_pos_emb,\n registered_causal_mask=registered_causal_mask,\n layer_past=layer_past,\n attention_mask=attention_mask,\n head_mask=head_mask,\n use_cache=use_cache,\n output_attentions=output_attentions,\n )\n attn_output = attn_outputs[0]\n\n outputs = attn_outputs[1:]\n\n residual = hidden_states\n layernorm_input = attn_output + residual\n\n layernorm_output = self.ln_2(layernorm_input)\n\n residual = layernorm_input\n mlp_output = self.mlp(layernorm_output)\n hidden_states = residual + mlp_output\n\n if use_cache:\n outputs = (hidden_states,) + outputs\n else:\n outputs = (hidden_states,) + outputs[1:]\n\n return outputs\n\n\nclass QWenPreTrainedModel(LookaheadPreTrainedModel):\n config_class = QWenConfig\n base_model_prefix = \"transformer\"\n is_parallelizable = False\n supports_gradient_checkpointing = True\n _no_split_modules = [\"QWenBlock\"]\n\n def __init__(self, *inputs, **kwargs):\n super().__init__(*inputs, **kwargs)\n\n def _init_weights(self, module):\n \"\"\"Initialize the weights.\"\"\"\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)\n if module.bias is not None:\n module.bias.data.zero_()\n elif isinstance(module, nn.Embedding):\n module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)\n if module.padding_idx is not None:\n module.weight.data[module.padding_idx].zero_()\n elif isinstance(module, RMSNorm):\n module.weight.data.fill_(1.0)\n\n for name, p in module.named_parameters():\n if name == \"c_proj.weight\":\n p.data.normal_(\n mean=0.0,\n std=(\n self.config.initializer_range\n / math.sqrt(2 * self.config.num_hidden_layers)\n ),\n )\n\n def _set_gradient_checkpointing(self, module, value=False):\n if isinstance(module, QWenModel):\n module.gradient_checkpointing = value\n\n\nclass QWenModel(QWenPreTrainedModel):\n _keys_to_ignore_on_load_missing = [\"attn.masked_bias\"]\n\n def __init__(self, config):\n super().__init__(config)\n self.vocab_size = config.vocab_size\n self.num_hidden_layers = config.num_hidden_layers\n self.embed_dim = config.hidden_size\n\n self.gradient_checkpointing = False\n self.use_dynamic_ntk = config.use_dynamic_ntk\n self.seq_length = config.seq_length\n\n self.wte = nn.Embedding(self.vocab_size, self.embed_dim)\n\n self.drop = nn.Dropout(config.emb_dropout_prob)\n\n if config.rotary_pct == 1.0:\n self.rotary_ndims = None\n else:\n assert config.rotary_pct < 1\n self.rotary_ndims = int(\n config.kv_channels * config.rotary_pct\n )\n dim = (\n self.rotary_ndims\n if self.rotary_ndims is not None\n else config.kv_channels\n )\n self.rotary_emb = RotaryEmbedding(dim, base=config.rotary_emb_base)\n\n # self.use_flash_attn = config.use_flash_attn\n self.use_flash_attn = False\n self.is_fp32 = not (config.bf16 or config.fp16)\n if (\n self.use_flash_attn\n and flash_attn_unpadded_func is not None\n and not self.is_fp32\n ):\n self.registered_causal_mask = None\n else:\n max_positions = config.max_position_embeddings\n self.register_buffer(\n \"registered_causal_mask\",\n torch.tril(\n torch.ones((max_positions, max_positions), dtype=torch.bool)\n ).view(1, 1, max_positions, max_positions),\n persistent=False,\n )\n\n self.h = nn.ModuleList(\n [\n QWenBlock(\n config\n )\n for i in range(config.num_hidden_layers)\n ]\n )\n self.ln_f = RMSNorm(\n self.embed_dim,\n eps=config.layer_norm_epsilon,\n )\n\n self.post_init()\n\n def get_input_embeddings(self):\n return self.wte\n\n def set_input_embeddings(self, new_embeddings):\n self.wte = new_embeddings\n\n def forward(\n self,\n input_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n token_type_ids: Optional[torch.LongTensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n head_mask: Optional[torch.FloatTensor] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.Tensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n ):\n output_attentions = (\n output_attentions\n if output_attentions is not None\n else self.config.output_attentions\n )\n output_hidden_states = (\n output_hidden_states\n if output_hidden_states is not None\n else self.config.output_hidden_states\n )\n use_cache = use_cache if use_cache is not None else self.config.use_cache\n return_dict = (\n return_dict if return_dict is not None else self.config.use_return_dict\n )\n\n if input_ids is not None and inputs_embeds is not None:\n raise ValueError(\n \"You cannot specify both input_ids and inputs_embeds at the same time\"\n )\n elif input_ids is not None:\n input_shape = input_ids.size()\n # input_ids = input_ids.view(-1, input_shape[-1])\n batch_size, seq_length = input_ids.shape\n # batch_size = input_ids.shape[0]\n elif inputs_embeds is not None:\n input_shape = inputs_embeds.size()[:-1]\n batch_size = inputs_embeds.shape[0]\n else:\n raise ValueError(\"You have to specify either input_ids or inputs_embeds\")\n\n device = input_ids.device if input_ids is not None else inputs_embeds.device\n\n if token_type_ids is not None:\n token_type_ids = token_type_ids.view(-1, input_shape[-1])\n if position_ids is not None:\n position_ids = position_ids.view(-1, input_shape[-1])\n\n if past_key_values is None:\n past_length = 0\n past_key_values = tuple([None] * len(self.h))\n else:\n past_length = past_key_values[0][0].size(-2)\n\n if inputs_embeds is None:\n inputs_embeds = self.wte(input_ids)\n\n # NOTE: adapt for lookahead\n if attention_mask is not None and len(attention_mask.shape) == 4:\n # with lookahead\n position_ids = torch.sum(attention_mask, dim=-1).squeeze(1) - 1\n attention_mask = (1.0 - attention_mask.to(inputs_embeds.dtype)) * torch.finfo(inputs_embeds.dtype).min\n else:\n # without lookahead\n if position_ids is None:\n position_ids = torch.arange(\n past_length,\n input_shape[-1] + past_length,\n dtype=torch.long,\n device=device,\n )\n position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])\n\n if attention_mask is not None:\n if batch_size <= 0:\n raise ValueError(\"batch_size has to be defined and > 0\")\n attention_mask = attention_mask.view(batch_size, -1)\n attention_mask = attention_mask[:, None, None, :]\n attention_mask = attention_mask.to(dtype=self.dtype)\n attention_mask = (1.0 - attention_mask) * torch.finfo(self.dtype).min\n\n encoder_attention_mask = None\n head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)\n\n # if inputs_embeds is None:\n # inputs_embeds = self.wte(input_ids)\n hidden_states = inputs_embeds\n\n kv_seq_len = hidden_states.size()[1]\n if past_key_values[0] is not None:\n # past key values[0][0] shape: bs * seq_len * head_num * dim\n kv_seq_len += past_key_values[0][0].shape[1]\n if (\n self.use_dynamic_ntk\n and kv_seq_len == hidden_states.size()[1]\n and not self.training\n ):\n context_value = math.log(kv_seq_len / self.seq_length, 2) + 1\n ntk_alpha = 2 ** math.ceil(context_value) - 1\n ntk_alpha = max(ntk_alpha, 1)\n else:\n ntk_alpha = self.rotary_emb._ntk_alpha_cached\n\n rotary_pos_emb = self.rotary_emb(kv_seq_len, ntk_alpha=ntk_alpha)\n for idx in range(len(rotary_pos_emb)):\n rotary_pos_emb[idx] = rotary_pos_emb[idx].to(hidden_states.device)\n\n hidden_states = self.drop(hidden_states)\n output_shape = input_shape + (hidden_states.size(-1),)\n\n if self.gradient_checkpointing and self.training:\n if use_cache:\n logger.warning_once(\n \"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`...\"\n )\n use_cache = False\n\n presents = () if use_cache else None\n all_self_attentions = () if output_attentions else None\n all_hidden_states = () if output_hidden_states else None\n for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):\n\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n if self.gradient_checkpointing and self.training:\n\n def create_custom_forward(module):\n def custom_forward(*inputs):\n # None for past_key_value\n return module(*inputs, use_cache, output_attentions)\n\n return custom_forward\n\n outputs = torch.utils.checkpoint.checkpoint(\n create_custom_forward(block),\n hidden_states,\n rotary_pos_emb,\n self.registered_causal_mask,\n None,\n attention_mask,\n head_mask[i],\n encoder_hidden_states,\n encoder_attention_mask,\n )\n else:\n outputs = block(\n hidden_states,\n layer_past=layer_past,\n rotary_pos_emb=rotary_pos_emb,\n registered_causal_mask=self.registered_causal_mask,\n attention_mask=attention_mask,\n head_mask=head_mask[i],\n encoder_hidden_states=encoder_hidden_states,\n encoder_attention_mask=encoder_attention_mask,\n use_cache=use_cache,\n output_attentions=output_attentions,\n )\n\n hidden_states = outputs[0]\n if use_cache is True:\n presents = presents + (outputs[1],)\n\n if output_attentions:\n all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)\n\n hidden_states = self.ln_f(hidden_states)\n hidden_states = hidden_states.view(output_shape)\n # Add last hidden state\n if output_hidden_states:\n all_hidden_states = all_hidden_states + (hidden_states,)\n\n if not return_dict:\n return tuple(\n v for v in [hidden_states, presents, all_hidden_states] if v is not None\n )\n\n return BaseModelOutputWithPast(\n last_hidden_state=hidden_states,\n past_key_values=presents,\n hidden_states=all_hidden_states,\n attentions=all_self_attentions,\n )\n\n\nclass QWenLMHeadModel(QWenPreTrainedModel):\n _keys_to_ignore_on_load_missing = [r\"h\\.\\d+\\.attn\\.rotary_emb\\.inv_freq\"]\n _keys_to_ignore_on_load_unexpected = [r\"h\\.\\d+\\.attn\\.masked_bias\"]\n\n def __init__(self, config):\n super().__init__(config)\n assert (\n config.bf16 + config.fp16 + config.fp32 <= 1\n ), \"Only one of \\\"bf16\\\", \\\"fp16\\\", \\\"fp32\\\" can be true\"\n\n autoset_precision = config.bf16 + config.fp16 + config.fp32 == 0\n\n if autoset_precision:\n if SUPPORT_BF16:\n logger.warn(\n \"The model is automatically converting to bf16 for faster inference. \"\n \"If you want to disable the automatic precision, please manually add bf16/fp16/fp32=True to \\\"AutoModelForCausalLM.from_pretrained\\\".\"\n )\n config.bf16 = True\n elif SUPPORT_FP16:\n logger.warn(\n \"The model is automatically converting to fp16 for faster inference. \"\n \"If you want to disable the automatic precision, please manually add bf16/fp16/fp32=True to \\\"AutoModelForCausalLM.from_pretrained\\\".\"\n )\n config.fp16 = True\n else:\n config.fp32 = True\n\n if config.bf16 and SUPPORT_CUDA and not SUPPORT_BF16:\n logger.warn(\n \"Your device does NOT seem to support bf16, you can switch to fp16 or fp32 by by passing fp16/fp32=True in \\\"AutoModelForCausalLM.from_pretrained\\\".\")\n if config.fp16 and SUPPORT_CUDA and not SUPPORT_FP16:\n logger.warn(\n \"Your device does NOT support faster inference with fp16, please switch to fp32 which is likely to be faster\")\n if config.fp32:\n if SUPPORT_BF16:\n logger.warn(\n \"Your device support faster inference by passing bf16=True in \\\"AutoModelForCausalLM.from_pretrained\\\".\")\n elif SUPPORT_FP16:\n logger.warn(\n \"Your device support faster inference by passing fp16=True in \\\"AutoModelForCausalLM.from_pretrained\\\".\")\n\n if config.use_flash_attn == \"auto\":\n if config.bf16 or config.fp16:\n logger.warn(\"Try importing flash-attention for faster inference...\")\n config.use_flash_attn = True\n else:\n config.use_flash_attn = False\n if config.use_flash_attn and config.fp32:\n logger.warn(\"Flash attention will be disabled because it does NOT support fp32.\")\n\n if config.use_flash_attn:\n _import_flash_attn()\n\n self.transformer = QWenModel(config)\n self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)\n\n if config.bf16:\n self.transformer.bfloat16()\n self.lm_head.bfloat16()\n if config.fp16:\n self.transformer.half()\n self.lm_head.half()\n self.post_init()\n\n def get_output_embeddings(self):\n return self.lm_head\n\n def set_output_embeddings(self, new_embeddings):\n self.lm_head = new_embeddings\n\n def prepare_inputs_for_generation(\n self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs\n ):\n token_type_ids = kwargs.get(\"token_type_ids\", None)\n if past_key_values:\n input_ids = input_ids[:, -1].unsqueeze(-1)\n if token_type_ids is not None:\n token_type_ids = token_type_ids[:, -1].unsqueeze(-1)\n\n attention_mask = kwargs.get(\"attention_mask\", None)\n position_ids = kwargs.get(\"position_ids\", None)\n\n if attention_mask is not None and position_ids is None:\n position_ids = attention_mask.long().cumsum(-1) - 1\n position_ids.masked_fill_(attention_mask == 0, 1)\n if past_key_values:\n position_ids = position_ids[:, -1].unsqueeze(-1)\n else:\n position_ids = None\n\n if inputs_embeds is not None and past_key_values is None:\n model_inputs = {\"inputs_embeds\": inputs_embeds}\n else:\n model_inputs = {\"input_ids\": input_ids}\n\n model_inputs.update(\n {\n \"past_key_values\": past_key_values,\n \"use_cache\": kwargs.get(\"use_cache\"),\n \"position_ids\": position_ids,\n \"attention_mask\": attention_mask,\n \"token_type_ids\": token_type_ids,\n }\n )\n return model_inputs\n\n def forward(\n self,\n input_ids: Optional[torch.LongTensor] = None,\n past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n token_type_ids: Optional[torch.LongTensor] = None,\n position_ids: Optional[torch.LongTensor] = None,\n head_mask: Optional[torch.FloatTensor] = None,\n inputs_embeds: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.Tensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n labels: Optional[torch.LongTensor] = None,\n use_cache: Optional[bool] = None,\n output_attentions: Optional[bool] = None,\n output_hidden_states: Optional[bool] = None,\n return_dict: Optional[bool] = None,\n ) -> Union[Tuple, CausalLMOutputWithPast]:\n\n return_dict = (\n return_dict if return_dict is not None else self.config.use_return_dict\n )\n\n transformer_outputs = self.transformer(\n input_ids,\n past_key_values=past_key_values,\n attention_mask=attention_mask,\n token_type_ids=token_type_ids,\n position_ids=position_ids,\n head_mask=head_mask,\n inputs_embeds=inputs_embeds,\n encoder_hidden_states=encoder_hidden_states,\n encoder_attention_mask=encoder_attention_mask,\n use_cache=use_cache,\n output_attentions=output_attentions,\n output_hidden_states=output_hidden_states,\n return_dict=return_dict,\n )\n hidden_states = transformer_outputs[0]\n\n lm_logits = self.lm_head(hidden_states)\n\n loss = None\n if labels is not None:\n labels = labels.to(lm_logits.device)\n shift_logits = lm_logits[..., :-1, :].contiguous()\n shift_labels = labels[..., 1:].contiguous()\n loss_fct = CrossEntropyLoss()\n loss = loss_fct(\n shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)\n )\n\n if not return_dict:\n output = (lm_logits,) + transformer_outputs[1:]\n return ((loss,) + output) if loss is not None else output\n\n return CausalLMOutputWithPast(\n loss=loss,\n logits=lm_logits,\n past_key_values=transformer_outputs.past_key_values,\n hidden_states=transformer_outputs.hidden_states,\n attentions=transformer_outputs.attentions,\n )\n\n @staticmethod\n def _reorder_cache(\n past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor\n ) -> Tuple[Tuple[torch.Tensor]]:\n\n return tuple(\n tuple(\n past_state.index_select(0, beam_idx.to(past_state.device))\n for past_state in layer_past\n )\n for layer_past in past_key_values\n )\n\n def chat(\n self,\n tokenizer: PreTrainedTokenizer,\n query: str,\n history: Optional[HistoryType],\n system: str = \"You are a helpful assistant.\",\n append_history: bool = True,\n stream: Optional[bool] = _SENTINEL,\n stop_words_ids: Optional[List[List[int]]] = None,\n generation_config: Optional[GenerationConfig] = None,\n **kwargs,\n ) -> Tuple[str, HistoryType]:\n generation_config = generation_config if generation_config is not None else self.generation_config\n\n assert stream is _SENTINEL, _ERROR_STREAM_IN_CHAT\n assert generation_config.chat_format == 'chatml', _ERROR_BAD_CHAT_FORMAT\n if history is None:\n history = []\n if stop_words_ids is None:\n stop_words_ids = []\n\n max_window_size = kwargs.get('max_window_size', None)\n if max_window_size is None:\n max_window_size = generation_config.max_window_size"},"next_line":{"kind":"string","value":" raw_text, context_tokens = make_context("},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-12-19 13:11:38+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5673,"cells":{"repo_name":{"kind":"string","value":"MingtaoGuo/AnimateAnyone_unofficial"},"file_path":{"kind":"string","value":"aldm/aldm.py"},"context":{"kind":"list like","value":[{"identifier":"conv_nd","path":"ldm/modules/diffusionmodules/util.py","snippet":"def conv_nd(dims, *args, **kwargs):\n \"\"\"\n Create a 1D, 2D, or 3D convolution module.\n \"\"\"\n if dims == 1:\n return nn.Conv1d(*args, **kwargs)\n elif dims == 2:\n return nn.Conv2d(*args, **kwargs)\n elif dims == 3:\n return nn.Conv3d(*args, **kwargs)\n raise ValueError(f\"unsupported dimensions: {dims}\")"},{"identifier":"linear","path":"ldm/modules/diffusionmodules/util.py","snippet":"def linear(*args, **kwargs):\n \"\"\"\n Create a linear module.\n \"\"\"\n return nn.Linear(*args, **kwargs)"},{"identifier":"zero_module","path":"ldm/modules/diffusionmodules/util.py","snippet":"def zero_module(module):\n \"\"\"\n Zero out the parameters of a module and return it.\n \"\"\"\n for p in module.parameters():\n p.detach().zero_()\n return module"},{"identifier":"timestep_embedding","path":"ldm/modules/diffusionmodules/util.py","snippet":"def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):\n \"\"\"\n Create sinusoidal timestep embeddings.\n :param timesteps: a 1-D Tensor of N indices, one per batch element.\n These may be fractional.\n :param dim: the dimension of the output.\n :param max_period: controls the minimum frequency of the embeddings.\n :return: an [N x dim] Tensor of positional embeddings.\n \"\"\"\n if not repeat_only:\n half = dim // 2\n freqs = torch.exp(\n -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half\n ).to(device=timesteps.device)\n args = timesteps[:, None].float() * freqs[None]\n embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\n if dim % 2:\n embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)\n else:\n embedding = repeat(timesteps, 'b -> b d', d=dim)\n return embedding"},{"identifier":"SpatialTransformer","path":"ldm/modules/attention.py","snippet":"class SpatialTransformer(nn.Module):\n \"\"\"\n Transformer block for image-like data.\n First, project the input (aka embedding)\n and reshape to b, t, d.\n Then apply standard transformer action.\n Finally, reshape to image\n NEW: use_linear for more efficiency instead of the 1x1 convs\n \"\"\"\n def __init__(self, in_channels, n_heads, d_head,\n depth=1, dropout=0., context_dim=None,\n disable_self_attn=False, use_linear=False,\n use_checkpoint=True):\n super().__init__()\n if exists(context_dim) and not isinstance(context_dim, list):\n context_dim = [context_dim]\n self.in_channels = in_channels\n inner_dim = n_heads * d_head\n self.norm = Normalize(in_channels)\n if not use_linear:\n self.proj_in = nn.Conv2d(in_channels,\n inner_dim,\n kernel_size=1,\n stride=1,\n padding=0)\n else:\n self.proj_in = nn.Linear(in_channels, inner_dim)\n\n self.transformer_blocks = nn.ModuleList(\n [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],\n disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)\n for d in range(depth)]\n )\n if not use_linear:\n self.proj_out = zero_module(nn.Conv2d(inner_dim,\n in_channels,\n kernel_size=1,\n stride=1,\n padding=0))\n else:\n self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))\n self.use_linear = use_linear\n\n def forward(self, x, context=None):\n # note: if no context is given, cross-attention defaults to self-attention\n if not isinstance(context, list):\n context = [context]\n b, c, h, w = x.shape\n x_in = x\n x = self.norm(x)\n if not self.use_linear:\n x = self.proj_in(x)\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\n if self.use_linear:\n x = self.proj_in(x)\n for i, block in enumerate(self.transformer_blocks):\n x = block(x, context=context[i])\n if self.use_linear:\n x = self.proj_out(x)\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\n if not self.use_linear:\n x = self.proj_out(x)\n return x + x_in"},{"identifier":"SpatialTransformerPlus","path":"ldm/modules/attention.py","snippet":"class SpatialTransformerPlus(nn.Module):\n \"\"\"\n Transformer block for image-like data.\n First, project the input (aka embedding)\n and reshape to b, t, d.\n Then apply standard transformer action.\n Finally, reshape to image\n NEW: use_linear for more efficiency instead of the 1x1 convs\n \"\"\"\n def __init__(self, in_channels, n_heads, d_head,\n depth=1, dropout=0., context_dim=None,\n disable_self_attn=False, use_linear=False,\n use_checkpoint=True, use_temporal_attention=False):\n super().__init__()\n if exists(context_dim) and not isinstance(context_dim, list):\n context_dim = [context_dim]\n self.in_channels = in_channels\n inner_dim = n_heads * d_head\n self.norm = Normalize(in_channels)\n if not use_linear:\n self.proj_in = nn.Conv2d(in_channels,\n inner_dim,\n kernel_size=1,\n stride=1,\n padding=0)\n else:\n self.proj_in = nn.Linear(in_channels, inner_dim)\n\n self.transformer_blocks = nn.ModuleList(\n [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],\n disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)\n for d in range(depth)]\n )\n if not use_linear:\n self.proj_out = zero_module(nn.Conv2d(inner_dim,\n in_channels,\n kernel_size=1,\n stride=1,\n padding=0))\n else:\n self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))\n self.use_linear = use_linear\n self.spatial_attn = SpatialSelfAttention(in_channels)\n if use_temporal_attention:\n self.temporal_attn = TemporalTransformer(in_channels)\n\n def forward(self, x, context=None, ref=None):\n x = torch.cat([x, ref], dim=-1)\n x = self.spatial_attn(x)\n x = x[..., :ref.shape[-1]]\n # note: if no context is given, cross-attention defaults to self-attention\n if not isinstance(context, list):\n context = [context]\n b, c, h, w = x.shape\n x_in = x\n x = self.norm(x)\n if not self.use_linear:\n x = self.proj_in(x)\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\n if self.use_linear:\n x = self.proj_in(x)\n for i, block in enumerate(self.transformer_blocks):\n x = block(x, context=context[i])\n if self.use_linear:\n x = self.proj_out(x)\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\n if not self.use_linear:\n x = self.proj_out(x)\n return x + x_in"},{"identifier":"ResBlock","path":"ldm/modules/diffusionmodules/openaimodel.py","snippet":"def convert_module_to_f16(x):\ndef convert_module_to_f32(x):\n def __init__(\n self,\n spacial_dim: int,\n embed_dim: int,\n num_heads_channels: int,\n output_dim: int = None,\n ):\n def forward(self, x):\n def forward(self, x, emb):\n def forward(self, x, emb, context=None):\n def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):\n def forward(self, x):\n def __init__(self, channels, out_channels=None, ks=5):\n def forward(self,x):\n def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):\n def forward(self, x):\n def __init__(\n self,\n channels,\n emb_channels,\n dropout,\n out_channels=None,\n use_conv=False,\n use_scale_shift_norm=False,\n dims=2,\n use_checkpoint=False,\n up=False,\n down=False,\n ):\n def forward(self, x, emb):\n def _forward(self, x, emb):\n def __init__(\n self,\n channels,\n dropout,\n out_channels=None,\n use_conv=False,\n dims=2,\n use_checkpoint=False,\n up=False,\n down=False,\n ):\n def forward(self, x):\n def _forward(self, x):\n def __init__(\n self,\n channels,\n num_heads=1,\n num_head_channels=-1,\n use_checkpoint=False,\n use_new_attention_order=False,\n ):\n def forward(self, x):\n def _forward(self, x):\ndef count_flops_attn(model, _x, y):\n def __init__(self, n_heads):\n def forward(self, qkv):\n def count_flops(model, _x, y):\n def __init__(self, n_heads):\n def forward(self, qkv):\n def count_flops(model, _x, y):\n def __init__(\n self,\n image_size,\n in_channels,\n model_channels,\n out_channels,\n num_res_blocks,\n attention_resolutions,\n dropout=0,\n channel_mult=(1, 2, 4, 8),\n conv_resample=True,\n dims=2,\n num_classes=None,\n use_checkpoint=False,\n use_fp16=False,\n num_heads=-1,\n num_head_channels=-1,\n num_heads_upsample=-1,\n use_scale_shift_norm=False,\n resblock_updown=False,\n use_new_attention_order=False,\n use_spatial_transformer=False, # custom transformer support\n transformer_depth=1, # custom transformer support\n context_dim=None, # custom transformer support\n n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model\n legacy=True,\n disable_self_attentions=None,\n num_attention_blocks=None,\n disable_middle_self_attn=False,\n use_linear_in_transformer=False,\n ):\n def convert_to_fp16(self):\n def convert_to_fp32(self):\n def forward(self, x, timesteps=None, context=None, y=None,**kwargs):\nclass AttentionPool2d(nn.Module):\nclass TimestepBlock(nn.Module):\nclass TimestepEmbedSequential(nn.Sequential, TimestepBlock):\nclass Upsample(nn.Module):\nclass TransposedUpsample(nn.Module):\nclass Downsample(nn.Module):\nclass ResBlock(TimestepBlock):\nclass ResBlockNoTime(TimestepBlock):\nclass AttentionBlock(nn.Module):\nclass QKVAttentionLegacy(nn.Module):\nclass QKVAttention(nn.Module):\nclass UNetModel(nn.Module):"},{"identifier":"LatentDiffusion","path":"ldm/models/diffusion/ddpm.py","snippet":"class LatentDiffusion(DDPM):\n \"\"\"main class\"\"\"\n\n def __init__(self,\n first_stage_config,\n cond_stage_config,\n num_timesteps_cond=None,\n cond_stage_key=\"image\",\n cond_stage_trainable=False,\n concat_mode=True,\n cond_stage_forward=None,\n conditioning_key=None,\n scale_factor=1.0,\n scale_by_std=False,\n force_null_conditioning=False,\n *args, **kwargs):\n self.force_null_conditioning = force_null_conditioning\n self.num_timesteps_cond = default(num_timesteps_cond, 1)\n self.scale_by_std = scale_by_std\n assert self.num_timesteps_cond <= kwargs['timesteps']\n # for backwards compatibility after implementation of DiffusionWrapper\n if conditioning_key is None:\n conditioning_key = 'concat' if concat_mode else 'crossattn'\n if cond_stage_config == '__is_unconditional__' and not self.force_null_conditioning:\n conditioning_key = None\n ckpt_path = kwargs.pop(\"ckpt_path\", None)\n reset_ema = kwargs.pop(\"reset_ema\", False)\n reset_num_ema_updates = kwargs.pop(\"reset_num_ema_updates\", False)\n ignore_keys = kwargs.pop(\"ignore_keys\", [])\n super().__init__(conditioning_key=conditioning_key, *args, **kwargs)\n self.concat_mode = concat_mode\n self.cond_stage_trainable = cond_stage_trainable\n self.cond_stage_key = cond_stage_key\n try:\n self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1\n except:\n self.num_downs = 0\n if not scale_by_std:\n self.scale_factor = scale_factor\n else:\n self.register_buffer('scale_factor', torch.tensor(scale_factor))\n self.instantiate_first_stage(first_stage_config)\n self.instantiate_cond_stage(cond_stage_config)\n self.cond_stage_forward = cond_stage_forward\n self.clip_denoised = False\n self.bbox_tokenizer = None\n\n self.restarted_from_ckpt = False\n if ckpt_path is not None:\n self.init_from_ckpt(ckpt_path, ignore_keys)\n self.restarted_from_ckpt = True\n if reset_ema:\n assert self.use_ema\n print(\n f\"Resetting ema to pure model weights. This is useful when restoring from an ema-only checkpoint.\")\n self.model_ema = LitEma(self.model)\n if reset_num_ema_updates:\n print(\" +++++++++++ WARNING: RESETTING NUM_EMA UPDATES TO ZERO +++++++++++ \")\n assert self.use_ema\n self.model_ema.reset_num_updates()\n\n def make_cond_schedule(self, ):\n self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)\n ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()\n self.cond_ids[:self.num_timesteps_cond] = ids\n\n @rank_zero_only\n @torch.no_grad()\n def on_train_batch_start(self, batch, batch_idx, dataloader_idx):\n # only for very first batch\n if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:\n assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'\n # set rescale weight to 1./std of encodings\n print(\"### USING STD-RESCALING ###\")\n x = super().get_input(batch, self.first_stage_key)\n x = x.to(self.device)\n encoder_posterior = self.encode_first_stage(x)\n z = self.get_first_stage_encoding(encoder_posterior).detach()\n del self.scale_factor\n self.register_buffer('scale_factor', 1. / z.flatten().std())\n print(f\"setting self.scale_factor to {self.scale_factor}\")\n print(\"### USING STD-RESCALING ###\")\n\n def register_schedule(self,\n given_betas=None, beta_schedule=\"linear\", timesteps=1000,\n linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):\n super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)\n\n self.shorten_cond_schedule = self.num_timesteps_cond > 1\n if self.shorten_cond_schedule:\n self.make_cond_schedule()\n\n def instantiate_first_stage(self, config):\n model = instantiate_from_config(config)\n self.first_stage_model = model.eval()\n self.first_stage_model.train = disabled_train\n for param in self.first_stage_model.parameters():\n param.requires_grad = False\n\n def instantiate_cond_stage(self, config):\n if not self.cond_stage_trainable:\n if config == \"__is_first_stage__\":\n print(\"Using first stage also as cond stage.\")\n self.cond_stage_model = self.first_stage_model\n elif config == \"__is_unconditional__\":\n print(f\"Training {self.__class__.__name__} as an unconditional model.\")\n self.cond_stage_model = None\n # self.be_unconditional = True\n else:\n model = instantiate_from_config(config)\n self.cond_stage_model = model.eval()\n self.cond_stage_model.train = disabled_train\n for param in self.cond_stage_model.parameters():\n param.requires_grad = False\n else:\n assert config != '__is_first_stage__'\n assert config != '__is_unconditional__'\n model = instantiate_from_config(config)\n self.cond_stage_model = model\n\n def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False):\n denoise_row = []\n for zd in tqdm(samples, desc=desc):\n denoise_row.append(self.decode_first_stage(zd.to(self.device),\n force_not_quantize=force_no_decoder_quantization))\n n_imgs_per_row = len(denoise_row)\n denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W\n denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')\n denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')\n denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)\n return denoise_grid\n\n def get_first_stage_encoding(self, encoder_posterior):\n if isinstance(encoder_posterior, DiagonalGaussianDistribution):\n z = encoder_posterior.sample()\n elif isinstance(encoder_posterior, torch.Tensor):\n z = encoder_posterior\n else:\n raise NotImplementedError(f\"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented\")\n return self.scale_factor * z\n\n def get_learned_conditioning(self, c):\n if self.cond_stage_forward is None:\n if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):\n c = self.cond_stage_model.encode(c)\n if isinstance(c, DiagonalGaussianDistribution):\n c = c.mode()\n else:\n c = self.cond_stage_model(c)\n else:\n assert hasattr(self.cond_stage_model, self.cond_stage_forward)\n c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)\n return c\n\n def meshgrid(self, h, w):\n y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)\n x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)\n\n arr = torch.cat([y, x], dim=-1)\n return arr\n\n def delta_border(self, h, w):\n \"\"\"\n :param h: height\n :param w: width\n :return: normalized distance to image border,\n wtith min distance = 0 at border and max dist = 0.5 at image center\n \"\"\"\n lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)\n arr = self.meshgrid(h, w) / lower_right_corner\n dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]\n dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]\n edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]\n return edge_dist\n\n def get_weighting(self, h, w, Ly, Lx, device):\n weighting = self.delta_border(h, w)\n weighting = torch.clip(weighting, self.split_input_params[\"clip_min_weight\"],\n self.split_input_params[\"clip_max_weight\"], )\n weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)\n\n if self.split_input_params[\"tie_braker\"]:\n L_weighting = self.delta_border(Ly, Lx)\n L_weighting = torch.clip(L_weighting,\n self.split_input_params[\"clip_min_tie_weight\"],\n self.split_input_params[\"clip_max_tie_weight\"])\n\n L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)\n weighting = weighting * L_weighting\n return weighting\n\n def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1): # todo load once not every time, shorten code\n \"\"\"\n :param x: img of size (bs, c, h, w)\n :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])\n \"\"\"\n bs, nc, h, w = x.shape\n\n # number of crops in image\n Ly = (h - kernel_size[0]) // stride[0] + 1\n Lx = (w - kernel_size[1]) // stride[1] + 1\n\n if uf == 1 and df == 1:\n fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)\n unfold = torch.nn.Unfold(**fold_params)\n\n fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)\n\n weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype)\n normalization = fold(weighting).view(1, 1, h, w) # normalizes the overlap\n weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))\n\n elif uf > 1 and df == 1:\n fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)\n unfold = torch.nn.Unfold(**fold_params)\n\n fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),\n dilation=1, padding=0,\n stride=(stride[0] * uf, stride[1] * uf))\n fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)\n\n weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype)\n normalization = fold(weighting).view(1, 1, h * uf, w * uf) # normalizes the overlap\n weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))\n\n elif df > 1 and uf == 1:\n fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)\n unfold = torch.nn.Unfold(**fold_params)\n\n fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df),\n dilation=1, padding=0,\n stride=(stride[0] // df, stride[1] // df))\n fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2)\n\n weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype)\n normalization = fold(weighting).view(1, 1, h // df, w // df) # normalizes the overlap\n weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))\n\n else:\n raise NotImplementedError\n\n return fold, unfold, normalization, weighting\n\n @torch.no_grad()\n def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,\n cond_key=None, return_original_cond=False, bs=None, return_x=False):\n x = super().get_input(batch, k)\n if bs is not None:\n x = x[:bs]\n x = x.to(self.device)\n encoder_posterior = self.encode_first_stage(x)\n z = self.get_first_stage_encoding(encoder_posterior).detach()\n\n if self.model.conditioning_key is not None and not self.force_null_conditioning:\n if cond_key is None:\n cond_key = self.cond_stage_key\n if cond_key != self.first_stage_key:\n if cond_key in ['caption', 'coordinates_bbox', 'txt', 'vision']:\n xc = batch[cond_key]\n xc = rearrange(xc, 'b h w c -> b c h w')\n elif cond_key in ['class_label', 'cls']:\n xc = batch\n else:\n xc = super().get_input(batch, cond_key).to(self.device)\n else:\n xc = x\n if not self.cond_stage_trainable or force_c_encode:\n if isinstance(xc, dict) or isinstance(xc, list):\n c = self.get_learned_conditioning(xc)\n else:\n c = self.get_learned_conditioning(xc.to(self.device))\n else:\n c = xc\n if bs is not None:\n c = c[:bs]\n\n if self.use_positional_encodings:\n pos_x, pos_y = self.compute_latent_shifts(batch)\n ckey = __conditioning_keys__[self.model.conditioning_key]\n c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}\n\n else:\n c = None\n xc = None\n if self.use_positional_encodings:\n pos_x, pos_y = self.compute_latent_shifts(batch)\n c = {'pos_x': pos_x, 'pos_y': pos_y}\n out = [z, c]\n if return_first_stage_outputs:\n xrec = self.decode_first_stage(z)\n out.extend([x, xrec])\n if return_x:\n out.extend([x])\n if return_original_cond:\n out.append(xc)\n return out\n\n @torch.no_grad()\n def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):\n if predict_cids:\n if z.dim() == 4:\n z = torch.argmax(z.exp(), dim=1).long()\n z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)\n z = rearrange(z, 'b h w c -> b c h w').contiguous()\n\n z = 1. / self.scale_factor * z\n return self.first_stage_model.decode(z)\n\n @torch.no_grad()\n def encode_first_stage(self, x):\n return self.first_stage_model.encode(x)\n\n def shared_step(self, batch, **kwargs):\n x, c = self.get_input(batch, self.first_stage_key)\n loss = self(x, c)\n return loss\n\n def forward(self, x, c, *args, **kwargs):\n t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()\n if self.model.conditioning_key is not None:\n assert c is not None\n if self.cond_stage_trainable:\n c = self.get_learned_conditioning(c)\n if self.shorten_cond_schedule: # TODO: drop this option\n tc = self.cond_ids[t].to(self.device)\n c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))\n return self.p_losses(x, c, t, *args, **kwargs)\n\n def apply_model(self, x_noisy, t, cond, return_ids=False):\n if isinstance(cond, dict):\n # hybrid case, cond is expected to be a dict\n pass\n else:\n if not isinstance(cond, list):\n cond = [cond]\n key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'\n cond = {key: cond}\n\n x_recon = self.model(x_noisy, t, **cond)\n\n if isinstance(x_recon, tuple) and not return_ids:\n return x_recon[0]\n else:\n return x_recon\n\n def _predict_eps_from_xstart(self, x_t, t, pred_xstart):\n return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \\\n extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)\n\n def _prior_bpd(self, x_start):\n \"\"\"\n Get the prior KL term for the variational lower-bound, measured in\n bits-per-dim.\n This term can't be optimized, as it only depends on the encoder.\n :param x_start: the [N x C x ...] tensor of inputs.\n :return: a batch of [N] KL values (in bits), one per batch element.\n \"\"\"\n batch_size = x_start.shape[0]\n t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)\n qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)\n kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)\n return mean_flat(kl_prior) / np.log(2.0)\n\n def p_losses(self, x_start, cond, t, noise=None):\n noise = default(noise, lambda: torch.randn_like(x_start))\n x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)\n model_output = self.apply_model(x_noisy, t, cond)\n \n loss_dict = {}\n prefix = 'train' if self.training else 'val'\n\n if self.parameterization == \"x0\":\n target = x_start\n elif self.parameterization == \"eps\":\n target = noise\n elif self.parameterization == \"v\":\n target = self.get_v(x_start, noise, t)\n else:\n raise NotImplementedError()\n\n loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])\n loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})\n\n logvar_t = self.logvar[t].to(self.device)\n loss = loss_simple / torch.exp(logvar_t) + logvar_t\n # loss = loss_simple / torch.exp(self.logvar) + self.logvar\n if self.learn_logvar:\n loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})\n loss_dict.update({'logvar': self.logvar.data.mean()})\n\n loss = self.l_simple_weight * loss.mean()\n\n loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))\n loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()\n loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})\n loss += (self.original_elbo_weight * loss_vlb)\n loss_dict.update({f'{prefix}/loss': loss})\n return loss, loss_dict\n\n def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,\n return_x0=False, score_corrector=None, corrector_kwargs=None):\n t_in = t\n model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)\n\n if score_corrector is not None:\n assert self.parameterization == \"eps\"\n model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)\n\n if return_codebook_ids:\n model_out, logits = model_out\n\n if self.parameterization == \"eps\":\n x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)\n elif self.parameterization == \"x0\":\n x_recon = model_out\n else:\n raise NotImplementedError()\n\n if clip_denoised:\n x_recon.clamp_(-1., 1.)\n if quantize_denoised:\n x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)\n model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)\n if return_codebook_ids:\n return model_mean, posterior_variance, posterior_log_variance, logits\n elif return_x0:\n return model_mean, posterior_variance, posterior_log_variance, x_recon\n else:\n return model_mean, posterior_variance, posterior_log_variance\n\n @torch.no_grad()\n def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,\n return_codebook_ids=False, quantize_denoised=False, return_x0=False,\n temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):\n b, *_, device = *x.shape, x.device\n outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,\n return_codebook_ids=return_codebook_ids,\n quantize_denoised=quantize_denoised,\n return_x0=return_x0,\n score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)\n if return_codebook_ids:\n raise DeprecationWarning(\"Support dropped.\")\n model_mean, _, model_log_variance, logits = outputs\n elif return_x0:\n model_mean, _, model_log_variance, x0 = outputs\n else:\n model_mean, _, model_log_variance = outputs\n\n noise = noise_like(x.shape, device, repeat_noise) * temperature\n if noise_dropout > 0.:\n noise = torch.nn.functional.dropout(noise, p=noise_dropout)\n # no noise when t == 0\n nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))\n\n if return_codebook_ids:\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)\n if return_x0:\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0\n else:\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise\n\n @torch.no_grad()\n def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,\n img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,\n score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,\n log_every_t=None):\n if not log_every_t:\n log_every_t = self.log_every_t\n timesteps = self.num_timesteps\n if batch_size is not None:\n b = batch_size if batch_size is not None else shape[0]\n shape = [batch_size] + list(shape)\n else:\n b = batch_size = shape[0]\n if x_T is None:\n img = torch.randn(shape, device=self.device)\n else:\n img = x_T\n intermediates = []\n if cond is not None:\n if isinstance(cond, dict):\n cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else\n list(map(lambda x: x[:batch_size], cond[key])) for key in cond}\n else:\n cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]\n\n if start_T is not None:\n timesteps = min(timesteps, start_T)\n iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',\n total=timesteps) if verbose else reversed(\n range(0, timesteps))\n if type(temperature) == float:\n temperature = [temperature] * timesteps\n\n for i in iterator:\n ts = torch.full((b,), i, device=self.device, dtype=torch.long)\n if self.shorten_cond_schedule:\n assert self.model.conditioning_key != 'hybrid'\n tc = self.cond_ids[ts].to(cond.device)\n cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))\n\n img, x0_partial = self.p_sample(img, cond, ts,\n clip_denoised=self.clip_denoised,\n quantize_denoised=quantize_denoised, return_x0=True,\n temperature=temperature[i], noise_dropout=noise_dropout,\n score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)\n if mask is not None:\n assert x0 is not None\n img_orig = self.q_sample(x0, ts)\n img = img_orig * mask + (1. - mask) * img\n\n if i % log_every_t == 0 or i == timesteps - 1:\n intermediates.append(x0_partial)\n if callback: callback(i)\n if img_callback: img_callback(img, i)\n return img, intermediates\n\n @torch.no_grad()\n def p_sample_loop(self, cond, shape, return_intermediates=False,\n x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,\n mask=None, x0=None, img_callback=None, start_T=None,\n log_every_t=None):\n\n if not log_every_t:\n log_every_t = self.log_every_t\n device = self.betas.device\n b = shape[0]\n if x_T is None:\n img = torch.randn(shape, device=device)\n else:\n img = x_T\n\n intermediates = [img]\n if timesteps is None:\n timesteps = self.num_timesteps\n\n if start_T is not None:\n timesteps = min(timesteps, start_T)\n iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(\n range(0, timesteps))\n\n if mask is not None:\n assert x0 is not None\n assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match\n\n for i in iterator:\n ts = torch.full((b,), i, device=device, dtype=torch.long)\n if self.shorten_cond_schedule:\n assert self.model.conditioning_key != 'hybrid'\n tc = self.cond_ids[ts].to(cond.device)\n cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))\n\n img = self.p_sample(img, cond, ts,\n clip_denoised=self.clip_denoised,\n quantize_denoised=quantize_denoised)\n if mask is not None:\n img_orig = self.q_sample(x0, ts)\n img = img_orig * mask + (1. - mask) * img\n\n if i % log_every_t == 0 or i == timesteps - 1:\n intermediates.append(img)\n if callback: callback(i)\n if img_callback: img_callback(img, i)\n\n if return_intermediates:\n return img, intermediates\n return img\n\n @torch.no_grad()\n def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,\n verbose=True, timesteps=None, quantize_denoised=False,\n mask=None, x0=None, shape=None, **kwargs):\n if shape is None:\n shape = (batch_size, self.channels, self.image_size, self.image_size)\n if cond is not None:\n if isinstance(cond, dict):\n cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else\n list(map(lambda x: x[:batch_size], cond[key])) for key in cond}\n else:\n cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]\n return self.p_sample_loop(cond,\n shape,\n return_intermediates=return_intermediates, x_T=x_T,\n verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,\n mask=mask, x0=x0)\n\n @torch.no_grad()\n def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):\n if ddim:\n ddim_sampler = DDIMSampler(self)\n shape = (self.channels, self.image_size, self.image_size)\n samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size,\n shape, cond, verbose=False, **kwargs)\n\n else:\n samples, intermediates = self.sample(cond=cond, batch_size=batch_size,\n return_intermediates=True, **kwargs)\n\n return samples, intermediates\n\n @torch.no_grad()\n def get_unconditional_conditioning(self, batch_size, null_label=None):\n if null_label is not None:\n xc = null_label\n if isinstance(xc, ListConfig):\n xc = list(xc)\n if isinstance(xc, dict) or isinstance(xc, list):\n c = self.get_learned_conditioning(xc)\n else:\n if hasattr(xc, \"to\"):\n xc = xc.to(self.device)\n c = self.get_learned_conditioning(xc)\n else:\n if self.cond_stage_key in [\"class_label\", \"cls\"]:\n xc = self.cond_stage_model.get_unconditional_conditioning(batch_size, device=self.device)\n return self.get_learned_conditioning(xc)\n else:\n raise NotImplementedError(\"todo\")\n if isinstance(c, list): # in case the encoder gives us a list\n for i in range(len(c)):\n c[i] = repeat(c[i], '1 ... -> b ...', b=batch_size).to(self.device)\n else:\n c = repeat(c, '1 ... -> b ...', b=batch_size).to(self.device)\n return c\n\n @torch.no_grad()\n def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=50, ddim_eta=0., return_keys=None,\n quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,\n plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None,\n use_ema_scope=True,\n **kwargs):\n ema_scope = self.ema_scope if use_ema_scope else nullcontext\n use_ddim = ddim_steps is not None\n\n log = dict()\n z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,\n return_first_stage_outputs=True,\n force_c_encode=True,\n return_original_cond=True,\n bs=N)\n N = min(x.shape[0], N)\n n_row = min(x.shape[0], n_row)\n log[\"inputs\"] = x\n log[\"reconstruction\"] = xrec\n if self.model.conditioning_key is not None:\n if hasattr(self.cond_stage_model, \"decode\"):\n xc = self.cond_stage_model.decode(c)\n log[\"conditioning\"] = xc\n elif self.cond_stage_key in [\"caption\", \"txt\"]:\n xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25)\n log[\"conditioning\"] = xc\n elif self.cond_stage_key in ['class_label', \"cls\"]:\n try:\n xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[\"human_label\"], size=x.shape[2] // 25)\n log['conditioning'] = xc\n except KeyError:\n # probably no \"human_label\" in batch\n pass\n elif isimage(xc):\n log[\"conditioning\"] = xc\n if ismap(xc):\n log[\"original_conditioning\"] = self.to_rgb(xc)\n\n if plot_diffusion_rows:\n # get diffusion row\n diffusion_row = list()\n z_start = z[:n_row]\n for t in range(self.num_timesteps):\n if t % self.log_every_t == 0 or t == self.num_timesteps - 1:\n t = repeat(torch.tensor([t]), '1 -> b', b=n_row)\n t = t.to(self.device).long()\n noise = torch.randn_like(z_start)\n z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)\n diffusion_row.append(self.decode_first_stage(z_noisy))\n\n diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W\n diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')\n diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')\n diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])\n log[\"diffusion_row\"] = diffusion_grid\n\n if sample:\n # get denoise row\n with ema_scope(\"Sampling\"):\n samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,\n ddim_steps=ddim_steps, eta=ddim_eta)\n # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)\n x_samples = self.decode_first_stage(samples)\n log[\"samples\"] = x_samples\n if plot_denoise_rows:\n denoise_grid = self._get_denoise_row_from_list(z_denoise_row)\n log[\"denoise_row\"] = denoise_grid\n\n if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance(\n self.first_stage_model, IdentityFirstStage):\n # also display when quantizing x0 while sampling\n with ema_scope(\"Plotting Quantized Denoised\"):\n samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,\n ddim_steps=ddim_steps, eta=ddim_eta,\n quantize_denoised=True)\n # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,\n # quantize_denoised=True)\n x_samples = self.decode_first_stage(samples.to(self.device))\n log[\"samples_x0_quantized\"] = x_samples\n\n if unconditional_guidance_scale > 1.0:\n uc = self.get_unconditional_conditioning(N, unconditional_guidance_label)\n if self.model.conditioning_key == \"crossattn-adm\":\n uc = {\"c_crossattn\": [uc], \"c_adm\": c[\"c_adm\"]}\n with ema_scope(\"Sampling with classifier-free guidance\"):\n samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,\n ddim_steps=ddim_steps, eta=ddim_eta,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=uc,\n )\n x_samples_cfg = self.decode_first_stage(samples_cfg)\n log[f\"samples_cfg_scale_{unconditional_guidance_scale:.2f}\"] = x_samples_cfg\n\n if inpaint:\n # make a simple center square\n b, h, w = z.shape[0], z.shape[2], z.shape[3]\n mask = torch.ones(N, h, w).to(self.device)\n # zeros will be filled in\n mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.\n mask = mask[:, None, ...]\n with ema_scope(\"Plotting Inpaint\"):\n samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta,\n ddim_steps=ddim_steps, x0=z[:N], mask=mask)\n x_samples = self.decode_first_stage(samples.to(self.device))\n log[\"samples_inpainting\"] = x_samples\n log[\"mask\"] = mask\n\n # outpaint\n mask = 1. - mask\n with ema_scope(\"Plotting Outpaint\"):\n samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta,\n ddim_steps=ddim_steps, x0=z[:N], mask=mask)\n x_samples = self.decode_first_stage(samples.to(self.device))\n log[\"samples_outpainting\"] = x_samples\n\n if plot_progressive_rows:\n with ema_scope(\"Plotting Progressives\"):\n img, progressives = self.progressive_denoising(c,\n shape=(self.channels, self.image_size, self.image_size),\n batch_size=N)\n prog_row = self._get_denoise_row_from_list(progressives, desc=\"Progressive Generation\")\n log[\"progressive_row\"] = prog_row\n\n if return_keys:\n if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:\n return log\n else:\n return {key: log[key] for key in return_keys}\n return log\n\n def configure_optimizers(self):\n lr = self.learning_rate\n params = list(self.model.parameters())\n if self.cond_stage_trainable:\n print(f\"{self.__class__.__name__}: Also optimizing conditioner params!\")\n params = params + list(self.cond_stage_model.parameters())\n if self.learn_logvar:\n print('Diffusion model optimizing logvar')\n params.append(self.logvar)\n opt = torch.optim.AdamW(params, lr=lr)\n if self.use_scheduler:\n assert 'target' in self.scheduler_config\n scheduler = instantiate_from_config(self.scheduler_config)\n\n print(\"Setting up LambdaLR scheduler...\")\n scheduler = [\n {\n 'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),\n 'interval': 'step',\n 'frequency': 1\n }]\n return [opt], scheduler\n return opt\n\n @torch.no_grad()\n def to_rgb(self, x):\n x = x.float()\n if not hasattr(self, \"colorize\"):\n self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)\n x = nn.functional.conv2d(x, weight=self.colorize)\n x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.\n return x"},{"identifier":"log_txt_as_img","path":"ldm/util.py","snippet":"def log_txt_as_img(wh, xc, size=10):\n # wh a tuple of (width, height)\n # xc a list of captions to plot\n b = len(xc)\n txts = list()\n for bi in range(b):\n txt = Image.new(\"RGB\", wh, color=\"white\")\n draw = ImageDraw.Draw(txt)\n font = ImageFont.truetype('font/DejaVuSans.ttf', size=size)\n nc = int(40 * (wh[0] / 256))\n lines = \"\\n\".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc))\n\n try:\n draw.text((0, 0), lines, fill=\"black\", font=font)\n except UnicodeEncodeError:\n print(\"Cant encode string for logging. Skipping.\")\n\n txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0\n txts.append(txt)\n txts = np.stack(txts)\n txts = torch.tensor(txts)\n return txts"},{"identifier":"exists","path":"ldm/util.py","snippet":"def exists(x):\n return x is not None"},{"identifier":"instantiate_from_config","path":"ldm/util.py","snippet":"def instantiate_from_config(config):\n if not \"target\" in config:\n if config == '__is_first_stage__':\n return None\n elif config == \"__is_unconditional__\":\n return None\n raise KeyError(\"Expected key `target` to instantiate.\")\n return get_obj_from_str(config[\"target\"])(**config.get(\"params\", dict()))"},{"identifier":"DDIMSampler","path":"ldm/models/diffusion/ddim.py","snippet":"class DDIMSampler(object):\n def __init__(self, model, schedule=\"linear\", **kwargs):\n super().__init__()\n self.model = model\n self.ddpm_num_timesteps = model.num_timesteps\n self.schedule = schedule\n\n def register_buffer(self, name, attr):\n if type(attr) == torch.Tensor:\n if attr.device != torch.device(\"cuda\"):\n attr = attr.to(torch.device(\"cuda\"))\n setattr(self, name, attr)\n\n def make_schedule(self, ddim_num_steps, ddim_discretize=\"uniform\", ddim_eta=0., verbose=True):\n self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,\n num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)\n alphas_cumprod = self.model.alphas_cumprod\n assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'\n to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)\n\n self.register_buffer('betas', to_torch(self.model.betas))\n self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))\n self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))\n\n # calculations for diffusion q(x_t | x_{t-1}) and others\n self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))\n self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))\n self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))\n self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))\n self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))\n\n # ddim sampling parameters\n ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),\n ddim_timesteps=self.ddim_timesteps,\n eta=ddim_eta,verbose=verbose)\n self.register_buffer('ddim_sigmas', ddim_sigmas)\n self.register_buffer('ddim_alphas', ddim_alphas)\n self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)\n self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))\n sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(\n (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (\n 1 - self.alphas_cumprod / self.alphas_cumprod_prev))\n self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)\n\n @torch.no_grad()\n def sample(self,\n S,\n batch_size,\n shape,\n conditioning=None,\n callback=None,\n normals_sequence=None,\n img_callback=None,\n quantize_x0=False,\n eta=0.,\n mask=None,\n x0=None,\n temperature=1.,\n noise_dropout=0.,\n score_corrector=None,\n corrector_kwargs=None,\n verbose=True,\n x_T=None,\n log_every_t=100,\n unconditional_guidance_scale=1.,\n unconditional_conditioning=None, # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\n dynamic_threshold=None,\n ucg_schedule=None,\n **kwargs\n ):\n if conditioning is not None:\n if isinstance(conditioning, dict):\n ctmp = conditioning[list(conditioning.keys())[0]]\n while isinstance(ctmp, list): ctmp = ctmp[0]\n cbs = ctmp.shape[0]\n if cbs != batch_size:\n print(f\"Warning: Got {cbs} conditionings but batch-size is {batch_size}\")\n\n elif isinstance(conditioning, list):\n for ctmp in conditioning:\n if ctmp.shape[0] != batch_size:\n print(f\"Warning: Got {cbs} conditionings but batch-size is {batch_size}\")\n\n else:\n if conditioning.shape[0] != batch_size:\n print(f\"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}\")\n\n self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose)\n # sampling\n C, H, W = shape\n size = (batch_size, C, H, W)\n print(f'Data shape for DDIM sampling is {size}, eta {eta}')\n\n samples, intermediates = self.ddim_sampling(conditioning, size,\n callback=callback,\n img_callback=img_callback,\n quantize_denoised=quantize_x0,\n mask=mask, x0=x0,\n ddim_use_original_steps=False,\n noise_dropout=noise_dropout,\n temperature=temperature,\n score_corrector=score_corrector,\n corrector_kwargs=corrector_kwargs,\n x_T=x_T,\n log_every_t=log_every_t,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=unconditional_conditioning,\n dynamic_threshold=dynamic_threshold,\n ucg_schedule=ucg_schedule\n )\n return samples, intermediates\n\n @torch.no_grad()\n def ddim_sampling(self, cond, shape,\n x_T=None, ddim_use_original_steps=False,\n callback=None, timesteps=None, quantize_denoised=False,\n mask=None, x0=None, img_callback=None, log_every_t=100,\n temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,\n unconditional_guidance_scale=1., unconditional_conditioning=None, dynamic_threshold=None,\n ucg_schedule=None):\n device = self.model.betas.device\n b = shape[0]\n if x_T is None:\n img = torch.randn(shape, device=device)\n else:\n img = x_T\n\n if timesteps is None:\n timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps\n elif timesteps is not None and not ddim_use_original_steps:\n subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1\n timesteps = self.ddim_timesteps[:subset_end]\n\n intermediates = {'x_inter': [img], 'pred_x0': [img]}\n time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)\n total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]\n print(f\"Running DDIM Sampling with {total_steps} timesteps\")\n\n iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)\n\n for i, step in enumerate(iterator):\n index = total_steps - i - 1\n ts = torch.full((b,), step, device=device, dtype=torch.long)\n\n if mask is not None:\n assert x0 is not None\n img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass?\n img = img_orig * mask + (1. - mask) * img\n\n if ucg_schedule is not None:\n assert len(ucg_schedule) == len(time_range)\n unconditional_guidance_scale = ucg_schedule[i]\n\n outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,\n quantize_denoised=quantize_denoised, temperature=temperature,\n noise_dropout=noise_dropout, score_corrector=score_corrector,\n corrector_kwargs=corrector_kwargs,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=unconditional_conditioning,\n dynamic_threshold=dynamic_threshold)\n img, pred_x0 = outs\n if callback: callback(i)\n if img_callback: img_callback(pred_x0, i)\n\n if index % log_every_t == 0 or index == total_steps - 1:\n intermediates['x_inter'].append(img)\n intermediates['pred_x0'].append(pred_x0)\n\n return img, intermediates\n\n @torch.no_grad()\n def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,\n temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,\n unconditional_guidance_scale=1., unconditional_conditioning=None,\n dynamic_threshold=None):\n b, *_, device = *x.shape, x.device\n\n if unconditional_conditioning is None or unconditional_guidance_scale == 1.:\n model_output = self.model.apply_model(x, t, c)\n else:\n x_in = torch.cat([x] * 2)\n t_in = torch.cat([t] * 2)\n if isinstance(c, dict):\n assert isinstance(unconditional_conditioning, dict)\n c_in = dict()\n for k in c:\n if isinstance(c[k], list):\n c_in[k] = [torch.cat([\n unconditional_conditioning[k][i],\n c[k][i]]) for i in range(len(c[k]))]\n else:\n c_in[k] = torch.cat([\n unconditional_conditioning[k],\n c[k]])\n elif isinstance(c, list):\n c_in = list()\n assert isinstance(unconditional_conditioning, list)\n for i in range(len(c)):\n c_in.append(torch.cat([unconditional_conditioning[i], c[i]]))\n else:\n c_in = torch.cat([unconditional_conditioning, c])\n model_uncond, model_t = self.model.apply_model(x_in, t_in, c_in).chunk(2)\n model_output = model_uncond + unconditional_guidance_scale * (model_t - model_uncond)\n\n if self.model.parameterization == \"v\":\n e_t = self.model.predict_eps_from_z_and_v(x, t, model_output)\n else:\n e_t = model_output\n\n if score_corrector is not None:\n assert self.model.parameterization == \"eps\", 'not implemented'\n e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)\n\n alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas\n alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev\n sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas\n sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas\n # select parameters corresponding to the currently considered timestep\n a_t = torch.full((b, 1, 1, 1), alphas[index], device=device)\n a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device)\n sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device)\n sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device)\n\n # current prediction for x_0\n if self.model.parameterization != \"v\":\n pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()\n else:\n pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output)\n\n if quantize_denoised:\n pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)\n\n if dynamic_threshold is not None:\n raise NotImplementedError()\n\n # direction pointing to x_t\n dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t\n noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature\n if noise_dropout > 0.:\n noise = torch.nn.functional.dropout(noise, p=noise_dropout)\n x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise\n return x_prev, pred_x0\n\n @torch.no_grad()\n def encode(self, x0, c, t_enc, use_original_steps=False, return_intermediates=None,\n unconditional_guidance_scale=1.0, unconditional_conditioning=None, callback=None):\n num_reference_steps = self.ddpm_num_timesteps if use_original_steps else self.ddim_timesteps.shape[0]\n\n assert t_enc <= num_reference_steps\n num_steps = t_enc\n\n if use_original_steps:\n alphas_next = self.alphas_cumprod[:num_steps]\n alphas = self.alphas_cumprod_prev[:num_steps]\n else:\n alphas_next = self.ddim_alphas[:num_steps]\n alphas = torch.tensor(self.ddim_alphas_prev[:num_steps])\n\n x_next = x0\n intermediates = []\n inter_steps = []\n for i in tqdm(range(num_steps), desc='Encoding Image'):\n t = torch.full((x0.shape[0],), i, device=self.model.device, dtype=torch.long)\n if unconditional_guidance_scale == 1.:\n noise_pred = self.model.apply_model(x_next, t, c)\n else:\n assert unconditional_conditioning is not None\n e_t_uncond, noise_pred = torch.chunk(\n self.model.apply_model(torch.cat((x_next, x_next)), torch.cat((t, t)),\n torch.cat((unconditional_conditioning, c))), 2)\n noise_pred = e_t_uncond + unconditional_guidance_scale * (noise_pred - e_t_uncond)\n\n xt_weighted = (alphas_next[i] / alphas[i]).sqrt() * x_next\n weighted_noise_pred = alphas_next[i].sqrt() * (\n (1 / alphas_next[i] - 1).sqrt() - (1 / alphas[i] - 1).sqrt()) * noise_pred\n x_next = xt_weighted + weighted_noise_pred\n if return_intermediates and i % (\n num_steps // return_intermediates) == 0 and i < num_steps - 1:\n intermediates.append(x_next)\n inter_steps.append(i)\n elif return_intermediates and i >= num_steps - 2:\n intermediates.append(x_next)\n inter_steps.append(i)\n if callback: callback(i)\n\n out = {'x_encoded': x_next, 'intermediate_steps': inter_steps}\n if return_intermediates:\n out.update({'intermediates': intermediates})\n return x_next, out\n\n @torch.no_grad()\n def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):\n # fast, but does not allow for exact reconstruction\n # t serves as an index to gather the correct alphas\n if use_original_steps:\n sqrt_alphas_cumprod = self.sqrt_alphas_cumprod\n sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod\n else:\n sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas)\n sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas\n\n if noise is None:\n noise = torch.randn_like(x0)\n return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 +\n extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise)\n\n @torch.no_grad()\n def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None,\n use_original_steps=False, callback=None):\n\n timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps\n timesteps = timesteps[:t_start]\n\n time_range = np.flip(timesteps)\n total_steps = timesteps.shape[0]\n print(f\"Running DDIM Sampling with {total_steps} timesteps\")\n\n iterator = tqdm(time_range, desc='Decoding image', total=total_steps)\n x_dec = x_latent\n for i, step in enumerate(iterator):\n index = total_steps - i - 1\n ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long)\n x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps,\n unconditional_guidance_scale=unconditional_guidance_scale,\n unconditional_conditioning=unconditional_conditioning)\n if callback: callback(i)\n return x_dec"}],"string":"[\n {\n \"identifier\": \"conv_nd\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def conv_nd(dims, *args, **kwargs):\\n \\\"\\\"\\\"\\n Create a 1D, 2D, or 3D convolution module.\\n \\\"\\\"\\\"\\n if dims == 1:\\n return nn.Conv1d(*args, **kwargs)\\n elif dims == 2:\\n return nn.Conv2d(*args, **kwargs)\\n elif dims == 3:\\n return nn.Conv3d(*args, **kwargs)\\n raise ValueError(f\\\"unsupported dimensions: {dims}\\\")\"\n },\n {\n \"identifier\": \"linear\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def linear(*args, **kwargs):\\n \\\"\\\"\\\"\\n Create a linear module.\\n \\\"\\\"\\\"\\n return nn.Linear(*args, **kwargs)\"\n },\n {\n \"identifier\": \"zero_module\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def zero_module(module):\\n \\\"\\\"\\\"\\n Zero out the parameters of a module and return it.\\n \\\"\\\"\\\"\\n for p in module.parameters():\\n p.detach().zero_()\\n return module\"\n },\n {\n \"identifier\": \"timestep_embedding\",\n \"path\": \"ldm/modules/diffusionmodules/util.py\",\n \"snippet\": \"def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):\\n \\\"\\\"\\\"\\n Create sinusoidal timestep embeddings.\\n :param timesteps: a 1-D Tensor of N indices, one per batch element.\\n These may be fractional.\\n :param dim: the dimension of the output.\\n :param max_period: controls the minimum frequency of the embeddings.\\n :return: an [N x dim] Tensor of positional embeddings.\\n \\\"\\\"\\\"\\n if not repeat_only:\\n half = dim // 2\\n freqs = torch.exp(\\n -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half\\n ).to(device=timesteps.device)\\n args = timesteps[:, None].float() * freqs[None]\\n embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\\n if dim % 2:\\n embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)\\n else:\\n embedding = repeat(timesteps, 'b -> b d', d=dim)\\n return embedding\"\n },\n {\n \"identifier\": \"SpatialTransformer\",\n \"path\": \"ldm/modules/attention.py\",\n \"snippet\": \"class SpatialTransformer(nn.Module):\\n \\\"\\\"\\\"\\n Transformer block for image-like data.\\n First, project the input (aka embedding)\\n and reshape to b, t, d.\\n Then apply standard transformer action.\\n Finally, reshape to image\\n NEW: use_linear for more efficiency instead of the 1x1 convs\\n \\\"\\\"\\\"\\n def __init__(self, in_channels, n_heads, d_head,\\n depth=1, dropout=0., context_dim=None,\\n disable_self_attn=False, use_linear=False,\\n use_checkpoint=True):\\n super().__init__()\\n if exists(context_dim) and not isinstance(context_dim, list):\\n context_dim = [context_dim]\\n self.in_channels = in_channels\\n inner_dim = n_heads * d_head\\n self.norm = Normalize(in_channels)\\n if not use_linear:\\n self.proj_in = nn.Conv2d(in_channels,\\n inner_dim,\\n kernel_size=1,\\n stride=1,\\n padding=0)\\n else:\\n self.proj_in = nn.Linear(in_channels, inner_dim)\\n\\n self.transformer_blocks = nn.ModuleList(\\n [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],\\n disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)\\n for d in range(depth)]\\n )\\n if not use_linear:\\n self.proj_out = zero_module(nn.Conv2d(inner_dim,\\n in_channels,\\n kernel_size=1,\\n stride=1,\\n padding=0))\\n else:\\n self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))\\n self.use_linear = use_linear\\n\\n def forward(self, x, context=None):\\n # note: if no context is given, cross-attention defaults to self-attention\\n if not isinstance(context, list):\\n context = [context]\\n b, c, h, w = x.shape\\n x_in = x\\n x = self.norm(x)\\n if not self.use_linear:\\n x = self.proj_in(x)\\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\\n if self.use_linear:\\n x = self.proj_in(x)\\n for i, block in enumerate(self.transformer_blocks):\\n x = block(x, context=context[i])\\n if self.use_linear:\\n x = self.proj_out(x)\\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\\n if not self.use_linear:\\n x = self.proj_out(x)\\n return x + x_in\"\n },\n {\n \"identifier\": \"SpatialTransformerPlus\",\n \"path\": \"ldm/modules/attention.py\",\n \"snippet\": \"class SpatialTransformerPlus(nn.Module):\\n \\\"\\\"\\\"\\n Transformer block for image-like data.\\n First, project the input (aka embedding)\\n and reshape to b, t, d.\\n Then apply standard transformer action.\\n Finally, reshape to image\\n NEW: use_linear for more efficiency instead of the 1x1 convs\\n \\\"\\\"\\\"\\n def __init__(self, in_channels, n_heads, d_head,\\n depth=1, dropout=0., context_dim=None,\\n disable_self_attn=False, use_linear=False,\\n use_checkpoint=True, use_temporal_attention=False):\\n super().__init__()\\n if exists(context_dim) and not isinstance(context_dim, list):\\n context_dim = [context_dim]\\n self.in_channels = in_channels\\n inner_dim = n_heads * d_head\\n self.norm = Normalize(in_channels)\\n if not use_linear:\\n self.proj_in = nn.Conv2d(in_channels,\\n inner_dim,\\n kernel_size=1,\\n stride=1,\\n padding=0)\\n else:\\n self.proj_in = nn.Linear(in_channels, inner_dim)\\n\\n self.transformer_blocks = nn.ModuleList(\\n [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],\\n disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)\\n for d in range(depth)]\\n )\\n if not use_linear:\\n self.proj_out = zero_module(nn.Conv2d(inner_dim,\\n in_channels,\\n kernel_size=1,\\n stride=1,\\n padding=0))\\n else:\\n self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))\\n self.use_linear = use_linear\\n self.spatial_attn = SpatialSelfAttention(in_channels)\\n if use_temporal_attention:\\n self.temporal_attn = TemporalTransformer(in_channels)\\n\\n def forward(self, x, context=None, ref=None):\\n x = torch.cat([x, ref], dim=-1)\\n x = self.spatial_attn(x)\\n x = x[..., :ref.shape[-1]]\\n # note: if no context is given, cross-attention defaults to self-attention\\n if not isinstance(context, list):\\n context = [context]\\n b, c, h, w = x.shape\\n x_in = x\\n x = self.norm(x)\\n if not self.use_linear:\\n x = self.proj_in(x)\\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\\n if self.use_linear:\\n x = self.proj_in(x)\\n for i, block in enumerate(self.transformer_blocks):\\n x = block(x, context=context[i])\\n if self.use_linear:\\n x = self.proj_out(x)\\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\\n if not self.use_linear:\\n x = self.proj_out(x)\\n return x + x_in\"\n },\n {\n \"identifier\": \"ResBlock\",\n \"path\": \"ldm/modules/diffusionmodules/openaimodel.py\",\n \"snippet\": \"def convert_module_to_f16(x):\\ndef convert_module_to_f32(x):\\n def __init__(\\n self,\\n spacial_dim: int,\\n embed_dim: int,\\n num_heads_channels: int,\\n output_dim: int = None,\\n ):\\n def forward(self, x):\\n def forward(self, x, emb):\\n def forward(self, x, emb, context=None):\\n def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):\\n def forward(self, x):\\n def __init__(self, channels, out_channels=None, ks=5):\\n def forward(self,x):\\n def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):\\n def forward(self, x):\\n def __init__(\\n self,\\n channels,\\n emb_channels,\\n dropout,\\n out_channels=None,\\n use_conv=False,\\n use_scale_shift_norm=False,\\n dims=2,\\n use_checkpoint=False,\\n up=False,\\n down=False,\\n ):\\n def forward(self, x, emb):\\n def _forward(self, x, emb):\\n def __init__(\\n self,\\n channels,\\n dropout,\\n out_channels=None,\\n use_conv=False,\\n dims=2,\\n use_checkpoint=False,\\n up=False,\\n down=False,\\n ):\\n def forward(self, x):\\n def _forward(self, x):\\n def __init__(\\n self,\\n channels,\\n num_heads=1,\\n num_head_channels=-1,\\n use_checkpoint=False,\\n use_new_attention_order=False,\\n ):\\n def forward(self, x):\\n def _forward(self, x):\\ndef count_flops_attn(model, _x, y):\\n def __init__(self, n_heads):\\n def forward(self, qkv):\\n def count_flops(model, _x, y):\\n def __init__(self, n_heads):\\n def forward(self, qkv):\\n def count_flops(model, _x, y):\\n def __init__(\\n self,\\n image_size,\\n in_channels,\\n model_channels,\\n out_channels,\\n num_res_blocks,\\n attention_resolutions,\\n dropout=0,\\n channel_mult=(1, 2, 4, 8),\\n conv_resample=True,\\n dims=2,\\n num_classes=None,\\n use_checkpoint=False,\\n use_fp16=False,\\n num_heads=-1,\\n num_head_channels=-1,\\n num_heads_upsample=-1,\\n use_scale_shift_norm=False,\\n resblock_updown=False,\\n use_new_attention_order=False,\\n use_spatial_transformer=False, # custom transformer support\\n transformer_depth=1, # custom transformer support\\n context_dim=None, # custom transformer support\\n n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model\\n legacy=True,\\n disable_self_attentions=None,\\n num_attention_blocks=None,\\n disable_middle_self_attn=False,\\n use_linear_in_transformer=False,\\n ):\\n def convert_to_fp16(self):\\n def convert_to_fp32(self):\\n def forward(self, x, timesteps=None, context=None, y=None,**kwargs):\\nclass AttentionPool2d(nn.Module):\\nclass TimestepBlock(nn.Module):\\nclass TimestepEmbedSequential(nn.Sequential, TimestepBlock):\\nclass Upsample(nn.Module):\\nclass TransposedUpsample(nn.Module):\\nclass Downsample(nn.Module):\\nclass ResBlock(TimestepBlock):\\nclass ResBlockNoTime(TimestepBlock):\\nclass AttentionBlock(nn.Module):\\nclass QKVAttentionLegacy(nn.Module):\\nclass QKVAttention(nn.Module):\\nclass UNetModel(nn.Module):\"\n },\n {\n \"identifier\": \"LatentDiffusion\",\n \"path\": \"ldm/models/diffusion/ddpm.py\",\n \"snippet\": \"class LatentDiffusion(DDPM):\\n \\\"\\\"\\\"main class\\\"\\\"\\\"\\n\\n def __init__(self,\\n first_stage_config,\\n cond_stage_config,\\n num_timesteps_cond=None,\\n cond_stage_key=\\\"image\\\",\\n cond_stage_trainable=False,\\n concat_mode=True,\\n cond_stage_forward=None,\\n conditioning_key=None,\\n scale_factor=1.0,\\n scale_by_std=False,\\n force_null_conditioning=False,\\n *args, **kwargs):\\n self.force_null_conditioning = force_null_conditioning\\n self.num_timesteps_cond = default(num_timesteps_cond, 1)\\n self.scale_by_std = scale_by_std\\n assert self.num_timesteps_cond <= kwargs['timesteps']\\n # for backwards compatibility after implementation of DiffusionWrapper\\n if conditioning_key is None:\\n conditioning_key = 'concat' if concat_mode else 'crossattn'\\n if cond_stage_config == '__is_unconditional__' and not self.force_null_conditioning:\\n conditioning_key = None\\n ckpt_path = kwargs.pop(\\\"ckpt_path\\\", None)\\n reset_ema = kwargs.pop(\\\"reset_ema\\\", False)\\n reset_num_ema_updates = kwargs.pop(\\\"reset_num_ema_updates\\\", False)\\n ignore_keys = kwargs.pop(\\\"ignore_keys\\\", [])\\n super().__init__(conditioning_key=conditioning_key, *args, **kwargs)\\n self.concat_mode = concat_mode\\n self.cond_stage_trainable = cond_stage_trainable\\n self.cond_stage_key = cond_stage_key\\n try:\\n self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1\\n except:\\n self.num_downs = 0\\n if not scale_by_std:\\n self.scale_factor = scale_factor\\n else:\\n self.register_buffer('scale_factor', torch.tensor(scale_factor))\\n self.instantiate_first_stage(first_stage_config)\\n self.instantiate_cond_stage(cond_stage_config)\\n self.cond_stage_forward = cond_stage_forward\\n self.clip_denoised = False\\n self.bbox_tokenizer = None\\n\\n self.restarted_from_ckpt = False\\n if ckpt_path is not None:\\n self.init_from_ckpt(ckpt_path, ignore_keys)\\n self.restarted_from_ckpt = True\\n if reset_ema:\\n assert self.use_ema\\n print(\\n f\\\"Resetting ema to pure model weights. This is useful when restoring from an ema-only checkpoint.\\\")\\n self.model_ema = LitEma(self.model)\\n if reset_num_ema_updates:\\n print(\\\" +++++++++++ WARNING: RESETTING NUM_EMA UPDATES TO ZERO +++++++++++ \\\")\\n assert self.use_ema\\n self.model_ema.reset_num_updates()\\n\\n def make_cond_schedule(self, ):\\n self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)\\n ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()\\n self.cond_ids[:self.num_timesteps_cond] = ids\\n\\n @rank_zero_only\\n @torch.no_grad()\\n def on_train_batch_start(self, batch, batch_idx, dataloader_idx):\\n # only for very first batch\\n if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:\\n assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'\\n # set rescale weight to 1./std of encodings\\n print(\\\"### USING STD-RESCALING ###\\\")\\n x = super().get_input(batch, self.first_stage_key)\\n x = x.to(self.device)\\n encoder_posterior = self.encode_first_stage(x)\\n z = self.get_first_stage_encoding(encoder_posterior).detach()\\n del self.scale_factor\\n self.register_buffer('scale_factor', 1. / z.flatten().std())\\n print(f\\\"setting self.scale_factor to {self.scale_factor}\\\")\\n print(\\\"### USING STD-RESCALING ###\\\")\\n\\n def register_schedule(self,\\n given_betas=None, beta_schedule=\\\"linear\\\", timesteps=1000,\\n linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):\\n super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)\\n\\n self.shorten_cond_schedule = self.num_timesteps_cond > 1\\n if self.shorten_cond_schedule:\\n self.make_cond_schedule()\\n\\n def instantiate_first_stage(self, config):\\n model = instantiate_from_config(config)\\n self.first_stage_model = model.eval()\\n self.first_stage_model.train = disabled_train\\n for param in self.first_stage_model.parameters():\\n param.requires_grad = False\\n\\n def instantiate_cond_stage(self, config):\\n if not self.cond_stage_trainable:\\n if config == \\\"__is_first_stage__\\\":\\n print(\\\"Using first stage also as cond stage.\\\")\\n self.cond_stage_model = self.first_stage_model\\n elif config == \\\"__is_unconditional__\\\":\\n print(f\\\"Training {self.__class__.__name__} as an unconditional model.\\\")\\n self.cond_stage_model = None\\n # self.be_unconditional = True\\n else:\\n model = instantiate_from_config(config)\\n self.cond_stage_model = model.eval()\\n self.cond_stage_model.train = disabled_train\\n for param in self.cond_stage_model.parameters():\\n param.requires_grad = False\\n else:\\n assert config != '__is_first_stage__'\\n assert config != '__is_unconditional__'\\n model = instantiate_from_config(config)\\n self.cond_stage_model = model\\n\\n def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False):\\n denoise_row = []\\n for zd in tqdm(samples, desc=desc):\\n denoise_row.append(self.decode_first_stage(zd.to(self.device),\\n force_not_quantize=force_no_decoder_quantization))\\n n_imgs_per_row = len(denoise_row)\\n denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W\\n denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')\\n denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')\\n denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)\\n return denoise_grid\\n\\n def get_first_stage_encoding(self, encoder_posterior):\\n if isinstance(encoder_posterior, DiagonalGaussianDistribution):\\n z = encoder_posterior.sample()\\n elif isinstance(encoder_posterior, torch.Tensor):\\n z = encoder_posterior\\n else:\\n raise NotImplementedError(f\\\"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented\\\")\\n return self.scale_factor * z\\n\\n def get_learned_conditioning(self, c):\\n if self.cond_stage_forward is None:\\n if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):\\n c = self.cond_stage_model.encode(c)\\n if isinstance(c, DiagonalGaussianDistribution):\\n c = c.mode()\\n else:\\n c = self.cond_stage_model(c)\\n else:\\n assert hasattr(self.cond_stage_model, self.cond_stage_forward)\\n c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)\\n return c\\n\\n def meshgrid(self, h, w):\\n y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)\\n x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)\\n\\n arr = torch.cat([y, x], dim=-1)\\n return arr\\n\\n def delta_border(self, h, w):\\n \\\"\\\"\\\"\\n :param h: height\\n :param w: width\\n :return: normalized distance to image border,\\n wtith min distance = 0 at border and max dist = 0.5 at image center\\n \\\"\\\"\\\"\\n lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)\\n arr = self.meshgrid(h, w) / lower_right_corner\\n dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]\\n dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]\\n edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]\\n return edge_dist\\n\\n def get_weighting(self, h, w, Ly, Lx, device):\\n weighting = self.delta_border(h, w)\\n weighting = torch.clip(weighting, self.split_input_params[\\\"clip_min_weight\\\"],\\n self.split_input_params[\\\"clip_max_weight\\\"], )\\n weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)\\n\\n if self.split_input_params[\\\"tie_braker\\\"]:\\n L_weighting = self.delta_border(Ly, Lx)\\n L_weighting = torch.clip(L_weighting,\\n self.split_input_params[\\\"clip_min_tie_weight\\\"],\\n self.split_input_params[\\\"clip_max_tie_weight\\\"])\\n\\n L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)\\n weighting = weighting * L_weighting\\n return weighting\\n\\n def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1): # todo load once not every time, shorten code\\n \\\"\\\"\\\"\\n :param x: img of size (bs, c, h, w)\\n :return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])\\n \\\"\\\"\\\"\\n bs, nc, h, w = x.shape\\n\\n # number of crops in image\\n Ly = (h - kernel_size[0]) // stride[0] + 1\\n Lx = (w - kernel_size[1]) // stride[1] + 1\\n\\n if uf == 1 and df == 1:\\n fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)\\n unfold = torch.nn.Unfold(**fold_params)\\n\\n fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)\\n\\n weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype)\\n normalization = fold(weighting).view(1, 1, h, w) # normalizes the overlap\\n weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))\\n\\n elif uf > 1 and df == 1:\\n fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)\\n unfold = torch.nn.Unfold(**fold_params)\\n\\n fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),\\n dilation=1, padding=0,\\n stride=(stride[0] * uf, stride[1] * uf))\\n fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)\\n\\n weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype)\\n normalization = fold(weighting).view(1, 1, h * uf, w * uf) # normalizes the overlap\\n weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))\\n\\n elif df > 1 and uf == 1:\\n fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)\\n unfold = torch.nn.Unfold(**fold_params)\\n\\n fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df),\\n dilation=1, padding=0,\\n stride=(stride[0] // df, stride[1] // df))\\n fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2)\\n\\n weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype)\\n normalization = fold(weighting).view(1, 1, h // df, w // df) # normalizes the overlap\\n weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))\\n\\n else:\\n raise NotImplementedError\\n\\n return fold, unfold, normalization, weighting\\n\\n @torch.no_grad()\\n def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,\\n cond_key=None, return_original_cond=False, bs=None, return_x=False):\\n x = super().get_input(batch, k)\\n if bs is not None:\\n x = x[:bs]\\n x = x.to(self.device)\\n encoder_posterior = self.encode_first_stage(x)\\n z = self.get_first_stage_encoding(encoder_posterior).detach()\\n\\n if self.model.conditioning_key is not None and not self.force_null_conditioning:\\n if cond_key is None:\\n cond_key = self.cond_stage_key\\n if cond_key != self.first_stage_key:\\n if cond_key in ['caption', 'coordinates_bbox', 'txt', 'vision']:\\n xc = batch[cond_key]\\n xc = rearrange(xc, 'b h w c -> b c h w')\\n elif cond_key in ['class_label', 'cls']:\\n xc = batch\\n else:\\n xc = super().get_input(batch, cond_key).to(self.device)\\n else:\\n xc = x\\n if not self.cond_stage_trainable or force_c_encode:\\n if isinstance(xc, dict) or isinstance(xc, list):\\n c = self.get_learned_conditioning(xc)\\n else:\\n c = self.get_learned_conditioning(xc.to(self.device))\\n else:\\n c = xc\\n if bs is not None:\\n c = c[:bs]\\n\\n if self.use_positional_encodings:\\n pos_x, pos_y = self.compute_latent_shifts(batch)\\n ckey = __conditioning_keys__[self.model.conditioning_key]\\n c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}\\n\\n else:\\n c = None\\n xc = None\\n if self.use_positional_encodings:\\n pos_x, pos_y = self.compute_latent_shifts(batch)\\n c = {'pos_x': pos_x, 'pos_y': pos_y}\\n out = [z, c]\\n if return_first_stage_outputs:\\n xrec = self.decode_first_stage(z)\\n out.extend([x, xrec])\\n if return_x:\\n out.extend([x])\\n if return_original_cond:\\n out.append(xc)\\n return out\\n\\n @torch.no_grad()\\n def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):\\n if predict_cids:\\n if z.dim() == 4:\\n z = torch.argmax(z.exp(), dim=1).long()\\n z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)\\n z = rearrange(z, 'b h w c -> b c h w').contiguous()\\n\\n z = 1. / self.scale_factor * z\\n return self.first_stage_model.decode(z)\\n\\n @torch.no_grad()\\n def encode_first_stage(self, x):\\n return self.first_stage_model.encode(x)\\n\\n def shared_step(self, batch, **kwargs):\\n x, c = self.get_input(batch, self.first_stage_key)\\n loss = self(x, c)\\n return loss\\n\\n def forward(self, x, c, *args, **kwargs):\\n t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()\\n if self.model.conditioning_key is not None:\\n assert c is not None\\n if self.cond_stage_trainable:\\n c = self.get_learned_conditioning(c)\\n if self.shorten_cond_schedule: # TODO: drop this option\\n tc = self.cond_ids[t].to(self.device)\\n c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))\\n return self.p_losses(x, c, t, *args, **kwargs)\\n\\n def apply_model(self, x_noisy, t, cond, return_ids=False):\\n if isinstance(cond, dict):\\n # hybrid case, cond is expected to be a dict\\n pass\\n else:\\n if not isinstance(cond, list):\\n cond = [cond]\\n key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'\\n cond = {key: cond}\\n\\n x_recon = self.model(x_noisy, t, **cond)\\n\\n if isinstance(x_recon, tuple) and not return_ids:\\n return x_recon[0]\\n else:\\n return x_recon\\n\\n def _predict_eps_from_xstart(self, x_t, t, pred_xstart):\\n return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \\\\\\n extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)\\n\\n def _prior_bpd(self, x_start):\\n \\\"\\\"\\\"\\n Get the prior KL term for the variational lower-bound, measured in\\n bits-per-dim.\\n This term can't be optimized, as it only depends on the encoder.\\n :param x_start: the [N x C x ...] tensor of inputs.\\n :return: a batch of [N] KL values (in bits), one per batch element.\\n \\\"\\\"\\\"\\n batch_size = x_start.shape[0]\\n t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)\\n qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)\\n kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)\\n return mean_flat(kl_prior) / np.log(2.0)\\n\\n def p_losses(self, x_start, cond, t, noise=None):\\n noise = default(noise, lambda: torch.randn_like(x_start))\\n x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)\\n model_output = self.apply_model(x_noisy, t, cond)\\n \\n loss_dict = {}\\n prefix = 'train' if self.training else 'val'\\n\\n if self.parameterization == \\\"x0\\\":\\n target = x_start\\n elif self.parameterization == \\\"eps\\\":\\n target = noise\\n elif self.parameterization == \\\"v\\\":\\n target = self.get_v(x_start, noise, t)\\n else:\\n raise NotImplementedError()\\n\\n loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])\\n loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})\\n\\n logvar_t = self.logvar[t].to(self.device)\\n loss = loss_simple / torch.exp(logvar_t) + logvar_t\\n # loss = loss_simple / torch.exp(self.logvar) + self.logvar\\n if self.learn_logvar:\\n loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})\\n loss_dict.update({'logvar': self.logvar.data.mean()})\\n\\n loss = self.l_simple_weight * loss.mean()\\n\\n loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))\\n loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()\\n loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})\\n loss += (self.original_elbo_weight * loss_vlb)\\n loss_dict.update({f'{prefix}/loss': loss})\\n return loss, loss_dict\\n\\n def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,\\n return_x0=False, score_corrector=None, corrector_kwargs=None):\\n t_in = t\\n model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)\\n\\n if score_corrector is not None:\\n assert self.parameterization == \\\"eps\\\"\\n model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)\\n\\n if return_codebook_ids:\\n model_out, logits = model_out\\n\\n if self.parameterization == \\\"eps\\\":\\n x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)\\n elif self.parameterization == \\\"x0\\\":\\n x_recon = model_out\\n else:\\n raise NotImplementedError()\\n\\n if clip_denoised:\\n x_recon.clamp_(-1., 1.)\\n if quantize_denoised:\\n x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)\\n model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)\\n if return_codebook_ids:\\n return model_mean, posterior_variance, posterior_log_variance, logits\\n elif return_x0:\\n return model_mean, posterior_variance, posterior_log_variance, x_recon\\n else:\\n return model_mean, posterior_variance, posterior_log_variance\\n\\n @torch.no_grad()\\n def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,\\n return_codebook_ids=False, quantize_denoised=False, return_x0=False,\\n temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):\\n b, *_, device = *x.shape, x.device\\n outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,\\n return_codebook_ids=return_codebook_ids,\\n quantize_denoised=quantize_denoised,\\n return_x0=return_x0,\\n score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)\\n if return_codebook_ids:\\n raise DeprecationWarning(\\\"Support dropped.\\\")\\n model_mean, _, model_log_variance, logits = outputs\\n elif return_x0:\\n model_mean, _, model_log_variance, x0 = outputs\\n else:\\n model_mean, _, model_log_variance = outputs\\n\\n noise = noise_like(x.shape, device, repeat_noise) * temperature\\n if noise_dropout > 0.:\\n noise = torch.nn.functional.dropout(noise, p=noise_dropout)\\n # no noise when t == 0\\n nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))\\n\\n if return_codebook_ids:\\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)\\n if return_x0:\\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0\\n else:\\n return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise\\n\\n @torch.no_grad()\\n def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,\\n img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,\\n score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,\\n log_every_t=None):\\n if not log_every_t:\\n log_every_t = self.log_every_t\\n timesteps = self.num_timesteps\\n if batch_size is not None:\\n b = batch_size if batch_size is not None else shape[0]\\n shape = [batch_size] + list(shape)\\n else:\\n b = batch_size = shape[0]\\n if x_T is None:\\n img = torch.randn(shape, device=self.device)\\n else:\\n img = x_T\\n intermediates = []\\n if cond is not None:\\n if isinstance(cond, dict):\\n cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else\\n list(map(lambda x: x[:batch_size], cond[key])) for key in cond}\\n else:\\n cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]\\n\\n if start_T is not None:\\n timesteps = min(timesteps, start_T)\\n iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',\\n total=timesteps) if verbose else reversed(\\n range(0, timesteps))\\n if type(temperature) == float:\\n temperature = [temperature] * timesteps\\n\\n for i in iterator:\\n ts = torch.full((b,), i, device=self.device, dtype=torch.long)\\n if self.shorten_cond_schedule:\\n assert self.model.conditioning_key != 'hybrid'\\n tc = self.cond_ids[ts].to(cond.device)\\n cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))\\n\\n img, x0_partial = self.p_sample(img, cond, ts,\\n clip_denoised=self.clip_denoised,\\n quantize_denoised=quantize_denoised, return_x0=True,\\n temperature=temperature[i], noise_dropout=noise_dropout,\\n score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)\\n if mask is not None:\\n assert x0 is not None\\n img_orig = self.q_sample(x0, ts)\\n img = img_orig * mask + (1. - mask) * img\\n\\n if i % log_every_t == 0 or i == timesteps - 1:\\n intermediates.append(x0_partial)\\n if callback: callback(i)\\n if img_callback: img_callback(img, i)\\n return img, intermediates\\n\\n @torch.no_grad()\\n def p_sample_loop(self, cond, shape, return_intermediates=False,\\n x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,\\n mask=None, x0=None, img_callback=None, start_T=None,\\n log_every_t=None):\\n\\n if not log_every_t:\\n log_every_t = self.log_every_t\\n device = self.betas.device\\n b = shape[0]\\n if x_T is None:\\n img = torch.randn(shape, device=device)\\n else:\\n img = x_T\\n\\n intermediates = [img]\\n if timesteps is None:\\n timesteps = self.num_timesteps\\n\\n if start_T is not None:\\n timesteps = min(timesteps, start_T)\\n iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(\\n range(0, timesteps))\\n\\n if mask is not None:\\n assert x0 is not None\\n assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match\\n\\n for i in iterator:\\n ts = torch.full((b,), i, device=device, dtype=torch.long)\\n if self.shorten_cond_schedule:\\n assert self.model.conditioning_key != 'hybrid'\\n tc = self.cond_ids[ts].to(cond.device)\\n cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))\\n\\n img = self.p_sample(img, cond, ts,\\n clip_denoised=self.clip_denoised,\\n quantize_denoised=quantize_denoised)\\n if mask is not None:\\n img_orig = self.q_sample(x0, ts)\\n img = img_orig * mask + (1. - mask) * img\\n\\n if i % log_every_t == 0 or i == timesteps - 1:\\n intermediates.append(img)\\n if callback: callback(i)\\n if img_callback: img_callback(img, i)\\n\\n if return_intermediates:\\n return img, intermediates\\n return img\\n\\n @torch.no_grad()\\n def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,\\n verbose=True, timesteps=None, quantize_denoised=False,\\n mask=None, x0=None, shape=None, **kwargs):\\n if shape is None:\\n shape = (batch_size, self.channels, self.image_size, self.image_size)\\n if cond is not None:\\n if isinstance(cond, dict):\\n cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else\\n list(map(lambda x: x[:batch_size], cond[key])) for key in cond}\\n else:\\n cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]\\n return self.p_sample_loop(cond,\\n shape,\\n return_intermediates=return_intermediates, x_T=x_T,\\n verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,\\n mask=mask, x0=x0)\\n\\n @torch.no_grad()\\n def sample_log(self, cond, batch_size, ddim, ddim_steps, **kwargs):\\n if ddim:\\n ddim_sampler = DDIMSampler(self)\\n shape = (self.channels, self.image_size, self.image_size)\\n samples, intermediates = ddim_sampler.sample(ddim_steps, batch_size,\\n shape, cond, verbose=False, **kwargs)\\n\\n else:\\n samples, intermediates = self.sample(cond=cond, batch_size=batch_size,\\n return_intermediates=True, **kwargs)\\n\\n return samples, intermediates\\n\\n @torch.no_grad()\\n def get_unconditional_conditioning(self, batch_size, null_label=None):\\n if null_label is not None:\\n xc = null_label\\n if isinstance(xc, ListConfig):\\n xc = list(xc)\\n if isinstance(xc, dict) or isinstance(xc, list):\\n c = self.get_learned_conditioning(xc)\\n else:\\n if hasattr(xc, \\\"to\\\"):\\n xc = xc.to(self.device)\\n c = self.get_learned_conditioning(xc)\\n else:\\n if self.cond_stage_key in [\\\"class_label\\\", \\\"cls\\\"]:\\n xc = self.cond_stage_model.get_unconditional_conditioning(batch_size, device=self.device)\\n return self.get_learned_conditioning(xc)\\n else:\\n raise NotImplementedError(\\\"todo\\\")\\n if isinstance(c, list): # in case the encoder gives us a list\\n for i in range(len(c)):\\n c[i] = repeat(c[i], '1 ... -> b ...', b=batch_size).to(self.device)\\n else:\\n c = repeat(c, '1 ... -> b ...', b=batch_size).to(self.device)\\n return c\\n\\n @torch.no_grad()\\n def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=50, ddim_eta=0., return_keys=None,\\n quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,\\n plot_diffusion_rows=True, unconditional_guidance_scale=1., unconditional_guidance_label=None,\\n use_ema_scope=True,\\n **kwargs):\\n ema_scope = self.ema_scope if use_ema_scope else nullcontext\\n use_ddim = ddim_steps is not None\\n\\n log = dict()\\n z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,\\n return_first_stage_outputs=True,\\n force_c_encode=True,\\n return_original_cond=True,\\n bs=N)\\n N = min(x.shape[0], N)\\n n_row = min(x.shape[0], n_row)\\n log[\\\"inputs\\\"] = x\\n log[\\\"reconstruction\\\"] = xrec\\n if self.model.conditioning_key is not None:\\n if hasattr(self.cond_stage_model, \\\"decode\\\"):\\n xc = self.cond_stage_model.decode(c)\\n log[\\\"conditioning\\\"] = xc\\n elif self.cond_stage_key in [\\\"caption\\\", \\\"txt\\\"]:\\n xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[self.cond_stage_key], size=x.shape[2] // 25)\\n log[\\\"conditioning\\\"] = xc\\n elif self.cond_stage_key in ['class_label', \\\"cls\\\"]:\\n try:\\n xc = log_txt_as_img((x.shape[2], x.shape[3]), batch[\\\"human_label\\\"], size=x.shape[2] // 25)\\n log['conditioning'] = xc\\n except KeyError:\\n # probably no \\\"human_label\\\" in batch\\n pass\\n elif isimage(xc):\\n log[\\\"conditioning\\\"] = xc\\n if ismap(xc):\\n log[\\\"original_conditioning\\\"] = self.to_rgb(xc)\\n\\n if plot_diffusion_rows:\\n # get diffusion row\\n diffusion_row = list()\\n z_start = z[:n_row]\\n for t in range(self.num_timesteps):\\n if t % self.log_every_t == 0 or t == self.num_timesteps - 1:\\n t = repeat(torch.tensor([t]), '1 -> b', b=n_row)\\n t = t.to(self.device).long()\\n noise = torch.randn_like(z_start)\\n z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)\\n diffusion_row.append(self.decode_first_stage(z_noisy))\\n\\n diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W\\n diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')\\n diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')\\n diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])\\n log[\\\"diffusion_row\\\"] = diffusion_grid\\n\\n if sample:\\n # get denoise row\\n with ema_scope(\\\"Sampling\\\"):\\n samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,\\n ddim_steps=ddim_steps, eta=ddim_eta)\\n # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)\\n x_samples = self.decode_first_stage(samples)\\n log[\\\"samples\\\"] = x_samples\\n if plot_denoise_rows:\\n denoise_grid = self._get_denoise_row_from_list(z_denoise_row)\\n log[\\\"denoise_row\\\"] = denoise_grid\\n\\n if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance(\\n self.first_stage_model, IdentityFirstStage):\\n # also display when quantizing x0 while sampling\\n with ema_scope(\\\"Plotting Quantized Denoised\\\"):\\n samples, z_denoise_row = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,\\n ddim_steps=ddim_steps, eta=ddim_eta,\\n quantize_denoised=True)\\n # samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,\\n # quantize_denoised=True)\\n x_samples = self.decode_first_stage(samples.to(self.device))\\n log[\\\"samples_x0_quantized\\\"] = x_samples\\n\\n if unconditional_guidance_scale > 1.0:\\n uc = self.get_unconditional_conditioning(N, unconditional_guidance_label)\\n if self.model.conditioning_key == \\\"crossattn-adm\\\":\\n uc = {\\\"c_crossattn\\\": [uc], \\\"c_adm\\\": c[\\\"c_adm\\\"]}\\n with ema_scope(\\\"Sampling with classifier-free guidance\\\"):\\n samples_cfg, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,\\n ddim_steps=ddim_steps, eta=ddim_eta,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=uc,\\n )\\n x_samples_cfg = self.decode_first_stage(samples_cfg)\\n log[f\\\"samples_cfg_scale_{unconditional_guidance_scale:.2f}\\\"] = x_samples_cfg\\n\\n if inpaint:\\n # make a simple center square\\n b, h, w = z.shape[0], z.shape[2], z.shape[3]\\n mask = torch.ones(N, h, w).to(self.device)\\n # zeros will be filled in\\n mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.\\n mask = mask[:, None, ...]\\n with ema_scope(\\\"Plotting Inpaint\\\"):\\n samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta,\\n ddim_steps=ddim_steps, x0=z[:N], mask=mask)\\n x_samples = self.decode_first_stage(samples.to(self.device))\\n log[\\\"samples_inpainting\\\"] = x_samples\\n log[\\\"mask\\\"] = mask\\n\\n # outpaint\\n mask = 1. - mask\\n with ema_scope(\\\"Plotting Outpaint\\\"):\\n samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim, eta=ddim_eta,\\n ddim_steps=ddim_steps, x0=z[:N], mask=mask)\\n x_samples = self.decode_first_stage(samples.to(self.device))\\n log[\\\"samples_outpainting\\\"] = x_samples\\n\\n if plot_progressive_rows:\\n with ema_scope(\\\"Plotting Progressives\\\"):\\n img, progressives = self.progressive_denoising(c,\\n shape=(self.channels, self.image_size, self.image_size),\\n batch_size=N)\\n prog_row = self._get_denoise_row_from_list(progressives, desc=\\\"Progressive Generation\\\")\\n log[\\\"progressive_row\\\"] = prog_row\\n\\n if return_keys:\\n if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:\\n return log\\n else:\\n return {key: log[key] for key in return_keys}\\n return log\\n\\n def configure_optimizers(self):\\n lr = self.learning_rate\\n params = list(self.model.parameters())\\n if self.cond_stage_trainable:\\n print(f\\\"{self.__class__.__name__}: Also optimizing conditioner params!\\\")\\n params = params + list(self.cond_stage_model.parameters())\\n if self.learn_logvar:\\n print('Diffusion model optimizing logvar')\\n params.append(self.logvar)\\n opt = torch.optim.AdamW(params, lr=lr)\\n if self.use_scheduler:\\n assert 'target' in self.scheduler_config\\n scheduler = instantiate_from_config(self.scheduler_config)\\n\\n print(\\\"Setting up LambdaLR scheduler...\\\")\\n scheduler = [\\n {\\n 'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),\\n 'interval': 'step',\\n 'frequency': 1\\n }]\\n return [opt], scheduler\\n return opt\\n\\n @torch.no_grad()\\n def to_rgb(self, x):\\n x = x.float()\\n if not hasattr(self, \\\"colorize\\\"):\\n self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)\\n x = nn.functional.conv2d(x, weight=self.colorize)\\n x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.\\n return x\"\n },\n {\n \"identifier\": \"log_txt_as_img\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def log_txt_as_img(wh, xc, size=10):\\n # wh a tuple of (width, height)\\n # xc a list of captions to plot\\n b = len(xc)\\n txts = list()\\n for bi in range(b):\\n txt = Image.new(\\\"RGB\\\", wh, color=\\\"white\\\")\\n draw = ImageDraw.Draw(txt)\\n font = ImageFont.truetype('font/DejaVuSans.ttf', size=size)\\n nc = int(40 * (wh[0] / 256))\\n lines = \\\"\\\\n\\\".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc))\\n\\n try:\\n draw.text((0, 0), lines, fill=\\\"black\\\", font=font)\\n except UnicodeEncodeError:\\n print(\\\"Cant encode string for logging. Skipping.\\\")\\n\\n txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0\\n txts.append(txt)\\n txts = np.stack(txts)\\n txts = torch.tensor(txts)\\n return txts\"\n },\n {\n \"identifier\": \"exists\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def exists(x):\\n return x is not None\"\n },\n {\n \"identifier\": \"instantiate_from_config\",\n \"path\": \"ldm/util.py\",\n \"snippet\": \"def instantiate_from_config(config):\\n if not \\\"target\\\" in config:\\n if config == '__is_first_stage__':\\n return None\\n elif config == \\\"__is_unconditional__\\\":\\n return None\\n raise KeyError(\\\"Expected key `target` to instantiate.\\\")\\n return get_obj_from_str(config[\\\"target\\\"])(**config.get(\\\"params\\\", dict()))\"\n },\n {\n \"identifier\": \"DDIMSampler\",\n \"path\": \"ldm/models/diffusion/ddim.py\",\n \"snippet\": \"class DDIMSampler(object):\\n def __init__(self, model, schedule=\\\"linear\\\", **kwargs):\\n super().__init__()\\n self.model = model\\n self.ddpm_num_timesteps = model.num_timesteps\\n self.schedule = schedule\\n\\n def register_buffer(self, name, attr):\\n if type(attr) == torch.Tensor:\\n if attr.device != torch.device(\\\"cuda\\\"):\\n attr = attr.to(torch.device(\\\"cuda\\\"))\\n setattr(self, name, attr)\\n\\n def make_schedule(self, ddim_num_steps, ddim_discretize=\\\"uniform\\\", ddim_eta=0., verbose=True):\\n self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,\\n num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)\\n alphas_cumprod = self.model.alphas_cumprod\\n assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'\\n to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)\\n\\n self.register_buffer('betas', to_torch(self.model.betas))\\n self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))\\n self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))\\n\\n # calculations for diffusion q(x_t | x_{t-1}) and others\\n self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))\\n self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))\\n self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))\\n\\n # ddim sampling parameters\\n ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),\\n ddim_timesteps=self.ddim_timesteps,\\n eta=ddim_eta,verbose=verbose)\\n self.register_buffer('ddim_sigmas', ddim_sigmas)\\n self.register_buffer('ddim_alphas', ddim_alphas)\\n self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)\\n self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))\\n sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(\\n (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (\\n 1 - self.alphas_cumprod / self.alphas_cumprod_prev))\\n self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)\\n\\n @torch.no_grad()\\n def sample(self,\\n S,\\n batch_size,\\n shape,\\n conditioning=None,\\n callback=None,\\n normals_sequence=None,\\n img_callback=None,\\n quantize_x0=False,\\n eta=0.,\\n mask=None,\\n x0=None,\\n temperature=1.,\\n noise_dropout=0.,\\n score_corrector=None,\\n corrector_kwargs=None,\\n verbose=True,\\n x_T=None,\\n log_every_t=100,\\n unconditional_guidance_scale=1.,\\n unconditional_conditioning=None, # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...\\n dynamic_threshold=None,\\n ucg_schedule=None,\\n **kwargs\\n ):\\n if conditioning is not None:\\n if isinstance(conditioning, dict):\\n ctmp = conditioning[list(conditioning.keys())[0]]\\n while isinstance(ctmp, list): ctmp = ctmp[0]\\n cbs = ctmp.shape[0]\\n if cbs != batch_size:\\n print(f\\\"Warning: Got {cbs} conditionings but batch-size is {batch_size}\\\")\\n\\n elif isinstance(conditioning, list):\\n for ctmp in conditioning:\\n if ctmp.shape[0] != batch_size:\\n print(f\\\"Warning: Got {cbs} conditionings but batch-size is {batch_size}\\\")\\n\\n else:\\n if conditioning.shape[0] != batch_size:\\n print(f\\\"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}\\\")\\n\\n self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose)\\n # sampling\\n C, H, W = shape\\n size = (batch_size, C, H, W)\\n print(f'Data shape for DDIM sampling is {size}, eta {eta}')\\n\\n samples, intermediates = self.ddim_sampling(conditioning, size,\\n callback=callback,\\n img_callback=img_callback,\\n quantize_denoised=quantize_x0,\\n mask=mask, x0=x0,\\n ddim_use_original_steps=False,\\n noise_dropout=noise_dropout,\\n temperature=temperature,\\n score_corrector=score_corrector,\\n corrector_kwargs=corrector_kwargs,\\n x_T=x_T,\\n log_every_t=log_every_t,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=unconditional_conditioning,\\n dynamic_threshold=dynamic_threshold,\\n ucg_schedule=ucg_schedule\\n )\\n return samples, intermediates\\n\\n @torch.no_grad()\\n def ddim_sampling(self, cond, shape,\\n x_T=None, ddim_use_original_steps=False,\\n callback=None, timesteps=None, quantize_denoised=False,\\n mask=None, x0=None, img_callback=None, log_every_t=100,\\n temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,\\n unconditional_guidance_scale=1., unconditional_conditioning=None, dynamic_threshold=None,\\n ucg_schedule=None):\\n device = self.model.betas.device\\n b = shape[0]\\n if x_T is None:\\n img = torch.randn(shape, device=device)\\n else:\\n img = x_T\\n\\n if timesteps is None:\\n timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps\\n elif timesteps is not None and not ddim_use_original_steps:\\n subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1\\n timesteps = self.ddim_timesteps[:subset_end]\\n\\n intermediates = {'x_inter': [img], 'pred_x0': [img]}\\n time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)\\n total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]\\n print(f\\\"Running DDIM Sampling with {total_steps} timesteps\\\")\\n\\n iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)\\n\\n for i, step in enumerate(iterator):\\n index = total_steps - i - 1\\n ts = torch.full((b,), step, device=device, dtype=torch.long)\\n\\n if mask is not None:\\n assert x0 is not None\\n img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass?\\n img = img_orig * mask + (1. - mask) * img\\n\\n if ucg_schedule is not None:\\n assert len(ucg_schedule) == len(time_range)\\n unconditional_guidance_scale = ucg_schedule[i]\\n\\n outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,\\n quantize_denoised=quantize_denoised, temperature=temperature,\\n noise_dropout=noise_dropout, score_corrector=score_corrector,\\n corrector_kwargs=corrector_kwargs,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=unconditional_conditioning,\\n dynamic_threshold=dynamic_threshold)\\n img, pred_x0 = outs\\n if callback: callback(i)\\n if img_callback: img_callback(pred_x0, i)\\n\\n if index % log_every_t == 0 or index == total_steps - 1:\\n intermediates['x_inter'].append(img)\\n intermediates['pred_x0'].append(pred_x0)\\n\\n return img, intermediates\\n\\n @torch.no_grad()\\n def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,\\n temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,\\n unconditional_guidance_scale=1., unconditional_conditioning=None,\\n dynamic_threshold=None):\\n b, *_, device = *x.shape, x.device\\n\\n if unconditional_conditioning is None or unconditional_guidance_scale == 1.:\\n model_output = self.model.apply_model(x, t, c)\\n else:\\n x_in = torch.cat([x] * 2)\\n t_in = torch.cat([t] * 2)\\n if isinstance(c, dict):\\n assert isinstance(unconditional_conditioning, dict)\\n c_in = dict()\\n for k in c:\\n if isinstance(c[k], list):\\n c_in[k] = [torch.cat([\\n unconditional_conditioning[k][i],\\n c[k][i]]) for i in range(len(c[k]))]\\n else:\\n c_in[k] = torch.cat([\\n unconditional_conditioning[k],\\n c[k]])\\n elif isinstance(c, list):\\n c_in = list()\\n assert isinstance(unconditional_conditioning, list)\\n for i in range(len(c)):\\n c_in.append(torch.cat([unconditional_conditioning[i], c[i]]))\\n else:\\n c_in = torch.cat([unconditional_conditioning, c])\\n model_uncond, model_t = self.model.apply_model(x_in, t_in, c_in).chunk(2)\\n model_output = model_uncond + unconditional_guidance_scale * (model_t - model_uncond)\\n\\n if self.model.parameterization == \\\"v\\\":\\n e_t = self.model.predict_eps_from_z_and_v(x, t, model_output)\\n else:\\n e_t = model_output\\n\\n if score_corrector is not None:\\n assert self.model.parameterization == \\\"eps\\\", 'not implemented'\\n e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)\\n\\n alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas\\n alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev\\n sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas\\n sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas\\n # select parameters corresponding to the currently considered timestep\\n a_t = torch.full((b, 1, 1, 1), alphas[index], device=device)\\n a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device)\\n sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device)\\n sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device)\\n\\n # current prediction for x_0\\n if self.model.parameterization != \\\"v\\\":\\n pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()\\n else:\\n pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output)\\n\\n if quantize_denoised:\\n pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)\\n\\n if dynamic_threshold is not None:\\n raise NotImplementedError()\\n\\n # direction pointing to x_t\\n dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t\\n noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature\\n if noise_dropout > 0.:\\n noise = torch.nn.functional.dropout(noise, p=noise_dropout)\\n x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise\\n return x_prev, pred_x0\\n\\n @torch.no_grad()\\n def encode(self, x0, c, t_enc, use_original_steps=False, return_intermediates=None,\\n unconditional_guidance_scale=1.0, unconditional_conditioning=None, callback=None):\\n num_reference_steps = self.ddpm_num_timesteps if use_original_steps else self.ddim_timesteps.shape[0]\\n\\n assert t_enc <= num_reference_steps\\n num_steps = t_enc\\n\\n if use_original_steps:\\n alphas_next = self.alphas_cumprod[:num_steps]\\n alphas = self.alphas_cumprod_prev[:num_steps]\\n else:\\n alphas_next = self.ddim_alphas[:num_steps]\\n alphas = torch.tensor(self.ddim_alphas_prev[:num_steps])\\n\\n x_next = x0\\n intermediates = []\\n inter_steps = []\\n for i in tqdm(range(num_steps), desc='Encoding Image'):\\n t = torch.full((x0.shape[0],), i, device=self.model.device, dtype=torch.long)\\n if unconditional_guidance_scale == 1.:\\n noise_pred = self.model.apply_model(x_next, t, c)\\n else:\\n assert unconditional_conditioning is not None\\n e_t_uncond, noise_pred = torch.chunk(\\n self.model.apply_model(torch.cat((x_next, x_next)), torch.cat((t, t)),\\n torch.cat((unconditional_conditioning, c))), 2)\\n noise_pred = e_t_uncond + unconditional_guidance_scale * (noise_pred - e_t_uncond)\\n\\n xt_weighted = (alphas_next[i] / alphas[i]).sqrt() * x_next\\n weighted_noise_pred = alphas_next[i].sqrt() * (\\n (1 / alphas_next[i] - 1).sqrt() - (1 / alphas[i] - 1).sqrt()) * noise_pred\\n x_next = xt_weighted + weighted_noise_pred\\n if return_intermediates and i % (\\n num_steps // return_intermediates) == 0 and i < num_steps - 1:\\n intermediates.append(x_next)\\n inter_steps.append(i)\\n elif return_intermediates and i >= num_steps - 2:\\n intermediates.append(x_next)\\n inter_steps.append(i)\\n if callback: callback(i)\\n\\n out = {'x_encoded': x_next, 'intermediate_steps': inter_steps}\\n if return_intermediates:\\n out.update({'intermediates': intermediates})\\n return x_next, out\\n\\n @torch.no_grad()\\n def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):\\n # fast, but does not allow for exact reconstruction\\n # t serves as an index to gather the correct alphas\\n if use_original_steps:\\n sqrt_alphas_cumprod = self.sqrt_alphas_cumprod\\n sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod\\n else:\\n sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas)\\n sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas\\n\\n if noise is None:\\n noise = torch.randn_like(x0)\\n return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 +\\n extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise)\\n\\n @torch.no_grad()\\n def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None,\\n use_original_steps=False, callback=None):\\n\\n timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps\\n timesteps = timesteps[:t_start]\\n\\n time_range = np.flip(timesteps)\\n total_steps = timesteps.shape[0]\\n print(f\\\"Running DDIM Sampling with {total_steps} timesteps\\\")\\n\\n iterator = tqdm(time_range, desc='Decoding image', total=total_steps)\\n x_dec = x_latent\\n for i, step in enumerate(iterator):\\n index = total_steps - i - 1\\n ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long)\\n x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps,\\n unconditional_guidance_scale=unconditional_guidance_scale,\\n unconditional_conditioning=unconditional_conditioning)\\n if callback: callback(i)\\n return x_dec\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import einops\nimport torch\nimport torch as th\nimport torch.nn as nn\nfrom ldm.modules.diffusionmodules.util import (\n conv_nd,\n linear,\n zero_module,\n timestep_embedding,\n)\nfrom einops import rearrange, repeat\nfrom torchvision.utils import make_grid\nfrom ldm.modules.attention import SpatialTransformer, SpatialTransformerPlus\nfrom ldm.modules.diffusionmodules.openaimodel import ResBlock, TimestepEmbedSequential, Downsample, AttentionBlock, Upsample, normalization, checkpoint, convert_module_to_f16, convert_module_to_f32\nfrom ldm.models.diffusion.ddpm import LatentDiffusion\nfrom ldm.util import log_txt_as_img, exists, instantiate_from_config\nfrom ldm.models.diffusion.ddim import DDIMSampler\n from omegaconf.listconfig import ListConfig\n from omegaconf.listconfig import ListConfig"},"token_num":{"kind":"number","value":18001,"string":"18,001"},"cropped_code":{"kind":"string","value":"class ReferenceNet(nn.Module):\n \"\"\"\n The full UNet model with attention and timestep embedding.\n :param in_channels: channels in the input Tensor.\n :param model_channels: base channel count for the model.\n :param out_channels: channels in the output Tensor.\n :param num_res_blocks: number of residual blocks per downsample.\n :param attention_resolutions: a collection of downsample rates at which\n attention will take place. May be a set, list, or tuple.\n For example, if this contains 4, then at 4x downsampling, attention\n will be used.\n :param dropout: the dropout probability.\n :param channel_mult: channel multiplier for each level of the UNet.\n :param conv_resample: if True, use learned convolutions for upsampling and\n downsampling.\n :param dims: determines if the signal is 1D, 2D, or 3D.\n :param num_classes: if specified (as an int), then this model will be\n class-conditional with `num_classes` classes.\n :param use_checkpoint: use gradient checkpointing to reduce memory usage.\n :param num_heads: the number of attention heads in each attention layer.\n :param num_heads_channels: if specified, ignore num_heads and instead use\n a fixed channel width per attention head.\n :param num_heads_upsample: works with num_heads to set a different number\n of heads for upsampling. Deprecated.\n :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.\n :param resblock_updown: use residual blocks for up/downsampling.\n :param use_new_attention_order: use a different attention pattern for potentially\n increased efficiency.\n \"\"\"\n\n def __init__(\n self,\n image_size,\n in_channels,\n model_channels,\n num_res_blocks,\n attention_resolutions,\n dropout=0,\n channel_mult=(1, 2, 4, 8),\n conv_resample=True,\n dims=2,\n num_classes=None,\n use_checkpoint=False,\n use_fp16=False,\n num_heads=-1,\n num_head_channels=-1,\n num_heads_upsample=-1,\n use_scale_shift_norm=False,\n resblock_updown=False,\n use_new_attention_order=False,\n use_spatial_transformer=False, # custom transformer support\n transformer_depth=1, # custom transformer support\n context_dim=None, # custom transformer support\n n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model\n legacy=True,\n disable_self_attentions=None,\n num_attention_blocks=None,\n disable_middle_self_attn=False,\n use_linear_in_transformer=False,\n ):\n super().__init__()\n if use_spatial_transformer:\n assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'\n\n if context_dim is not None:\n assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'\n if type(context_dim) == ListConfig:\n context_dim = list(context_dim)\n\n if num_heads_upsample == -1:\n num_heads_upsample = num_heads\n\n if num_heads == -1:\n assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'\n\n if num_head_channels == -1:\n assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'\n\n self.image_size = image_size\n self.in_channels = in_channels\n self.model_channels = model_channels\n if isinstance(num_res_blocks, int):\n self.num_res_blocks = len(channel_mult) * [num_res_blocks]\n else:\n if len(num_res_blocks) != len(channel_mult):\n raise ValueError(\"provide num_res_blocks either as an int (globally constant) or \"\n \"as a list/tuple (per-level) with the same length as channel_mult\")\n self.num_res_blocks = num_res_blocks\n if disable_self_attentions is not None:\n # should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not\n assert len(disable_self_attentions) == len(channel_mult)\n if num_attention_blocks is not None:\n assert len(num_attention_blocks) == len(self.num_res_blocks)\n assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks))))\n print(f\"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. \"\n f\"This option has LESS priority than attention_resolutions {attention_resolutions}, \"\n f\"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, \"\n f\"attention will still not be set.\")\n\n self.attention_resolutions = attention_resolutions\n self.dropout = dropout\n self.channel_mult = channel_mult\n self.conv_resample = conv_resample\n self.num_classes = num_classes\n self.use_checkpoint = use_checkpoint\n self.dtype = th.float16 if use_fp16 else th.float32\n self.num_heads = num_heads\n self.num_head_channels = num_head_channels\n self.num_heads_upsample = num_heads_upsample\n self.predict_codebook_ids = n_embed is not None\n\n time_embed_dim = model_channels * 4\n self.time_embed = nn.Sequential(\n linear(model_channels, time_embed_dim),\n nn.SiLU(),\n linear(time_embed_dim, time_embed_dim),\n )\n self.input_blocks = nn.ModuleList(\n [\n TimestepEmbedSequential(\n"},"all_code":{"kind":"string","value":"\n\n\n\nclass ReferenceNet(nn.Module):\n \"\"\"\n The full UNet model with attention and timestep embedding.\n :param in_channels: channels in the input Tensor.\n :param model_channels: base channel count for the model.\n :param out_channels: channels in the output Tensor.\n :param num_res_blocks: number of residual blocks per downsample.\n :param attention_resolutions: a collection of downsample rates at which\n attention will take place. May be a set, list, or tuple.\n For example, if this contains 4, then at 4x downsampling, attention\n will be used.\n :param dropout: the dropout probability.\n :param channel_mult: channel multiplier for each level of the UNet.\n :param conv_resample: if True, use learned convolutions for upsampling and\n downsampling.\n :param dims: determines if the signal is 1D, 2D, or 3D.\n :param num_classes: if specified (as an int), then this model will be\n class-conditional with `num_classes` classes.\n :param use_checkpoint: use gradient checkpointing to reduce memory usage.\n :param num_heads: the number of attention heads in each attention layer.\n :param num_heads_channels: if specified, ignore num_heads and instead use\n a fixed channel width per attention head.\n :param num_heads_upsample: works with num_heads to set a different number\n of heads for upsampling. Deprecated.\n :param use_scale_shift_norm: use a FiLM-like conditioning mechanism.\n :param resblock_updown: use residual blocks for up/downsampling.\n :param use_new_attention_order: use a different attention pattern for potentially\n increased efficiency.\n \"\"\"\n\n def __init__(\n self,\n image_size,\n in_channels,\n model_channels,\n num_res_blocks,\n attention_resolutions,\n dropout=0,\n channel_mult=(1, 2, 4, 8),\n conv_resample=True,\n dims=2,\n num_classes=None,\n use_checkpoint=False,\n use_fp16=False,\n num_heads=-1,\n num_head_channels=-1,\n num_heads_upsample=-1,\n use_scale_shift_norm=False,\n resblock_updown=False,\n use_new_attention_order=False,\n use_spatial_transformer=False, # custom transformer support\n transformer_depth=1, # custom transformer support\n context_dim=None, # custom transformer support\n n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model\n legacy=True,\n disable_self_attentions=None,\n num_attention_blocks=None,\n disable_middle_self_attn=False,\n use_linear_in_transformer=False,\n ):\n super().__init__()\n if use_spatial_transformer:\n assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'\n\n if context_dim is not None:\n assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'\n if type(context_dim) == ListConfig:\n context_dim = list(context_dim)\n\n if num_heads_upsample == -1:\n num_heads_upsample = num_heads\n\n if num_heads == -1:\n assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'\n\n if num_head_channels == -1:\n assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'\n\n self.image_size = image_size\n self.in_channels = in_channels\n self.model_channels = model_channels\n if isinstance(num_res_blocks, int):\n self.num_res_blocks = len(channel_mult) * [num_res_blocks]\n else:\n if len(num_res_blocks) != len(channel_mult):\n raise ValueError(\"provide num_res_blocks either as an int (globally constant) or \"\n \"as a list/tuple (per-level) with the same length as channel_mult\")\n self.num_res_blocks = num_res_blocks\n if disable_self_attentions is not None:\n # should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not\n assert len(disable_self_attentions) == len(channel_mult)\n if num_attention_blocks is not None:\n assert len(num_attention_blocks) == len(self.num_res_blocks)\n assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks))))\n print(f\"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. \"\n f\"This option has LESS priority than attention_resolutions {attention_resolutions}, \"\n f\"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, \"\n f\"attention will still not be set.\")\n\n self.attention_resolutions = attention_resolutions\n self.dropout = dropout\n self.channel_mult = channel_mult\n self.conv_resample = conv_resample\n self.num_classes = num_classes\n self.use_checkpoint = use_checkpoint\n self.dtype = th.float16 if use_fp16 else th.float32\n self.num_heads = num_heads\n self.num_head_channels = num_head_channels\n self.num_heads_upsample = num_heads_upsample\n self.predict_codebook_ids = n_embed is not None\n\n time_embed_dim = model_channels * 4\n self.time_embed = nn.Sequential(\n linear(model_channels, time_embed_dim),\n nn.SiLU(),\n linear(time_embed_dim, time_embed_dim),\n )\n self.input_blocks = nn.ModuleList(\n [\n TimestepEmbedSequential("},"next_line":{"kind":"string","value":" conv_nd(dims, in_channels, model_channels, 3, padding=1)"},"gold_snippet_index":{"kind":"number","value":0,"string":"0"},"created_at":{"kind":"string","value":"2023-12-16 03:31:33+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5674,"cells":{"repo_name":{"kind":"string","value":"yasserben/CLOUDS"},"file_path":{"kind":"string","value":"train_net.py"},"context":{"kind":"list like","value":[{"identifier":"add_maskformer2_config","path":"clouds/config.py","snippet":"def add_maskformer2_config(cfg):\n \"\"\"\n Add config for MASK_FORMER.\n \"\"\"\n # NOTE: configs from original maskformer\n # data config\n # select the dataset mapper\n cfg.INPUT.DATASET_MAPPER_NAME = \"mask_former_semantic\"\n # Color augmentation\n cfg.INPUT.COLOR_AUG_SSD = False\n # We retry random cropping until no single category in semantic segmentation GT occupies more\n # than `SINGLE_CATEGORY_MAX_AREA` part of the crop.\n cfg.INPUT.CROP.SINGLE_CATEGORY_MAX_AREA = 1.0\n # Pad image and segmentation GT in dataset mapper.\n cfg.INPUT.SIZE_DIVISIBILITY = -1\n\n # solver config\n # weight decay on embedding\n cfg.SOLVER.WEIGHT_DECAY_EMBED = 0.0\n # optimizer\n cfg.SOLVER.OPTIMIZER = \"ADAMW\"\n cfg.SOLVER.BACKBONE_MULTIPLIER = 0.1\n\n # mask_former model config\n cfg.MODEL.MASK_FORMER = CN()\n\n # loss\n cfg.MODEL.MASK_FORMER.DEEP_SUPERVISION = True\n cfg.MODEL.MASK_FORMER.NO_OBJECT_WEIGHT = 0.1\n cfg.MODEL.MASK_FORMER.CLASS_WEIGHT = 1.0\n cfg.MODEL.MASK_FORMER.DICE_WEIGHT = 1.0\n cfg.MODEL.MASK_FORMER.MASK_WEIGHT = 20.0\n\n # transformer config\n cfg.MODEL.MASK_FORMER.NHEADS = 8\n cfg.MODEL.MASK_FORMER.DROPOUT = 0.1\n cfg.MODEL.MASK_FORMER.DIM_FEEDFORWARD = 2048\n cfg.MODEL.MASK_FORMER.ENC_LAYERS = 0\n cfg.MODEL.MASK_FORMER.DEC_LAYERS = 6\n cfg.MODEL.MASK_FORMER.PRE_NORM = False\n\n cfg.MODEL.MASK_FORMER.HIDDEN_DIM = 256\n cfg.MODEL.MASK_FORMER.NUM_OBJECT_QUERIES = 100\n\n cfg.MODEL.MASK_FORMER.TRANSFORMER_IN_FEATURE = \"res5\"\n cfg.MODEL.MASK_FORMER.ENFORCE_INPUT_PROJ = False\n\n # mask_former inference config\n cfg.MODEL.MASK_FORMER.TEST = CN()\n cfg.MODEL.MASK_FORMER.TEST.SEMANTIC_ON = True\n cfg.MODEL.MASK_FORMER.TEST.INSTANCE_ON = False\n cfg.MODEL.MASK_FORMER.TEST.PANOPTIC_ON = False\n cfg.MODEL.MASK_FORMER.TEST.OBJECT_MASK_THRESHOLD = 0.0\n cfg.MODEL.MASK_FORMER.TEST.OVERLAP_THRESHOLD = 0.0\n cfg.MODEL.MASK_FORMER.TEST.SEM_SEG_POSTPROCESSING_BEFORE_INFERENCE = False\n\n # Sometimes `backbone.size_divisibility` is set to 0 for some backbone (e.g. ResNet)\n # you can use this config to override\n cfg.MODEL.MASK_FORMER.SIZE_DIVISIBILITY = 32\n\n # pixel decoder config\n cfg.MODEL.SEM_SEG_HEAD.MASK_DIM = 256\n # adding transformer in pixel decoder\n cfg.MODEL.SEM_SEG_HEAD.TRANSFORMER_ENC_LAYERS = 0\n # pixel decoder\n cfg.MODEL.SEM_SEG_HEAD.PIXEL_DECODER_NAME = \"BasePixelDecoder\"\n\n # swin transformer backbone\n cfg.MODEL.SWIN = CN()\n cfg.MODEL.SWIN.PRETRAIN_IMG_SIZE = 224\n cfg.MODEL.SWIN.PATCH_SIZE = 4\n cfg.MODEL.SWIN.EMBED_DIM = 96\n cfg.MODEL.SWIN.DEPTHS = [2, 2, 6, 2]\n cfg.MODEL.SWIN.NUM_HEADS = [3, 6, 12, 24]\n cfg.MODEL.SWIN.WINDOW_SIZE = 7\n cfg.MODEL.SWIN.MLP_RATIO = 4.0\n cfg.MODEL.SWIN.QKV_BIAS = True\n cfg.MODEL.SWIN.QK_SCALE = None\n cfg.MODEL.SWIN.DROP_RATE = 0.0\n cfg.MODEL.SWIN.ATTN_DROP_RATE = 0.0\n cfg.MODEL.SWIN.DROP_PATH_RATE = 0.3\n cfg.MODEL.SWIN.APE = False\n cfg.MODEL.SWIN.PATCH_NORM = True\n cfg.MODEL.SWIN.OUT_FEATURES = [\"res2\", \"res3\", \"res4\", \"res5\"]\n cfg.MODEL.SWIN.USE_CHECKPOINT = False\n\n # NOTE: maskformer2 extra configs\n # transformer module\n cfg.MODEL.MASK_FORMER.TRANSFORMER_DECODER_NAME = (\n \"MultiScaleMaskedTransformerDecoder\"\n )\n\n # LSJ aug\n cfg.INPUT.IMAGE_SIZE = 1024\n cfg.INPUT.MIN_SCALE = 0.1\n cfg.INPUT.MAX_SCALE = 2.0\n\n # MSDeformAttn encoder configs\n cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_IN_FEATURES = [\n \"res3\",\n \"res4\",\n \"res5\",\n ]\n cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_N_POINTS = 4\n cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_N_HEADS = 8\n\n # point loss configs\n # Number of points sampled during training for a mask point head.\n cfg.MODEL.MASK_FORMER.TRAIN_NUM_POINTS = 112 * 112\n # Oversampling parameter for PointRend point sampling during training. Parameter `k` in the\n # original paper.\n cfg.MODEL.MASK_FORMER.OVERSAMPLE_RATIO = 3.0\n # Importance sampling parameter for PointRend point sampling during training. Parametr `beta` in\n # the original paper.\n cfg.MODEL.MASK_FORMER.IMPORTANCE_SAMPLE_RATIO = 0.75\n\n # Resizing disabled for Synthia\n cfg.INPUT.RESIZE = CN()\n cfg.INPUT.RESIZE.ENABLED = True\n cfg.INPUT.RESIZE.SIZE_TRAIN = (1280, 720)\n\n # Saving Pseudo Labels during test time\n cfg.MODEL.SAVE_PSEUDO_LABELS = False\n\n # for the Dataset repeat factor\n # cfg.DATASETS.TRAIN_REPEAT_FACTOR = [(\"sd_v99\",5.0), (\"cityscapes_train\",1.0)]"},{"identifier":"add_clouds_config","path":"clouds/config.py","snippet":"def add_clouds_config(cfg):\n # CLOUDS model config\n cfg.MODEL.CLOUDS = CN()\n cfg.MODEL.CLOUDS.CLIP_MODEL_NAME = \"convnext_large_d_320\"\n cfg.MODEL.CLOUDS.CLIP_PRETRAINED_WEIGHTS = \"laion2b_s29b_b131k_ft_soup\"\n cfg.MODEL.CLOUDS.EMBED_DIM = 768\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE_ALPHA = 0.4\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE_BETA = 0.8\n cfg.MODEL.CLOUDS.ENSEMBLE_ON_VALID_MASK = False\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE = False\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE_EMA = False\n cfg.MODEL.CLOUDS.SAM = CN()\n cfg.MODEL.CLOUDS.SAM.ENABLED = False\n cfg.MODEL.CLOUDS.SAM.MOBILE = True\n cfg.MODEL.CLOUDS.SAM.MINIBATCH = False\n cfg.MODEL.CLOUDS.SAM.SIZE_THRESHOLD = 5000\n cfg.MODEL.CLOUDS.SAM.EROSION = False\n cfg.MODEL.CLOUDS.SAM.EROSION_SIZE = 3\n cfg.MODEL.CLOUDS.SAM.NUM_POINTS = 5\n cfg.MODEL.CLOUDS.SAM.SELECTION_MODE = \"random\"\n cfg.MODEL.CLOUDS.SAM.RM_INTERSECTION = True\n cfg.MODEL.CLOUDS.SAM.REFINEMENT = False\n cfg.MODEL.CLOUDS.SAM.ALPHA_EMA = 0.999\n cfg.MODEL.CLOUDS.OVERWRITING = True\n cfg.MODEL.CLOUDS.ITERATION_UPDATE = 100"},{"identifier":"add_wandb_config","path":"clouds/config.py","snippet":"def add_wandb_config(cfg):\n # Wandb\n cfg.WANDB = CN()\n cfg.WANDB.PROJECT = \"clouds\"\n cfg.WANDB.NAME = None\n # use flash attention\n cfg.MODEL.FLASH = False"},{"identifier":"add_prerocessing_training_set_config","path":"clouds/config.py","snippet":"def add_prerocessing_training_set_config(cfg):\n cfg.INPUT.FLIP = True\n cfg.INPUT.INITIAL_HEIGHT = 1052\n cfg.INPUT.INITIAL_WIDTH = 1914\n cfg.INPUT.RESIZE_HEIGHT = 720\n cfg.INPUT.RESIZE_WIDTH = 1280\n cfg.INPUT.PL_THRESHOLD = 0.0\n\n cfg.DATASETS.SOURCE_FACTOR = 1.0\n cfg.DATASETS.TARGET_FACTOR = 1.0"},{"identifier":"add_repeat_factors","path":"clouds/config.py","snippet":"def add_repeat_factors(cfg):\n # for the Dataset repeat factor\n if (\n len(cfg.DATASETS.TRAIN) == 2\n and cfg.DATALOADER.SAMPLER_TRAIN == \"WeightedTrainingSampler\"\n ):\n if \"sd\" in cfg.DATASETS.TRAIN[0]:\n target_dataset = cfg.DATASETS.TRAIN[0]\n source_dataset = cfg.DATASETS.TRAIN[1]\n else:\n target_dataset = cfg.DATASETS.TRAIN[1]\n source_dataset = cfg.DATASETS.TRAIN[0]\n\n TRAIN_REPEAT_FACTOR = [\n (target_dataset, cfg.DATASETS.TARGET_FACTOR),\n (source_dataset, cfg.DATASETS.SOURCE_FACTOR),\n ]\n cfg.DATASETS.TRAIN_REPEAT_FACTOR = TRAIN_REPEAT_FACTOR\n return cfg\n else:\n return cfg"},{"identifier":"MapperTrain","path":"clouds/data/dataset_mappers/mapper_train.py","snippet":"class MapperTrain:\n \"\"\"\n A callable which takes a dataset dict in Detectron2 Dataset format,\n and map it into a format used by MaskFormer for semantic segmentation.\n\n The callable currently does the following:\n\n 1. Read the image from \"file_name\"\n 2. Applies geometric transforms to the image and annotation\n 3. Find and applies suitable cropping to the image and annotation\n 4. Prepare image and annotation to Tensors\n \"\"\"\n\n @configurable\n def __init__(\n self,\n is_train=True,\n *,\n augmentations_src,\n augmentations_sd,\n augmentations_photo,\n image_format,\n ignore_label,\n size_divisibility,\n ):\n \"\"\"\n NOTE: this interface is experimental.\n Args:\n is_train: for training or inference\n augmentations: a list of augmentations or deterministic transforms to apply\n image_format: an image format supported by :func:`detection_utils.read_image`.\n ignore_label: the label that is ignored to evaluation\n size_divisibility: pad image size to be divisible by this value\n \"\"\"\n self.is_train = is_train\n self.tfm_gens_src = augmentations_src\n self.tfm_gens_sd = augmentations_sd\n self.tfm_gens_photometric = augmentations_photo\n self.img_format = image_format\n self.ignore_label = ignore_label\n self.size_divisibility = size_divisibility\n\n logger = logging.getLogger(__name__)\n mode = \"training\" if is_train else \"inference\"\n logger.info(\n f\"[{self.__class__.__name__}] Augmentations used in {mode}: {augmentations_src}\"\n )\n\n @classmethod\n def from_config(cls, cfg, is_train=True):\n augs_src = []\n augs_sd = []\n augs_photometric = []\n # Build augmentation\n if cfg.INPUT.RESIZE.ENABLED:\n augs_src.append(\n T.ResizeScale(\n min_scale=0.5,\n max_scale=2.0,\n target_height=cfg.INPUT.INITIAL_HEIGHT,\n target_width=cfg.INPUT.INITIAL_WIDTH,\n interp=Image.BILINEAR,\n )\n )\n if cfg.INPUT.CROP.ENABLED:\n augs_src.append(\n T.FixedSizeCrop(\n (768, 768),\n pad=True,\n seg_pad_value=255,\n pad_value=0,\n )\n )\n if cfg.INPUT.COLOR_AUG_SSD:\n augs_src.append(ColorAugSSDTransform(img_format=cfg.INPUT.FORMAT))\n augs_photometric.append(ColorAugSSDTransform(img_format=cfg.INPUT.FORMAT))\n if cfg.INPUT.FLIP:\n augs_src.append(T.RandomFlip())\n augs_sd.append(T.RandomFlip())\n\n # Assume always applies to the training set.\n dataset_names = cfg.DATASETS.TRAIN\n meta = MetadataCatalog.get(dataset_names[0])\n ignore_label = meta.ignore_label\n\n ret = {\n \"is_train\": is_train,\n \"augmentations_src\": augs_src,\n \"augmentations_sd\": augs_sd,\n \"augmentations_photo\": augs_photometric,\n \"image_format\": cfg.INPUT.FORMAT,\n \"ignore_label\": ignore_label,\n \"size_divisibility\": cfg.INPUT.SIZE_DIVISIBILITY,\n }\n return ret\n\n def __call__(self, dataset_dict):\n \"\"\"\n Args:\n dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.\n\n Returns:\n dict: a format that builtin models in detectron2 accept\n \"\"\"\n assert (\n self.is_train\n ), \"MaskFormerSemanticDatasetMapper should only be used for training!\"\n\n dataset_dict = copy.deepcopy(dataset_dict) # it will be modified by code below\n image = utils.read_image(dataset_dict[\"file_name\"], format=self.img_format)\n utils.check_image_size(dataset_dict, image)\n\n if \"sem_seg_file_name\" in dataset_dict:\n # PyTorch transformation not implemented for uint16, so converting it to double first\n sem_seg_gt = utils.read_image(dataset_dict.pop(\"sem_seg_file_name\")).astype(\n \"double\"\n )\n else:\n sem_seg_gt = np.full(\n (dataset_dict[\"height\"], dataset_dict[\"width\"]), self.ignore_label\n ).astype(\"double\")\n\n if sem_seg_gt is None:\n raise ValueError(\n \"Cannot find 'sem_seg_file_name' for semantic segmentation dataset {}.\".format(\n dataset_dict[\"file_name\"]\n )\n )\n\n aug_input = T.AugInput(image, sem_seg=sem_seg_gt)\n if not (\"generated\" in str(dataset_dict[\"image_id\"])):\n aug_input, transforms = T.apply_transform_gens(self.tfm_gens_src, aug_input)\n image = aug_input.image\n sem_seg_gt = aug_input.sem_seg\n else:\n aug_input, transforms = T.apply_transform_gens(self.tfm_gens_sd, aug_input)\n image = aug_input.image\n sem_seg_gt = aug_input.sem_seg\n aug_input_photo, transforms = T.apply_transform_gens(\n self.tfm_gens_photometric, aug_input\n )\n image_aug = aug_input_photo.image\n\n # Pad image and segmentation label here!\n image = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))\n if \"generated\" in str(dataset_dict[\"image_id\"]):\n image_aug = torch.as_tensor(\n np.ascontiguousarray(image_aug.transpose(2, 0, 1))\n )\n if sem_seg_gt is not None:\n sem_seg_gt = torch.as_tensor(sem_seg_gt.astype(\"long\"))\n\n if self.size_divisibility > 0:\n image_size = (image.shape[-2], image.shape[-1])\n padding_size = [\n 0,\n self.size_divisibility - image_size[1],\n 0,\n self.size_divisibility - image_size[0],\n ]\n image = F.pad(image, padding_size, value=128).contiguous()\n if \"generated\" in str(dataset_dict[\"image_id\"]):\n image_aug = F.pad(image_aug, padding_size, value=128).contiguous()\n if sem_seg_gt is not None:\n sem_seg_gt = F.pad(\n sem_seg_gt, padding_size, value=self.ignore_label\n ).contiguous()\n\n image_shape = (image.shape[-2], image.shape[-1]) # h, w\n\n # Pytorch's dataloader is efficient on torch.Tensor due to shared-memory,\n # but not efficient on large generic data structures due to the use of pickle & mp.Queue.\n # Therefore it's important to use torch.Tensor.\n dataset_dict[\"image\"] = image\n if \"generated\" in str(dataset_dict[\"image_id\"]):\n dataset_dict[\"image_aug\"] = image_aug\n\n if sem_seg_gt is not None:\n dataset_dict[\"sem_seg\"] = sem_seg_gt.long()\n\n if \"annotations\" in dataset_dict:\n raise ValueError(\n \"Semantic segmentation dataset should not have 'annotations'.\"\n )\n\n # Prepare per-category binary masks\n if sem_seg_gt is not None:\n sem_seg_gt = sem_seg_gt.numpy()\n instances = Instances(image_shape)\n classes = np.unique(sem_seg_gt)\n # remove ignored region\n classes = classes[classes != self.ignore_label]\n instances.gt_classes = torch.tensor(classes, dtype=torch.int64)\n\n masks = []\n for class_id in classes:\n masks.append(sem_seg_gt == class_id)\n\n if len(masks) == 0:\n # Some image does not have annotation (all ignored)\n instances.gt_masks = torch.zeros(\n (0, sem_seg_gt.shape[-2], sem_seg_gt.shape[-1])\n )\n else:\n masks = BitMasks(\n torch.stack(\n [\n torch.from_numpy(np.ascontiguousarray(x.copy()))\n for x in masks\n ]\n )\n )\n instances.gt_masks = masks.tensor\n\n dataset_dict[\"instances\"] = instances\n\n return dataset_dict"},{"identifier":"MapperTest","path":"clouds/data/dataset_mappers/mapper_test.py","snippet":"class MapperTest:\n \"\"\"\n A callable which takes a dataset dict in Detectron2 Dataset format,\n and map it into a format used by the model.\n\n This is the default callable to be used to map your dataset dict into training data.\n You may need to follow it to implement your own one for customized logic,\n such as a different way to read or transform images.\n See :doc:`/tutorials/data_loading` for details.\n\n The callable currently does the following:\n\n 1. Read the image from \"file_name\"\n 2. Applies cropping/geometric transforms to the image and annotations\n 3. Prepare data and annotations to Tensor and :class:`Instances`\n \"\"\"\n\n @configurable\n def __init__(\n self,\n is_train: bool,\n *,\n augmentations: List[Union[T.Augmentation, T.Transform]],\n image_format: str,\n\n ):\n \"\"\"\n NOTE: this interface is experimental.\n\n Args:\n is_train: whether it's used in training or inference\n augmentations: a list of augmentations or deterministic transforms to apply\n image_format: an image format supported by :func:`detection_utils.read_image`.\n \"\"\"\n # if recompute_boxes:\n # assert use_instance_mask, \"recompute_boxes requires instance masks\"\n # fmt: off\n self.is_train = is_train\n self.augmentations = augmentations\n self.image_format = image_format\n logger = logging.getLogger(__name__)\n mode = \"training\" if is_train else \"inference\"\n logger.info(f\"[DatasetMapper] Augmentations used in {mode}: {augmentations}\")\n\n @classmethod\n def from_config(cls, cfg, is_train: bool = True):\n augs = [T.ResizeShortestEdge(short_edge_length=[1024], sample_style=\"choice\")]\n\n ret = {\n \"is_train\": is_train,\n \"augmentations\": augs,\n \"image_format\": cfg.INPUT.FORMAT,\n }\n\n\n return ret\n\n def __call__(self, dataset_dict):\n \"\"\"\n Args:\n dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.\n\n Returns:\n dict: a format that builtin models in detectron2 accept\n \"\"\"\n dataset_dict = copy.deepcopy(dataset_dict) # it will be modified by code below\n # USER: Write your own image loading if it's not from a file\n image = utils.read_image(dataset_dict[\"file_name\"], format=self.image_format)\n utils.check_image_size(dataset_dict, image)\n\n # USER: Remove if you don't do semantic/panoptic segmentation.\n if \"sem_seg_file_name\" in dataset_dict:\n sem_seg_gt = utils.read_image(dataset_dict.pop(\"sem_seg_file_name\"), \"L\").squeeze(2)\n else:\n sem_seg_gt = None\n\n aug_input = T.AugInput(image, sem_seg=sem_seg_gt)\n aug_input, transformation = T.apply_transform_gens(self.augmentations, aug_input)\n image, sem_seg_gt = aug_input.image, aug_input.sem_seg\n\n # Pytorch's dataloader is efficient on torch.Tensor due to shared-memory,\n # but not efficient on large generic data structures due to the use of pickle & mp.Queue.\n # Therefore it's important to use torch.Tensor.\n dataset_dict[\"image\"] = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))\n\n if sem_seg_gt is not None:\n dataset_dict[\"sem_seg\"] = torch.as_tensor(sem_seg_gt.astype(\"long\"))\n\n dataset_dict['height'] = dataset_dict[\"image\"].shape[1]\n dataset_dict['width'] = dataset_dict[\"image\"].shape[2]\n if not self.is_train:\n # USER: Modify this if you want to keep them for some reason.\n dataset_dict.pop(\"sem_seg_file_name\", None)\n return dataset_dict\n\n return dataset_dict"},{"identifier":"CityscapesSemSegEvaluator","path":"clouds/evaluation/cityscapes_evaluation.py","snippet":"class CityscapesSemSegEvaluator(CityscapesEvaluator):\n \"\"\"\n Evaluate semantic segmentation results on cityscapes dataset using cityscapes API.\n\n Note:\n * It does not work in multi-machine distributed training.\n * It contains a synchronization, therefore has to be used on all ranks.\n * Only the main process runs evaluation.\n \"\"\"\n\n def process(self, inputs, outputs):\n from cityscapesscripts.helpers.labels import trainId2label\n for input, output in zip(inputs, outputs):\n file_name = input[\"file_name\"]\n basename = os.path.splitext(os.path.basename(file_name))[0]\n pred_filename = os.path.join(self._temp_dir, basename + \"_pred.png\")\n\n output = output[\"sem_seg\"].argmax(dim=0).to(self._cpu_device).numpy()\n pred = 255 * np.ones(output.shape, dtype=np.uint8)\n for train_id, label in trainId2label.items():\n if label.ignoreInEval:\n continue\n pred[output == train_id] = label.id\n Image.fromarray(pred).save(pred_filename)\n\n\n def evaluate(self):\n comm.synchronize()\n if comm.get_rank() > 0:\n return\n # Load the Cityscapes eval script *after* setting the required env var,\n # since the script reads CITYSCAPES_DATASET into global variables at load time.\n import cityscapesscripts.evaluation.evalPixelLevelSemanticLabeling as cityscapes_eval\n\n self._logger.info(\"Evaluating results under {} ...\".format(self._temp_dir))\n\n # set some global states in cityscapes evaluation API, before evaluating\n cityscapes_eval.args.predictionPath = os.path.abspath(self._temp_dir)\n cityscapes_eval.args.predictionWalk = None\n cityscapes_eval.args.JSONOutput = False\n cityscapes_eval.args.colorized = False\n\n # These lines are adopted from\n # https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/evalPixelLevelSemanticLabeling.py # noqa\n gt_dir = PathManager.get_local_path(self._metadata.gt_dir)\n groundTruthImgList = glob.glob(\n os.path.join(gt_dir, \"*\", \"*_gtFine_labelIds.png\")\n )\n assert len(\n groundTruthImgList\n ), \"Cannot find any ground truth images to use for evaluation. Searched for: {}\".format(\n cityscapes_eval.args.groundTruthSearch\n )\n predictionImgList = []\n for gt in groundTruthImgList:\n predictionImgList.append(\n cityscapes_eval.getPrediction(cityscapes_eval.args, gt)\n )\n results = cityscapes_eval.evaluateImgLists(\n predictionImgList, groundTruthImgList, cityscapes_eval.args\n )\n ret = OrderedDict()\n ret[\"sem_seg\"] = {\n \"mIoU\": 100.0 * results[\"averageScoreClasses\"],\n \"IoU.road\": 100.0 * results[\"classScores\"][\"road\"],\n \"IoU.sidewalk\": 100.0 * results[\"classScores\"][\"sidewalk\"],\n \"IoU.building\": 100.0 * results[\"classScores\"][\"building\"],\n \"IoU.wall\": 100.0 * results[\"classScores\"][\"wall\"],\n \"IoU.fence\": 100.0 * results[\"classScores\"][\"fence\"],\n \"IoU.pole\": 100.0 * results[\"classScores\"][\"pole\"],\n \"IoU.traffic light\": 100.0 * results[\"classScores\"][\"traffic light\"],\n \"IoU.traffic sign\": 100.0 * results[\"classScores\"][\"traffic sign\"],\n \"IoU.vegetation\": 100.0 * results[\"classScores\"][\"vegetation\"],\n \"IoU.terrain\": 100.0 * results[\"classScores\"][\"terrain\"],\n \"IoU.sky\": 100.0 * results[\"classScores\"][\"sky\"],\n \"IoU.person\": 100.0 * results[\"classScores\"][\"person\"],\n \"IoU.rider\": 100.0 * results[\"classScores\"][\"rider\"],\n \"IoU.car\": 100.0 * results[\"classScores\"][\"car\"],\n \"IoU.truck\": 100.0 * results[\"classScores\"][\"truck\"],\n \"IoU.bus\": 100.0 * results[\"classScores\"][\"bus\"],\n \"IoU.train\": 100.0 * results[\"classScores\"][\"train\"],\n \"IoU.motorcycle\": 100.0 * results[\"classScores\"][\"motorcycle\"],\n \"IoU.bicycle\": 100.0 * results[\"classScores\"][\"bicycle\"],\n }\n if not self._save_pl:\n self._working_dir.cleanup()\n return ret"},{"identifier":"ClassicalSemSegEvaluator","path":"clouds/evaluation/semantic_evaluation.py","snippet":"class ClassicalSemSegEvaluator(DatasetEvaluator):\n \"\"\"\n Evaluate semantic segmentation metrics.\n \"\"\"\n\n def __init__(\n self,\n dataset_name,\n distributed=True,\n output_dir=None,\n *,\n sem_seg_loading_fn=load_image_into_numpy_array,\n num_classes=None,\n ignore_label=None,\n save_pl=False,\n ):\n \"\"\"\n Args:\n dataset_name (str): name of the dataset to be evaluated.\n distributed (bool): if True, will collect results from all ranks for evaluation.\n Otherwise, will evaluate the results in the current process.\n output_dir (str): an output directory to dump results.\n sem_seg_loading_fn: function to read sem seg file and load into numpy array.\n Default provided, but projects can customize.\n num_classes, ignore_label: deprecated argument\n \"\"\"\n self._logger = logging.getLogger(__name__)\n if num_classes is not None:\n self._logger.warn(\n \"SemSegEvaluator(num_classes) is deprecated! It should be obtained from metadata.\"\n )\n if ignore_label is not None:\n self._logger.warn(\n \"SemSegEvaluator(ignore_label) is deprecated! It should be obtained from metadata.\"\n )\n self._dataset_name = dataset_name\n self._distributed = distributed\n self._output_dir = output_dir\n\n self._cpu_device = torch.device(\"cpu\")\n\n self.input_file_to_gt_file = {\n dataset_record[\"file_name\"]: dataset_record[\"sem_seg_file_name\"]\n for dataset_record in DatasetCatalog.get(dataset_name)\n }\n\n meta = MetadataCatalog.get(dataset_name)\n # Dict that maps contiguous training ids to COCO category ids\n try:\n c2d = meta.stuff_dataset_id_to_contiguous_id\n self._contiguous_id_to_dataset_id = {v: k for k, v in c2d.items()}\n except AttributeError:\n self._contiguous_id_to_dataset_id = None\n self._class_names = meta.stuff_classes\n self.sem_seg_loading_fn = sem_seg_loading_fn\n self._num_classes = len(meta.stuff_classes)\n if num_classes is not None:\n assert (\n self._num_classes == num_classes\n ), f\"{self._num_classes} != {num_classes}\"\n self._ignore_label = (\n ignore_label if ignore_label is not None else meta.ignore_label\n )\n\n # This is because cv2.erode did not work for int datatype. Only works for uint8.\n self._compute_boundary_iou = True\n if not _CV2_IMPORTED:\n self._compute_boundary_iou = False\n self._logger.warn(\n \"\"\"Boundary IoU calculation requires OpenCV. B-IoU metrics are\n not going to be computed because OpenCV is not available to import.\"\"\"\n )\n if self._num_classes >= np.iinfo(np.uint8).max:\n self._compute_boundary_iou = False\n self._logger.warn(\n f\"\"\"SemSegEvaluator(num_classes) is more than supported value for Boundary IoU calculation!\n B-IoU metrics are not going to be computed. Max allowed value (exclusive)\n for num_classes for calculating Boundary IoU is {np.iinfo(np.uint8).max}.\n The number of classes of dataset {self._dataset_name} is {self._num_classes}\"\"\"\n )\n self._save_pl = save_pl\n\n def reset(self):\n self._conf_matrix = np.zeros(\n (self._num_classes + 1, self._num_classes + 1), dtype=np.int64\n )\n self._b_conf_matrix = np.zeros(\n (self._num_classes + 1, self._num_classes + 1), dtype=np.int64\n )\n self._predictions = []\n\n def process(self, inputs, outputs):\n \"\"\"\n Args:\n inputs: the inputs to a model.\n It is a list of dicts. Each dict corresponds to an image and\n contains keys like \"height\", \"width\", \"file_name\".\n outputs: the outputs of a model. It is either list of semantic segmentation predictions\n (Tensor [H, W]) or list of dicts with key \"sem_seg\" that contains semantic\n segmentation prediction in the same format.\n \"\"\"\n for input, output in zip(inputs, outputs):\n output = output[\"sem_seg\"].argmax(dim=0).to(self._cpu_device)\n pred = np.array(output, dtype=int)\n gt = input[\"sem_seg\"].numpy()\n\n gt[gt == self._ignore_label] = self._num_classes\n\n self._conf_matrix += np.bincount(\n (self._num_classes + 1) * pred.reshape(-1) + gt.reshape(-1),\n minlength=self._conf_matrix.size,\n ).reshape(self._conf_matrix.shape)\n\n if self._compute_boundary_iou:\n b_gt = self._mask_to_boundary(gt.astype(np.uint8))\n b_pred = self._mask_to_boundary(pred.astype(np.uint8))\n\n self._b_conf_matrix += np.bincount(\n (self._num_classes + 1) * b_pred.reshape(-1) + b_gt.reshape(-1),\n minlength=self._conf_matrix.size,\n ).reshape(self._conf_matrix.shape)\n\n if self._save_pl:\n self._predictions.extend(\n [dict(file_name=input[\"file_name\"], pred=pred)]\n )\n else:\n self._predictions.extend(\n self.encode_json_sem_seg(pred, input[\"file_name\"])\n )\n\n def evaluate(self):\n \"\"\"\n Evaluates standard semantic segmentation metrics (http://cocodataset.org/#stuff-eval):\n\n * Mean intersection-over-union averaged across classes (mIoU)\n * Frequency Weighted IoU (fwIoU)\n * Mean pixel accuracy averaged across classes (mACC)\n * Pixel Accuracy (pACC)\n \"\"\"\n if self._distributed:\n synchronize()\n conf_matrix_list = all_gather(self._conf_matrix)\n b_conf_matrix_list = all_gather(self._b_conf_matrix)\n self._predictions = all_gather(self._predictions)\n self._predictions = list(itertools.chain(*self._predictions))\n if not is_main_process():\n return\n\n self._conf_matrix = np.zeros_like(self._conf_matrix)\n for conf_matrix in conf_matrix_list:\n self._conf_matrix += conf_matrix\n\n self._b_conf_matrix = np.zeros_like(self._b_conf_matrix)\n for b_conf_matrix in b_conf_matrix_list:\n self._b_conf_matrix += b_conf_matrix\n\n if self._output_dir:\n first_elem = self._predictions[0]\n if \"bdd\" in first_elem[\"file_name\"]:\n self._output_dir = os.path.join(self._output_dir, \"bdd_eval_pl\")\n elif \"mapillary\" in first_elem[\"file_name\"]:\n self._output_dir = os.path.join(self._output_dir, \"mapillary_eval_pl\")\n PathManager.mkdirs(self._output_dir)\n if self._save_pl:\n # A function that will iterate over the list of dictionnaries and write the corresponding image\n # in the output directory\n def write_image_from_dict(dict):\n filename = os.path.join(\n self._output_dir,\n dict[\"file_name\"].split(\"/\")[-1].split(\".\")[0] + \"_pred.png\",\n )\n pred = dict[\"pred\"]\n pred = get_rgb_from_semantic_map_maxed(pred)\n # pred = Image.fromarray(pred)\n pred.save(filename)\n\n # We apply the function to the list of dictionnaries\n list(map(write_image_from_dict, self._predictions))\n\n else:\n file_path = os.path.join(self._output_dir, \"sem_seg_predictions.json\")\n with PathManager.open(file_path, \"w\") as f:\n f.write(json.dumps(self._predictions))\n\n acc = np.full(self._num_classes, np.nan, dtype=float)\n iou = np.full(self._num_classes, np.nan, dtype=float)\n tp = self._conf_matrix.diagonal()[:-1].astype(float)\n pos_gt = np.sum(self._conf_matrix[:-1, :-1], axis=0).astype(float)\n class_weights = pos_gt / np.sum(pos_gt)\n pos_pred = np.sum(self._conf_matrix[:-1, :-1], axis=1).astype(float)\n acc_valid = pos_gt > 0\n acc[acc_valid] = tp[acc_valid] / pos_gt[acc_valid]\n union = pos_gt + pos_pred - tp\n iou_valid = np.logical_and(acc_valid, union > 0)\n iou[iou_valid] = tp[iou_valid] / union[iou_valid]\n macc = np.sum(acc[acc_valid]) / np.sum(acc_valid)\n miou = np.sum(iou[iou_valid]) / np.sum(iou_valid)\n fiou = np.sum(iou[iou_valid] * class_weights[iou_valid])\n pacc = np.sum(tp) / np.sum(pos_gt)\n\n if self._compute_boundary_iou:\n b_iou = np.full(self._num_classes, np.nan, dtype=float)\n b_tp = self._b_conf_matrix.diagonal()[:-1].astype(float)\n b_pos_gt = np.sum(self._b_conf_matrix[:-1, :-1], axis=0).astype(float)\n b_pos_pred = np.sum(self._b_conf_matrix[:-1, :-1], axis=1).astype(float)\n b_union = b_pos_gt + b_pos_pred - b_tp\n b_iou_valid = b_union > 0\n b_iou[b_iou_valid] = b_tp[b_iou_valid] / b_union[b_iou_valid]\n\n res = {}\n res[\"mIoU\"] = 100 * miou\n res[\"fwIoU\"] = 100 * fiou\n for i, name in enumerate(self._class_names):\n res[f\"IoU-{name}\"] = 100 * iou[i]\n if self._compute_boundary_iou:\n res[f\"BoundaryIoU-{name}\"] = 100 * b_iou[i]\n res[f\"min(IoU, B-Iou)-{name}\"] = 100 * min(iou[i], b_iou[i])\n res[\"mACC\"] = 100 * macc\n res[\"pACC\"] = 100 * pacc\n for i, name in enumerate(self._class_names):\n res[f\"ACC-{name}\"] = 100 * acc[i]\n\n if self._output_dir:\n file_path = os.path.join(self._output_dir, \"sem_seg_evaluation.pth\")\n with PathManager.open(file_path, \"wb\") as f:\n torch.save(res, f)\n results = OrderedDict({\"sem_seg\": res})\n self._logger.info(results)\n\n def get_miou_value_from_dict(dict, subkey):\n for key, value in dict.items():\n if subkey in key and \"IoU\" in key:\n if np.isnan(value):\n return 0\n else:\n return value\n\n ret = OrderedDict()\n ret[\"sem_seg\"] = {\n \"mIoU\": results[\"sem_seg\"][\"mIoU\"],\n \"IoU.road\": get_miou_value_from_dict(results[\"sem_seg\"], \"road\"),\n \"IoU.sidewalk\": get_miou_value_from_dict(results[\"sem_seg\"], \"sidewalk\"),\n \"IoU.building\": get_miou_value_from_dict(results[\"sem_seg\"], \"building\"),\n \"IoU.wall\": get_miou_value_from_dict(results[\"sem_seg\"], \"wall\"),\n \"IoU.fence\": get_miou_value_from_dict(results[\"sem_seg\"], \"fence\"),\n \"IoU.pole\": get_miou_value_from_dict(results[\"sem_seg\"], \"pole\"),\n \"IoU.traffic light\": get_miou_value_from_dict(\n results[\"sem_seg\"], \"traffic light\"\n ),\n \"IoU.traffic sign\": get_miou_value_from_dict(\n results[\"sem_seg\"], \"traffic sign\"\n ),\n \"IoU.vegetation\": get_miou_value_from_dict(\n results[\"sem_seg\"], \"vegetation\"\n ),\n \"IoU.terrain\": get_miou_value_from_dict(results[\"sem_seg\"], \"terrain\"),\n \"IoU.sky\": get_miou_value_from_dict(results[\"sem_seg\"], \"sky\"),\n \"IoU.person\": get_miou_value_from_dict(results[\"sem_seg\"], \"person\"),\n \"IoU.rider\": get_miou_value_from_dict(results[\"sem_seg\"], \"rider\"),\n \"IoU.car\": get_miou_value_from_dict(results[\"sem_seg\"], \"car\"),\n \"IoU.truck\": get_miou_value_from_dict(results[\"sem_seg\"], \"truck\"),\n \"IoU.bus\": get_miou_value_from_dict(results[\"sem_seg\"], \"bus\"),\n \"IoU.train\": get_miou_value_from_dict(results[\"sem_seg\"], \"train\"),\n \"IoU.motorcycle\": get_miou_value_from_dict(\n results[\"sem_seg\"], \"motorcycle\"\n ),\n \"IoU.bicycle\": get_miou_value_from_dict(results[\"sem_seg\"], \"bicycle\"),\n }\n return ret\n\n def encode_json_sem_seg(self, sem_seg, input_file_name):\n \"\"\"\n Convert semantic segmentation to COCO stuff format with segments encoded as RLEs.\n See http://cocodataset.org/#format-results\n \"\"\"\n json_list = []\n for label in np.unique(sem_seg):\n if self._contiguous_id_to_dataset_id is not None:\n assert (\n label in self._contiguous_id_to_dataset_id\n ), \"Label {} is not in the metadata info for {}\".format(\n label, self._dataset_name\n )\n dataset_id = self._contiguous_id_to_dataset_id[label]\n else:\n dataset_id = int(label)\n mask = (sem_seg == label).astype(np.uint8)\n mask_rle = mask_util.encode(np.array(mask[:, :, None], order=\"F\"))[0]\n mask_rle[\"counts\"] = mask_rle[\"counts\"].decode(\"utf-8\")\n json_list.append(\n {\n \"file_name\": input_file_name,\n \"category_id\": dataset_id,\n \"segmentation\": mask_rle,\n }\n )\n return json_list\n\n def _mask_to_boundary(self, mask: np.ndarray, dilation_ratio=0.02):\n assert mask.ndim == 2, \"mask_to_boundary expects a 2-dimensional image\"\n h, w = mask.shape\n diag_len = np.sqrt(h ** 2 + w ** 2)\n dilation = max(1, int(round(dilation_ratio * diag_len)))\n kernel = np.ones((3, 3), dtype=np.uint8)\n\n padded_mask = cv2.copyMakeBorder(mask, 1, 1, 1, 1, cv2.BORDER_CONSTANT, value=0)\n eroded_mask_with_padding = cv2.erode(padded_mask, kernel, iterations=dilation)\n eroded_mask = eroded_mask_with_padding[1:-1, 1:-1]\n boundary = mask - eroded_mask\n return boundary"},{"identifier":"PersoEvalHook","path":"clouds/engine/hooks.py","snippet":"class PersoEvalHook(HookBase):\n \"\"\"\n Run an evaluation function periodically, and at the end of training.\n\n It is executed every ``eval_period`` iterations and after the last iteration.\n \"\"\"\n\n def __init__(self, eval_period, eval_function, eval_after_train=True):\n \"\"\"\n Args:\n eval_period (int): the period to run `eval_function`. Set to 0 to\n not evaluate periodically (but still evaluate after the last iteration\n if `eval_after_train` is True).\n eval_function (callable): a function which takes no arguments, and\n returns a nested dict of evaluation metrics.\n eval_after_train (bool): whether to evaluate after the last iteration\n\n Note:\n This hook must be enabled in all or none workers.\n If you would like only certain workers to perform evaluation,\n give other workers a no-op function (`eval_function=lambda: None`).\n \"\"\"\n self._period = eval_period\n self._func = eval_function\n self._eval_after_train = eval_after_train\n\n def _do_eval(self):\n results = self._func()\n\n if results:\n assert isinstance(\n results, dict\n ), \"Eval function must return a dict. Got {} instead.\".format(results)\n\n flattened_results = flatten_results_dict(results)\n for k, v in flattened_results.items():\n try:\n v = float(v)\n except Exception as e:\n raise ValueError(\n \"[EvalHook] eval_function should return a nested dict of float. \"\n \"Got '{}: {}' instead.\".format(k, v)\n ) from e\n self.trainer.storage.put_scalars(**flattened_results, smoothing_hint=False)\n\n # Evaluation may take different time among workers.\n # A barrier make them start the next iteration together.\n comm.synchronize()\n\n def before_train(self):\n \"\"\"\n Called before the first iteration.\n \"\"\"\n if \"debug\" in self.trainer.cfg.OUTPUT_DIR:\n pass\n else:\n results = self._func()\n\n if results:\n assert isinstance(\n results, dict\n ), \"Eval function must return a dict. Got {} instead.\".format(results)\n\n flattened_results = flatten_results_dict(results)\n for k, v in flattened_results.items():\n try:\n v = float(v)\n except Exception as e:\n raise ValueError(\n \"[EvalHook] eval_function should return a nested dict of float. \"\n \"Got '{}: {}' instead.\".format(k, v)\n ) from e\n self.trainer.storage.put_scalars(\n **flattened_results, smoothing_hint=False\n )\n\n def after_step(self):\n next_iter = self.trainer.iter + 1\n if self._period > 0 and next_iter % self._period == 0:\n # do the last eval in after_train\n if next_iter != self.trainer.max_iter:\n self._do_eval()\n\n def after_train(self):\n # This condition is to prevent the eval from running after a failed training\n if self._eval_after_train and self.trainer.iter + 1 >= self.trainer.max_iter:\n self._do_eval()\n # func is likely a closure that holds reference to the trainer\n # therefore we clean it to avoid circular reference in the end\n del self._func"},{"identifier":"WandbWriter","path":"clouds/utils/events.py","snippet":"class WandbWriter(EventWriter):\n \"\"\"\n Write all scalars to a tensorboard file.\n \"\"\"\n\n def __init__(self):\n \"\"\"\n Args:\n log_dir (str): the directory to save the output events\n kwargs: other arguments passed to `torch.utils.tensorboard.SummaryWriter(...)`\n \"\"\"\n self._last_write = -1\n self._group_rules = [\n (IsIn(\"/\"), BaseRule()),\n (IsIn(\"loss\"), Prefix(\"train\")),\n # (IsIn(\"sem_seg\"), Prefix(\"val\")),\n (\n IsInList([\"lr\", \"time\", \"eta_seconds\", \"rank_data_time\", \"data_time\"]),\n Prefix(\"stats\"),\n ),\n ]\n\n def write(self):\n storage = get_event_storage()\n\n def _group_name(scalar_name):\n for rule, op in self._group_rules:\n if rule(scalar_name):\n return op(scalar_name)\n return scalar_name\n\n stats = {\n _group_name(name): scalars[0]\n for name, scalars in storage.latest().items()\n if scalars[1] > self._last_write\n }\n if len(stats) > 0:\n self._last_write = max([v[1] for k, v in storage.latest().items()])\n\n # storage.put_{image,histogram} is only meant to be used by\n # tensorboard writer. So we access its internal fields directly from here.\n if len(storage._vis_data) >= 1:\n stats[\"image\"] = [\n wandb.Image(img, caption=img_name)\n for img_name, img, step_num in storage._vis_data\n ]\n # Storage stores all image data and rely on this writer to clear them.\n # As a result it assumes only one writer will use its image data.\n # An alternative design is to let storage store limited recent\n # data (e.g. only the most recent image) that all writers can access.\n # In that case a writer may not see all image data if its period is long.\n storage.clear_images()\n\n if len(storage._histograms) >= 1:\n\n def create_bar(tag, bucket_limits, bucket_counts, **kwargs):\n data = [\n [label, val] for (label, val) in zip(bucket_limits, bucket_counts)\n ]\n table = wandb.Table(data=data, columns=[\"label\", \"value\"])\n return wandb.plot.bar(table, \"label\", \"value\", title=tag)\n\n stats[\"hist\"] = [create_bar(**params) for params in storage._histograms]\n\n storage.clear_histograms()\n\n if len(stats) == 0:\n return\n wandb.log(stats, step=storage.iter)\n\n def close(self):\n wandb.finish()"},{"identifier":"setup_wandb","path":"clouds/utils/events.py","snippet":"def setup_wandb(cfg, args):\n if comm.is_main_process():\n init_args = {\n k.lower(): v\n for k, v in cfg.WANDB.items()\n if isinstance(k, str) and k not in [\"config\", \"name\"]\n }\n if \"config_exclude_keys\" in init_args:\n init_args[\"config\"] = cfg\n init_args[\"config\"][\"cfg_file\"] = args.config_file\n else:\n init_args[\"config\"] = {\n \"output_dir\": cfg.OUTPUT_DIR,\n \"train\": extract_dataset_from_string(cfg.DATASETS.TRAIN),\n \"test\": extract_dataset_from_string(cfg.DATASETS.TEST),\n \"iter\": cfg.SOLVER.MAX_ITER,\n \"lr\": cfg.SOLVER.BASE_LR,\n \"batch_size\": cfg.SOLVER.IMS_PER_BATCH,\n \"cfg_file\": args.config_file,\n }\n\n init_args[\"group\"] = get_base_name(cfg)\n if cfg.WANDB.NAME is not None:\n init_args[\"name\"] = cfg.WANDB.NAME\n else:\n init_args[\"name\"] = get_full_name_xp(init_args[\"group\"], cfg)\n if \"debug\" in cfg.OUTPUT_DIR:\n init_args[\"project\"] = \"debug\"\n wandb.init(**init_args)"}],"string":"[\n {\n \"identifier\": \"add_maskformer2_config\",\n \"path\": \"clouds/config.py\",\n \"snippet\": \"def add_maskformer2_config(cfg):\\n \\\"\\\"\\\"\\n Add config for MASK_FORMER.\\n \\\"\\\"\\\"\\n # NOTE: configs from original maskformer\\n # data config\\n # select the dataset mapper\\n cfg.INPUT.DATASET_MAPPER_NAME = \\\"mask_former_semantic\\\"\\n # Color augmentation\\n cfg.INPUT.COLOR_AUG_SSD = False\\n # We retry random cropping until no single category in semantic segmentation GT occupies more\\n # than `SINGLE_CATEGORY_MAX_AREA` part of the crop.\\n cfg.INPUT.CROP.SINGLE_CATEGORY_MAX_AREA = 1.0\\n # Pad image and segmentation GT in dataset mapper.\\n cfg.INPUT.SIZE_DIVISIBILITY = -1\\n\\n # solver config\\n # weight decay on embedding\\n cfg.SOLVER.WEIGHT_DECAY_EMBED = 0.0\\n # optimizer\\n cfg.SOLVER.OPTIMIZER = \\\"ADAMW\\\"\\n cfg.SOLVER.BACKBONE_MULTIPLIER = 0.1\\n\\n # mask_former model config\\n cfg.MODEL.MASK_FORMER = CN()\\n\\n # loss\\n cfg.MODEL.MASK_FORMER.DEEP_SUPERVISION = True\\n cfg.MODEL.MASK_FORMER.NO_OBJECT_WEIGHT = 0.1\\n cfg.MODEL.MASK_FORMER.CLASS_WEIGHT = 1.0\\n cfg.MODEL.MASK_FORMER.DICE_WEIGHT = 1.0\\n cfg.MODEL.MASK_FORMER.MASK_WEIGHT = 20.0\\n\\n # transformer config\\n cfg.MODEL.MASK_FORMER.NHEADS = 8\\n cfg.MODEL.MASK_FORMER.DROPOUT = 0.1\\n cfg.MODEL.MASK_FORMER.DIM_FEEDFORWARD = 2048\\n cfg.MODEL.MASK_FORMER.ENC_LAYERS = 0\\n cfg.MODEL.MASK_FORMER.DEC_LAYERS = 6\\n cfg.MODEL.MASK_FORMER.PRE_NORM = False\\n\\n cfg.MODEL.MASK_FORMER.HIDDEN_DIM = 256\\n cfg.MODEL.MASK_FORMER.NUM_OBJECT_QUERIES = 100\\n\\n cfg.MODEL.MASK_FORMER.TRANSFORMER_IN_FEATURE = \\\"res5\\\"\\n cfg.MODEL.MASK_FORMER.ENFORCE_INPUT_PROJ = False\\n\\n # mask_former inference config\\n cfg.MODEL.MASK_FORMER.TEST = CN()\\n cfg.MODEL.MASK_FORMER.TEST.SEMANTIC_ON = True\\n cfg.MODEL.MASK_FORMER.TEST.INSTANCE_ON = False\\n cfg.MODEL.MASK_FORMER.TEST.PANOPTIC_ON = False\\n cfg.MODEL.MASK_FORMER.TEST.OBJECT_MASK_THRESHOLD = 0.0\\n cfg.MODEL.MASK_FORMER.TEST.OVERLAP_THRESHOLD = 0.0\\n cfg.MODEL.MASK_FORMER.TEST.SEM_SEG_POSTPROCESSING_BEFORE_INFERENCE = False\\n\\n # Sometimes `backbone.size_divisibility` is set to 0 for some backbone (e.g. ResNet)\\n # you can use this config to override\\n cfg.MODEL.MASK_FORMER.SIZE_DIVISIBILITY = 32\\n\\n # pixel decoder config\\n cfg.MODEL.SEM_SEG_HEAD.MASK_DIM = 256\\n # adding transformer in pixel decoder\\n cfg.MODEL.SEM_SEG_HEAD.TRANSFORMER_ENC_LAYERS = 0\\n # pixel decoder\\n cfg.MODEL.SEM_SEG_HEAD.PIXEL_DECODER_NAME = \\\"BasePixelDecoder\\\"\\n\\n # swin transformer backbone\\n cfg.MODEL.SWIN = CN()\\n cfg.MODEL.SWIN.PRETRAIN_IMG_SIZE = 224\\n cfg.MODEL.SWIN.PATCH_SIZE = 4\\n cfg.MODEL.SWIN.EMBED_DIM = 96\\n cfg.MODEL.SWIN.DEPTHS = [2, 2, 6, 2]\\n cfg.MODEL.SWIN.NUM_HEADS = [3, 6, 12, 24]\\n cfg.MODEL.SWIN.WINDOW_SIZE = 7\\n cfg.MODEL.SWIN.MLP_RATIO = 4.0\\n cfg.MODEL.SWIN.QKV_BIAS = True\\n cfg.MODEL.SWIN.QK_SCALE = None\\n cfg.MODEL.SWIN.DROP_RATE = 0.0\\n cfg.MODEL.SWIN.ATTN_DROP_RATE = 0.0\\n cfg.MODEL.SWIN.DROP_PATH_RATE = 0.3\\n cfg.MODEL.SWIN.APE = False\\n cfg.MODEL.SWIN.PATCH_NORM = True\\n cfg.MODEL.SWIN.OUT_FEATURES = [\\\"res2\\\", \\\"res3\\\", \\\"res4\\\", \\\"res5\\\"]\\n cfg.MODEL.SWIN.USE_CHECKPOINT = False\\n\\n # NOTE: maskformer2 extra configs\\n # transformer module\\n cfg.MODEL.MASK_FORMER.TRANSFORMER_DECODER_NAME = (\\n \\\"MultiScaleMaskedTransformerDecoder\\\"\\n )\\n\\n # LSJ aug\\n cfg.INPUT.IMAGE_SIZE = 1024\\n cfg.INPUT.MIN_SCALE = 0.1\\n cfg.INPUT.MAX_SCALE = 2.0\\n\\n # MSDeformAttn encoder configs\\n cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_IN_FEATURES = [\\n \\\"res3\\\",\\n \\\"res4\\\",\\n \\\"res5\\\",\\n ]\\n cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_N_POINTS = 4\\n cfg.MODEL.SEM_SEG_HEAD.DEFORMABLE_TRANSFORMER_ENCODER_N_HEADS = 8\\n\\n # point loss configs\\n # Number of points sampled during training for a mask point head.\\n cfg.MODEL.MASK_FORMER.TRAIN_NUM_POINTS = 112 * 112\\n # Oversampling parameter for PointRend point sampling during training. Parameter `k` in the\\n # original paper.\\n cfg.MODEL.MASK_FORMER.OVERSAMPLE_RATIO = 3.0\\n # Importance sampling parameter for PointRend point sampling during training. Parametr `beta` in\\n # the original paper.\\n cfg.MODEL.MASK_FORMER.IMPORTANCE_SAMPLE_RATIO = 0.75\\n\\n # Resizing disabled for Synthia\\n cfg.INPUT.RESIZE = CN()\\n cfg.INPUT.RESIZE.ENABLED = True\\n cfg.INPUT.RESIZE.SIZE_TRAIN = (1280, 720)\\n\\n # Saving Pseudo Labels during test time\\n cfg.MODEL.SAVE_PSEUDO_LABELS = False\\n\\n # for the Dataset repeat factor\\n # cfg.DATASETS.TRAIN_REPEAT_FACTOR = [(\\\"sd_v99\\\",5.0), (\\\"cityscapes_train\\\",1.0)]\"\n },\n {\n \"identifier\": \"add_clouds_config\",\n \"path\": \"clouds/config.py\",\n \"snippet\": \"def add_clouds_config(cfg):\\n # CLOUDS model config\\n cfg.MODEL.CLOUDS = CN()\\n cfg.MODEL.CLOUDS.CLIP_MODEL_NAME = \\\"convnext_large_d_320\\\"\\n cfg.MODEL.CLOUDS.CLIP_PRETRAINED_WEIGHTS = \\\"laion2b_s29b_b131k_ft_soup\\\"\\n cfg.MODEL.CLOUDS.EMBED_DIM = 768\\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE_ALPHA = 0.4\\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE_BETA = 0.8\\n cfg.MODEL.CLOUDS.ENSEMBLE_ON_VALID_MASK = False\\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE = False\\n cfg.MODEL.CLOUDS.GEOMETRIC_ENSEMBLE_EMA = False\\n cfg.MODEL.CLOUDS.SAM = CN()\\n cfg.MODEL.CLOUDS.SAM.ENABLED = False\\n cfg.MODEL.CLOUDS.SAM.MOBILE = True\\n cfg.MODEL.CLOUDS.SAM.MINIBATCH = False\\n cfg.MODEL.CLOUDS.SAM.SIZE_THRESHOLD = 5000\\n cfg.MODEL.CLOUDS.SAM.EROSION = False\\n cfg.MODEL.CLOUDS.SAM.EROSION_SIZE = 3\\n cfg.MODEL.CLOUDS.SAM.NUM_POINTS = 5\\n cfg.MODEL.CLOUDS.SAM.SELECTION_MODE = \\\"random\\\"\\n cfg.MODEL.CLOUDS.SAM.RM_INTERSECTION = True\\n cfg.MODEL.CLOUDS.SAM.REFINEMENT = False\\n cfg.MODEL.CLOUDS.SAM.ALPHA_EMA = 0.999\\n cfg.MODEL.CLOUDS.OVERWRITING = True\\n cfg.MODEL.CLOUDS.ITERATION_UPDATE = 100\"\n },\n {\n \"identifier\": \"add_wandb_config\",\n \"path\": \"clouds/config.py\",\n \"snippet\": \"def add_wandb_config(cfg):\\n # Wandb\\n cfg.WANDB = CN()\\n cfg.WANDB.PROJECT = \\\"clouds\\\"\\n cfg.WANDB.NAME = None\\n # use flash attention\\n cfg.MODEL.FLASH = False\"\n },\n {\n \"identifier\": \"add_prerocessing_training_set_config\",\n \"path\": \"clouds/config.py\",\n \"snippet\": \"def add_prerocessing_training_set_config(cfg):\\n cfg.INPUT.FLIP = True\\n cfg.INPUT.INITIAL_HEIGHT = 1052\\n cfg.INPUT.INITIAL_WIDTH = 1914\\n cfg.INPUT.RESIZE_HEIGHT = 720\\n cfg.INPUT.RESIZE_WIDTH = 1280\\n cfg.INPUT.PL_THRESHOLD = 0.0\\n\\n cfg.DATASETS.SOURCE_FACTOR = 1.0\\n cfg.DATASETS.TARGET_FACTOR = 1.0\"\n },\n {\n \"identifier\": \"add_repeat_factors\",\n \"path\": \"clouds/config.py\",\n \"snippet\": \"def add_repeat_factors(cfg):\\n # for the Dataset repeat factor\\n if (\\n len(cfg.DATASETS.TRAIN) == 2\\n and cfg.DATALOADER.SAMPLER_TRAIN == \\\"WeightedTrainingSampler\\\"\\n ):\\n if \\\"sd\\\" in cfg.DATASETS.TRAIN[0]:\\n target_dataset = cfg.DATASETS.TRAIN[0]\\n source_dataset = cfg.DATASETS.TRAIN[1]\\n else:\\n target_dataset = cfg.DATASETS.TRAIN[1]\\n source_dataset = cfg.DATASETS.TRAIN[0]\\n\\n TRAIN_REPEAT_FACTOR = [\\n (target_dataset, cfg.DATASETS.TARGET_FACTOR),\\n (source_dataset, cfg.DATASETS.SOURCE_FACTOR),\\n ]\\n cfg.DATASETS.TRAIN_REPEAT_FACTOR = TRAIN_REPEAT_FACTOR\\n return cfg\\n else:\\n return cfg\"\n },\n {\n \"identifier\": \"MapperTrain\",\n \"path\": \"clouds/data/dataset_mappers/mapper_train.py\",\n \"snippet\": \"class MapperTrain:\\n \\\"\\\"\\\"\\n A callable which takes a dataset dict in Detectron2 Dataset format,\\n and map it into a format used by MaskFormer for semantic segmentation.\\n\\n The callable currently does the following:\\n\\n 1. Read the image from \\\"file_name\\\"\\n 2. Applies geometric transforms to the image and annotation\\n 3. Find and applies suitable cropping to the image and annotation\\n 4. Prepare image and annotation to Tensors\\n \\\"\\\"\\\"\\n\\n @configurable\\n def __init__(\\n self,\\n is_train=True,\\n *,\\n augmentations_src,\\n augmentations_sd,\\n augmentations_photo,\\n image_format,\\n ignore_label,\\n size_divisibility,\\n ):\\n \\\"\\\"\\\"\\n NOTE: this interface is experimental.\\n Args:\\n is_train: for training or inference\\n augmentations: a list of augmentations or deterministic transforms to apply\\n image_format: an image format supported by :func:`detection_utils.read_image`.\\n ignore_label: the label that is ignored to evaluation\\n size_divisibility: pad image size to be divisible by this value\\n \\\"\\\"\\\"\\n self.is_train = is_train\\n self.tfm_gens_src = augmentations_src\\n self.tfm_gens_sd = augmentations_sd\\n self.tfm_gens_photometric = augmentations_photo\\n self.img_format = image_format\\n self.ignore_label = ignore_label\\n self.size_divisibility = size_divisibility\\n\\n logger = logging.getLogger(__name__)\\n mode = \\\"training\\\" if is_train else \\\"inference\\\"\\n logger.info(\\n f\\\"[{self.__class__.__name__}] Augmentations used in {mode}: {augmentations_src}\\\"\\n )\\n\\n @classmethod\\n def from_config(cls, cfg, is_train=True):\\n augs_src = []\\n augs_sd = []\\n augs_photometric = []\\n # Build augmentation\\n if cfg.INPUT.RESIZE.ENABLED:\\n augs_src.append(\\n T.ResizeScale(\\n min_scale=0.5,\\n max_scale=2.0,\\n target_height=cfg.INPUT.INITIAL_HEIGHT,\\n target_width=cfg.INPUT.INITIAL_WIDTH,\\n interp=Image.BILINEAR,\\n )\\n )\\n if cfg.INPUT.CROP.ENABLED:\\n augs_src.append(\\n T.FixedSizeCrop(\\n (768, 768),\\n pad=True,\\n seg_pad_value=255,\\n pad_value=0,\\n )\\n )\\n if cfg.INPUT.COLOR_AUG_SSD:\\n augs_src.append(ColorAugSSDTransform(img_format=cfg.INPUT.FORMAT))\\n augs_photometric.append(ColorAugSSDTransform(img_format=cfg.INPUT.FORMAT))\\n if cfg.INPUT.FLIP:\\n augs_src.append(T.RandomFlip())\\n augs_sd.append(T.RandomFlip())\\n\\n # Assume always applies to the training set.\\n dataset_names = cfg.DATASETS.TRAIN\\n meta = MetadataCatalog.get(dataset_names[0])\\n ignore_label = meta.ignore_label\\n\\n ret = {\\n \\\"is_train\\\": is_train,\\n \\\"augmentations_src\\\": augs_src,\\n \\\"augmentations_sd\\\": augs_sd,\\n \\\"augmentations_photo\\\": augs_photometric,\\n \\\"image_format\\\": cfg.INPUT.FORMAT,\\n \\\"ignore_label\\\": ignore_label,\\n \\\"size_divisibility\\\": cfg.INPUT.SIZE_DIVISIBILITY,\\n }\\n return ret\\n\\n def __call__(self, dataset_dict):\\n \\\"\\\"\\\"\\n Args:\\n dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.\\n\\n Returns:\\n dict: a format that builtin models in detectron2 accept\\n \\\"\\\"\\\"\\n assert (\\n self.is_train\\n ), \\\"MaskFormerSemanticDatasetMapper should only be used for training!\\\"\\n\\n dataset_dict = copy.deepcopy(dataset_dict) # it will be modified by code below\\n image = utils.read_image(dataset_dict[\\\"file_name\\\"], format=self.img_format)\\n utils.check_image_size(dataset_dict, image)\\n\\n if \\\"sem_seg_file_name\\\" in dataset_dict:\\n # PyTorch transformation not implemented for uint16, so converting it to double first\\n sem_seg_gt = utils.read_image(dataset_dict.pop(\\\"sem_seg_file_name\\\")).astype(\\n \\\"double\\\"\\n )\\n else:\\n sem_seg_gt = np.full(\\n (dataset_dict[\\\"height\\\"], dataset_dict[\\\"width\\\"]), self.ignore_label\\n ).astype(\\\"double\\\")\\n\\n if sem_seg_gt is None:\\n raise ValueError(\\n \\\"Cannot find 'sem_seg_file_name' for semantic segmentation dataset {}.\\\".format(\\n dataset_dict[\\\"file_name\\\"]\\n )\\n )\\n\\n aug_input = T.AugInput(image, sem_seg=sem_seg_gt)\\n if not (\\\"generated\\\" in str(dataset_dict[\\\"image_id\\\"])):\\n aug_input, transforms = T.apply_transform_gens(self.tfm_gens_src, aug_input)\\n image = aug_input.image\\n sem_seg_gt = aug_input.sem_seg\\n else:\\n aug_input, transforms = T.apply_transform_gens(self.tfm_gens_sd, aug_input)\\n image = aug_input.image\\n sem_seg_gt = aug_input.sem_seg\\n aug_input_photo, transforms = T.apply_transform_gens(\\n self.tfm_gens_photometric, aug_input\\n )\\n image_aug = aug_input_photo.image\\n\\n # Pad image and segmentation label here!\\n image = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))\\n if \\\"generated\\\" in str(dataset_dict[\\\"image_id\\\"]):\\n image_aug = torch.as_tensor(\\n np.ascontiguousarray(image_aug.transpose(2, 0, 1))\\n )\\n if sem_seg_gt is not None:\\n sem_seg_gt = torch.as_tensor(sem_seg_gt.astype(\\\"long\\\"))\\n\\n if self.size_divisibility > 0:\\n image_size = (image.shape[-2], image.shape[-1])\\n padding_size = [\\n 0,\\n self.size_divisibility - image_size[1],\\n 0,\\n self.size_divisibility - image_size[0],\\n ]\\n image = F.pad(image, padding_size, value=128).contiguous()\\n if \\\"generated\\\" in str(dataset_dict[\\\"image_id\\\"]):\\n image_aug = F.pad(image_aug, padding_size, value=128).contiguous()\\n if sem_seg_gt is not None:\\n sem_seg_gt = F.pad(\\n sem_seg_gt, padding_size, value=self.ignore_label\\n ).contiguous()\\n\\n image_shape = (image.shape[-2], image.shape[-1]) # h, w\\n\\n # Pytorch's dataloader is efficient on torch.Tensor due to shared-memory,\\n # but not efficient on large generic data structures due to the use of pickle & mp.Queue.\\n # Therefore it's important to use torch.Tensor.\\n dataset_dict[\\\"image\\\"] = image\\n if \\\"generated\\\" in str(dataset_dict[\\\"image_id\\\"]):\\n dataset_dict[\\\"image_aug\\\"] = image_aug\\n\\n if sem_seg_gt is not None:\\n dataset_dict[\\\"sem_seg\\\"] = sem_seg_gt.long()\\n\\n if \\\"annotations\\\" in dataset_dict:\\n raise ValueError(\\n \\\"Semantic segmentation dataset should not have 'annotations'.\\\"\\n )\\n\\n # Prepare per-category binary masks\\n if sem_seg_gt is not None:\\n sem_seg_gt = sem_seg_gt.numpy()\\n instances = Instances(image_shape)\\n classes = np.unique(sem_seg_gt)\\n # remove ignored region\\n classes = classes[classes != self.ignore_label]\\n instances.gt_classes = torch.tensor(classes, dtype=torch.int64)\\n\\n masks = []\\n for class_id in classes:\\n masks.append(sem_seg_gt == class_id)\\n\\n if len(masks) == 0:\\n # Some image does not have annotation (all ignored)\\n instances.gt_masks = torch.zeros(\\n (0, sem_seg_gt.shape[-2], sem_seg_gt.shape[-1])\\n )\\n else:\\n masks = BitMasks(\\n torch.stack(\\n [\\n torch.from_numpy(np.ascontiguousarray(x.copy()))\\n for x in masks\\n ]\\n )\\n )\\n instances.gt_masks = masks.tensor\\n\\n dataset_dict[\\\"instances\\\"] = instances\\n\\n return dataset_dict\"\n },\n {\n \"identifier\": \"MapperTest\",\n \"path\": \"clouds/data/dataset_mappers/mapper_test.py\",\n \"snippet\": \"class MapperTest:\\n \\\"\\\"\\\"\\n A callable which takes a dataset dict in Detectron2 Dataset format,\\n and map it into a format used by the model.\\n\\n This is the default callable to be used to map your dataset dict into training data.\\n You may need to follow it to implement your own one for customized logic,\\n such as a different way to read or transform images.\\n See :doc:`/tutorials/data_loading` for details.\\n\\n The callable currently does the following:\\n\\n 1. Read the image from \\\"file_name\\\"\\n 2. Applies cropping/geometric transforms to the image and annotations\\n 3. Prepare data and annotations to Tensor and :class:`Instances`\\n \\\"\\\"\\\"\\n\\n @configurable\\n def __init__(\\n self,\\n is_train: bool,\\n *,\\n augmentations: List[Union[T.Augmentation, T.Transform]],\\n image_format: str,\\n\\n ):\\n \\\"\\\"\\\"\\n NOTE: this interface is experimental.\\n\\n Args:\\n is_train: whether it's used in training or inference\\n augmentations: a list of augmentations or deterministic transforms to apply\\n image_format: an image format supported by :func:`detection_utils.read_image`.\\n \\\"\\\"\\\"\\n # if recompute_boxes:\\n # assert use_instance_mask, \\\"recompute_boxes requires instance masks\\\"\\n # fmt: off\\n self.is_train = is_train\\n self.augmentations = augmentations\\n self.image_format = image_format\\n logger = logging.getLogger(__name__)\\n mode = \\\"training\\\" if is_train else \\\"inference\\\"\\n logger.info(f\\\"[DatasetMapper] Augmentations used in {mode}: {augmentations}\\\")\\n\\n @classmethod\\n def from_config(cls, cfg, is_train: bool = True):\\n augs = [T.ResizeShortestEdge(short_edge_length=[1024], sample_style=\\\"choice\\\")]\\n\\n ret = {\\n \\\"is_train\\\": is_train,\\n \\\"augmentations\\\": augs,\\n \\\"image_format\\\": cfg.INPUT.FORMAT,\\n }\\n\\n\\n return ret\\n\\n def __call__(self, dataset_dict):\\n \\\"\\\"\\\"\\n Args:\\n dataset_dict (dict): Metadata of one image, in Detectron2 Dataset format.\\n\\n Returns:\\n dict: a format that builtin models in detectron2 accept\\n \\\"\\\"\\\"\\n dataset_dict = copy.deepcopy(dataset_dict) # it will be modified by code below\\n # USER: Write your own image loading if it's not from a file\\n image = utils.read_image(dataset_dict[\\\"file_name\\\"], format=self.image_format)\\n utils.check_image_size(dataset_dict, image)\\n\\n # USER: Remove if you don't do semantic/panoptic segmentation.\\n if \\\"sem_seg_file_name\\\" in dataset_dict:\\n sem_seg_gt = utils.read_image(dataset_dict.pop(\\\"sem_seg_file_name\\\"), \\\"L\\\").squeeze(2)\\n else:\\n sem_seg_gt = None\\n\\n aug_input = T.AugInput(image, sem_seg=sem_seg_gt)\\n aug_input, transformation = T.apply_transform_gens(self.augmentations, aug_input)\\n image, sem_seg_gt = aug_input.image, aug_input.sem_seg\\n\\n # Pytorch's dataloader is efficient on torch.Tensor due to shared-memory,\\n # but not efficient on large generic data structures due to the use of pickle & mp.Queue.\\n # Therefore it's important to use torch.Tensor.\\n dataset_dict[\\\"image\\\"] = torch.as_tensor(np.ascontiguousarray(image.transpose(2, 0, 1)))\\n\\n if sem_seg_gt is not None:\\n dataset_dict[\\\"sem_seg\\\"] = torch.as_tensor(sem_seg_gt.astype(\\\"long\\\"))\\n\\n dataset_dict['height'] = dataset_dict[\\\"image\\\"].shape[1]\\n dataset_dict['width'] = dataset_dict[\\\"image\\\"].shape[2]\\n if not self.is_train:\\n # USER: Modify this if you want to keep them for some reason.\\n dataset_dict.pop(\\\"sem_seg_file_name\\\", None)\\n return dataset_dict\\n\\n return dataset_dict\"\n },\n {\n \"identifier\": \"CityscapesSemSegEvaluator\",\n \"path\": \"clouds/evaluation/cityscapes_evaluation.py\",\n \"snippet\": \"class CityscapesSemSegEvaluator(CityscapesEvaluator):\\n \\\"\\\"\\\"\\n Evaluate semantic segmentation results on cityscapes dataset using cityscapes API.\\n\\n Note:\\n * It does not work in multi-machine distributed training.\\n * It contains a synchronization, therefore has to be used on all ranks.\\n * Only the main process runs evaluation.\\n \\\"\\\"\\\"\\n\\n def process(self, inputs, outputs):\\n from cityscapesscripts.helpers.labels import trainId2label\\n for input, output in zip(inputs, outputs):\\n file_name = input[\\\"file_name\\\"]\\n basename = os.path.splitext(os.path.basename(file_name))[0]\\n pred_filename = os.path.join(self._temp_dir, basename + \\\"_pred.png\\\")\\n\\n output = output[\\\"sem_seg\\\"].argmax(dim=0).to(self._cpu_device).numpy()\\n pred = 255 * np.ones(output.shape, dtype=np.uint8)\\n for train_id, label in trainId2label.items():\\n if label.ignoreInEval:\\n continue\\n pred[output == train_id] = label.id\\n Image.fromarray(pred).save(pred_filename)\\n\\n\\n def evaluate(self):\\n comm.synchronize()\\n if comm.get_rank() > 0:\\n return\\n # Load the Cityscapes eval script *after* setting the required env var,\\n # since the script reads CITYSCAPES_DATASET into global variables at load time.\\n import cityscapesscripts.evaluation.evalPixelLevelSemanticLabeling as cityscapes_eval\\n\\n self._logger.info(\\\"Evaluating results under {} ...\\\".format(self._temp_dir))\\n\\n # set some global states in cityscapes evaluation API, before evaluating\\n cityscapes_eval.args.predictionPath = os.path.abspath(self._temp_dir)\\n cityscapes_eval.args.predictionWalk = None\\n cityscapes_eval.args.JSONOutput = False\\n cityscapes_eval.args.colorized = False\\n\\n # These lines are adopted from\\n # https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/evalPixelLevelSemanticLabeling.py # noqa\\n gt_dir = PathManager.get_local_path(self._metadata.gt_dir)\\n groundTruthImgList = glob.glob(\\n os.path.join(gt_dir, \\\"*\\\", \\\"*_gtFine_labelIds.png\\\")\\n )\\n assert len(\\n groundTruthImgList\\n ), \\\"Cannot find any ground truth images to use for evaluation. Searched for: {}\\\".format(\\n cityscapes_eval.args.groundTruthSearch\\n )\\n predictionImgList = []\\n for gt in groundTruthImgList:\\n predictionImgList.append(\\n cityscapes_eval.getPrediction(cityscapes_eval.args, gt)\\n )\\n results = cityscapes_eval.evaluateImgLists(\\n predictionImgList, groundTruthImgList, cityscapes_eval.args\\n )\\n ret = OrderedDict()\\n ret[\\\"sem_seg\\\"] = {\\n \\\"mIoU\\\": 100.0 * results[\\\"averageScoreClasses\\\"],\\n \\\"IoU.road\\\": 100.0 * results[\\\"classScores\\\"][\\\"road\\\"],\\n \\\"IoU.sidewalk\\\": 100.0 * results[\\\"classScores\\\"][\\\"sidewalk\\\"],\\n \\\"IoU.building\\\": 100.0 * results[\\\"classScores\\\"][\\\"building\\\"],\\n \\\"IoU.wall\\\": 100.0 * results[\\\"classScores\\\"][\\\"wall\\\"],\\n \\\"IoU.fence\\\": 100.0 * results[\\\"classScores\\\"][\\\"fence\\\"],\\n \\\"IoU.pole\\\": 100.0 * results[\\\"classScores\\\"][\\\"pole\\\"],\\n \\\"IoU.traffic light\\\": 100.0 * results[\\\"classScores\\\"][\\\"traffic light\\\"],\\n \\\"IoU.traffic sign\\\": 100.0 * results[\\\"classScores\\\"][\\\"traffic sign\\\"],\\n \\\"IoU.vegetation\\\": 100.0 * results[\\\"classScores\\\"][\\\"vegetation\\\"],\\n \\\"IoU.terrain\\\": 100.0 * results[\\\"classScores\\\"][\\\"terrain\\\"],\\n \\\"IoU.sky\\\": 100.0 * results[\\\"classScores\\\"][\\\"sky\\\"],\\n \\\"IoU.person\\\": 100.0 * results[\\\"classScores\\\"][\\\"person\\\"],\\n \\\"IoU.rider\\\": 100.0 * results[\\\"classScores\\\"][\\\"rider\\\"],\\n \\\"IoU.car\\\": 100.0 * results[\\\"classScores\\\"][\\\"car\\\"],\\n \\\"IoU.truck\\\": 100.0 * results[\\\"classScores\\\"][\\\"truck\\\"],\\n \\\"IoU.bus\\\": 100.0 * results[\\\"classScores\\\"][\\\"bus\\\"],\\n \\\"IoU.train\\\": 100.0 * results[\\\"classScores\\\"][\\\"train\\\"],\\n \\\"IoU.motorcycle\\\": 100.0 * results[\\\"classScores\\\"][\\\"motorcycle\\\"],\\n \\\"IoU.bicycle\\\": 100.0 * results[\\\"classScores\\\"][\\\"bicycle\\\"],\\n }\\n if not self._save_pl:\\n self._working_dir.cleanup()\\n return ret\"\n },\n {\n \"identifier\": \"ClassicalSemSegEvaluator\",\n \"path\": \"clouds/evaluation/semantic_evaluation.py\",\n \"snippet\": \"class ClassicalSemSegEvaluator(DatasetEvaluator):\\n \\\"\\\"\\\"\\n Evaluate semantic segmentation metrics.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n dataset_name,\\n distributed=True,\\n output_dir=None,\\n *,\\n sem_seg_loading_fn=load_image_into_numpy_array,\\n num_classes=None,\\n ignore_label=None,\\n save_pl=False,\\n ):\\n \\\"\\\"\\\"\\n Args:\\n dataset_name (str): name of the dataset to be evaluated.\\n distributed (bool): if True, will collect results from all ranks for evaluation.\\n Otherwise, will evaluate the results in the current process.\\n output_dir (str): an output directory to dump results.\\n sem_seg_loading_fn: function to read sem seg file and load into numpy array.\\n Default provided, but projects can customize.\\n num_classes, ignore_label: deprecated argument\\n \\\"\\\"\\\"\\n self._logger = logging.getLogger(__name__)\\n if num_classes is not None:\\n self._logger.warn(\\n \\\"SemSegEvaluator(num_classes) is deprecated! It should be obtained from metadata.\\\"\\n )\\n if ignore_label is not None:\\n self._logger.warn(\\n \\\"SemSegEvaluator(ignore_label) is deprecated! It should be obtained from metadata.\\\"\\n )\\n self._dataset_name = dataset_name\\n self._distributed = distributed\\n self._output_dir = output_dir\\n\\n self._cpu_device = torch.device(\\\"cpu\\\")\\n\\n self.input_file_to_gt_file = {\\n dataset_record[\\\"file_name\\\"]: dataset_record[\\\"sem_seg_file_name\\\"]\\n for dataset_record in DatasetCatalog.get(dataset_name)\\n }\\n\\n meta = MetadataCatalog.get(dataset_name)\\n # Dict that maps contiguous training ids to COCO category ids\\n try:\\n c2d = meta.stuff_dataset_id_to_contiguous_id\\n self._contiguous_id_to_dataset_id = {v: k for k, v in c2d.items()}\\n except AttributeError:\\n self._contiguous_id_to_dataset_id = None\\n self._class_names = meta.stuff_classes\\n self.sem_seg_loading_fn = sem_seg_loading_fn\\n self._num_classes = len(meta.stuff_classes)\\n if num_classes is not None:\\n assert (\\n self._num_classes == num_classes\\n ), f\\\"{self._num_classes} != {num_classes}\\\"\\n self._ignore_label = (\\n ignore_label if ignore_label is not None else meta.ignore_label\\n )\\n\\n # This is because cv2.erode did not work for int datatype. Only works for uint8.\\n self._compute_boundary_iou = True\\n if not _CV2_IMPORTED:\\n self._compute_boundary_iou = False\\n self._logger.warn(\\n \\\"\\\"\\\"Boundary IoU calculation requires OpenCV. B-IoU metrics are\\n not going to be computed because OpenCV is not available to import.\\\"\\\"\\\"\\n )\\n if self._num_classes >= np.iinfo(np.uint8).max:\\n self._compute_boundary_iou = False\\n self._logger.warn(\\n f\\\"\\\"\\\"SemSegEvaluator(num_classes) is more than supported value for Boundary IoU calculation!\\n B-IoU metrics are not going to be computed. Max allowed value (exclusive)\\n for num_classes for calculating Boundary IoU is {np.iinfo(np.uint8).max}.\\n The number of classes of dataset {self._dataset_name} is {self._num_classes}\\\"\\\"\\\"\\n )\\n self._save_pl = save_pl\\n\\n def reset(self):\\n self._conf_matrix = np.zeros(\\n (self._num_classes + 1, self._num_classes + 1), dtype=np.int64\\n )\\n self._b_conf_matrix = np.zeros(\\n (self._num_classes + 1, self._num_classes + 1), dtype=np.int64\\n )\\n self._predictions = []\\n\\n def process(self, inputs, outputs):\\n \\\"\\\"\\\"\\n Args:\\n inputs: the inputs to a model.\\n It is a list of dicts. Each dict corresponds to an image and\\n contains keys like \\\"height\\\", \\\"width\\\", \\\"file_name\\\".\\n outputs: the outputs of a model. It is either list of semantic segmentation predictions\\n (Tensor [H, W]) or list of dicts with key \\\"sem_seg\\\" that contains semantic\\n segmentation prediction in the same format.\\n \\\"\\\"\\\"\\n for input, output in zip(inputs, outputs):\\n output = output[\\\"sem_seg\\\"].argmax(dim=0).to(self._cpu_device)\\n pred = np.array(output, dtype=int)\\n gt = input[\\\"sem_seg\\\"].numpy()\\n\\n gt[gt == self._ignore_label] = self._num_classes\\n\\n self._conf_matrix += np.bincount(\\n (self._num_classes + 1) * pred.reshape(-1) + gt.reshape(-1),\\n minlength=self._conf_matrix.size,\\n ).reshape(self._conf_matrix.shape)\\n\\n if self._compute_boundary_iou:\\n b_gt = self._mask_to_boundary(gt.astype(np.uint8))\\n b_pred = self._mask_to_boundary(pred.astype(np.uint8))\\n\\n self._b_conf_matrix += np.bincount(\\n (self._num_classes + 1) * b_pred.reshape(-1) + b_gt.reshape(-1),\\n minlength=self._conf_matrix.size,\\n ).reshape(self._conf_matrix.shape)\\n\\n if self._save_pl:\\n self._predictions.extend(\\n [dict(file_name=input[\\\"file_name\\\"], pred=pred)]\\n )\\n else:\\n self._predictions.extend(\\n self.encode_json_sem_seg(pred, input[\\\"file_name\\\"])\\n )\\n\\n def evaluate(self):\\n \\\"\\\"\\\"\\n Evaluates standard semantic segmentation metrics (http://cocodataset.org/#stuff-eval):\\n\\n * Mean intersection-over-union averaged across classes (mIoU)\\n * Frequency Weighted IoU (fwIoU)\\n * Mean pixel accuracy averaged across classes (mACC)\\n * Pixel Accuracy (pACC)\\n \\\"\\\"\\\"\\n if self._distributed:\\n synchronize()\\n conf_matrix_list = all_gather(self._conf_matrix)\\n b_conf_matrix_list = all_gather(self._b_conf_matrix)\\n self._predictions = all_gather(self._predictions)\\n self._predictions = list(itertools.chain(*self._predictions))\\n if not is_main_process():\\n return\\n\\n self._conf_matrix = np.zeros_like(self._conf_matrix)\\n for conf_matrix in conf_matrix_list:\\n self._conf_matrix += conf_matrix\\n\\n self._b_conf_matrix = np.zeros_like(self._b_conf_matrix)\\n for b_conf_matrix in b_conf_matrix_list:\\n self._b_conf_matrix += b_conf_matrix\\n\\n if self._output_dir:\\n first_elem = self._predictions[0]\\n if \\\"bdd\\\" in first_elem[\\\"file_name\\\"]:\\n self._output_dir = os.path.join(self._output_dir, \\\"bdd_eval_pl\\\")\\n elif \\\"mapillary\\\" in first_elem[\\\"file_name\\\"]:\\n self._output_dir = os.path.join(self._output_dir, \\\"mapillary_eval_pl\\\")\\n PathManager.mkdirs(self._output_dir)\\n if self._save_pl:\\n # A function that will iterate over the list of dictionnaries and write the corresponding image\\n # in the output directory\\n def write_image_from_dict(dict):\\n filename = os.path.join(\\n self._output_dir,\\n dict[\\\"file_name\\\"].split(\\\"/\\\")[-1].split(\\\".\\\")[0] + \\\"_pred.png\\\",\\n )\\n pred = dict[\\\"pred\\\"]\\n pred = get_rgb_from_semantic_map_maxed(pred)\\n # pred = Image.fromarray(pred)\\n pred.save(filename)\\n\\n # We apply the function to the list of dictionnaries\\n list(map(write_image_from_dict, self._predictions))\\n\\n else:\\n file_path = os.path.join(self._output_dir, \\\"sem_seg_predictions.json\\\")\\n with PathManager.open(file_path, \\\"w\\\") as f:\\n f.write(json.dumps(self._predictions))\\n\\n acc = np.full(self._num_classes, np.nan, dtype=float)\\n iou = np.full(self._num_classes, np.nan, dtype=float)\\n tp = self._conf_matrix.diagonal()[:-1].astype(float)\\n pos_gt = np.sum(self._conf_matrix[:-1, :-1], axis=0).astype(float)\\n class_weights = pos_gt / np.sum(pos_gt)\\n pos_pred = np.sum(self._conf_matrix[:-1, :-1], axis=1).astype(float)\\n acc_valid = pos_gt > 0\\n acc[acc_valid] = tp[acc_valid] / pos_gt[acc_valid]\\n union = pos_gt + pos_pred - tp\\n iou_valid = np.logical_and(acc_valid, union > 0)\\n iou[iou_valid] = tp[iou_valid] / union[iou_valid]\\n macc = np.sum(acc[acc_valid]) / np.sum(acc_valid)\\n miou = np.sum(iou[iou_valid]) / np.sum(iou_valid)\\n fiou = np.sum(iou[iou_valid] * class_weights[iou_valid])\\n pacc = np.sum(tp) / np.sum(pos_gt)\\n\\n if self._compute_boundary_iou:\\n b_iou = np.full(self._num_classes, np.nan, dtype=float)\\n b_tp = self._b_conf_matrix.diagonal()[:-1].astype(float)\\n b_pos_gt = np.sum(self._b_conf_matrix[:-1, :-1], axis=0).astype(float)\\n b_pos_pred = np.sum(self._b_conf_matrix[:-1, :-1], axis=1).astype(float)\\n b_union = b_pos_gt + b_pos_pred - b_tp\\n b_iou_valid = b_union > 0\\n b_iou[b_iou_valid] = b_tp[b_iou_valid] / b_union[b_iou_valid]\\n\\n res = {}\\n res[\\\"mIoU\\\"] = 100 * miou\\n res[\\\"fwIoU\\\"] = 100 * fiou\\n for i, name in enumerate(self._class_names):\\n res[f\\\"IoU-{name}\\\"] = 100 * iou[i]\\n if self._compute_boundary_iou:\\n res[f\\\"BoundaryIoU-{name}\\\"] = 100 * b_iou[i]\\n res[f\\\"min(IoU, B-Iou)-{name}\\\"] = 100 * min(iou[i], b_iou[i])\\n res[\\\"mACC\\\"] = 100 * macc\\n res[\\\"pACC\\\"] = 100 * pacc\\n for i, name in enumerate(self._class_names):\\n res[f\\\"ACC-{name}\\\"] = 100 * acc[i]\\n\\n if self._output_dir:\\n file_path = os.path.join(self._output_dir, \\\"sem_seg_evaluation.pth\\\")\\n with PathManager.open(file_path, \\\"wb\\\") as f:\\n torch.save(res, f)\\n results = OrderedDict({\\\"sem_seg\\\": res})\\n self._logger.info(results)\\n\\n def get_miou_value_from_dict(dict, subkey):\\n for key, value in dict.items():\\n if subkey in key and \\\"IoU\\\" in key:\\n if np.isnan(value):\\n return 0\\n else:\\n return value\\n\\n ret = OrderedDict()\\n ret[\\\"sem_seg\\\"] = {\\n \\\"mIoU\\\": results[\\\"sem_seg\\\"][\\\"mIoU\\\"],\\n \\\"IoU.road\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"road\\\"),\\n \\\"IoU.sidewalk\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"sidewalk\\\"),\\n \\\"IoU.building\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"building\\\"),\\n \\\"IoU.wall\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"wall\\\"),\\n \\\"IoU.fence\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"fence\\\"),\\n \\\"IoU.pole\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"pole\\\"),\\n \\\"IoU.traffic light\\\": get_miou_value_from_dict(\\n results[\\\"sem_seg\\\"], \\\"traffic light\\\"\\n ),\\n \\\"IoU.traffic sign\\\": get_miou_value_from_dict(\\n results[\\\"sem_seg\\\"], \\\"traffic sign\\\"\\n ),\\n \\\"IoU.vegetation\\\": get_miou_value_from_dict(\\n results[\\\"sem_seg\\\"], \\\"vegetation\\\"\\n ),\\n \\\"IoU.terrain\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"terrain\\\"),\\n \\\"IoU.sky\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"sky\\\"),\\n \\\"IoU.person\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"person\\\"),\\n \\\"IoU.rider\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"rider\\\"),\\n \\\"IoU.car\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"car\\\"),\\n \\\"IoU.truck\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"truck\\\"),\\n \\\"IoU.bus\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"bus\\\"),\\n \\\"IoU.train\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"train\\\"),\\n \\\"IoU.motorcycle\\\": get_miou_value_from_dict(\\n results[\\\"sem_seg\\\"], \\\"motorcycle\\\"\\n ),\\n \\\"IoU.bicycle\\\": get_miou_value_from_dict(results[\\\"sem_seg\\\"], \\\"bicycle\\\"),\\n }\\n return ret\\n\\n def encode_json_sem_seg(self, sem_seg, input_file_name):\\n \\\"\\\"\\\"\\n Convert semantic segmentation to COCO stuff format with segments encoded as RLEs.\\n See http://cocodataset.org/#format-results\\n \\\"\\\"\\\"\\n json_list = []\\n for label in np.unique(sem_seg):\\n if self._contiguous_id_to_dataset_id is not None:\\n assert (\\n label in self._contiguous_id_to_dataset_id\\n ), \\\"Label {} is not in the metadata info for {}\\\".format(\\n label, self._dataset_name\\n )\\n dataset_id = self._contiguous_id_to_dataset_id[label]\\n else:\\n dataset_id = int(label)\\n mask = (sem_seg == label).astype(np.uint8)\\n mask_rle = mask_util.encode(np.array(mask[:, :, None], order=\\\"F\\\"))[0]\\n mask_rle[\\\"counts\\\"] = mask_rle[\\\"counts\\\"].decode(\\\"utf-8\\\")\\n json_list.append(\\n {\\n \\\"file_name\\\": input_file_name,\\n \\\"category_id\\\": dataset_id,\\n \\\"segmentation\\\": mask_rle,\\n }\\n )\\n return json_list\\n\\n def _mask_to_boundary(self, mask: np.ndarray, dilation_ratio=0.02):\\n assert mask.ndim == 2, \\\"mask_to_boundary expects a 2-dimensional image\\\"\\n h, w = mask.shape\\n diag_len = np.sqrt(h ** 2 + w ** 2)\\n dilation = max(1, int(round(dilation_ratio * diag_len)))\\n kernel = np.ones((3, 3), dtype=np.uint8)\\n\\n padded_mask = cv2.copyMakeBorder(mask, 1, 1, 1, 1, cv2.BORDER_CONSTANT, value=0)\\n eroded_mask_with_padding = cv2.erode(padded_mask, kernel, iterations=dilation)\\n eroded_mask = eroded_mask_with_padding[1:-1, 1:-1]\\n boundary = mask - eroded_mask\\n return boundary\"\n },\n {\n \"identifier\": \"PersoEvalHook\",\n \"path\": \"clouds/engine/hooks.py\",\n \"snippet\": \"class PersoEvalHook(HookBase):\\n \\\"\\\"\\\"\\n Run an evaluation function periodically, and at the end of training.\\n\\n It is executed every ``eval_period`` iterations and after the last iteration.\\n \\\"\\\"\\\"\\n\\n def __init__(self, eval_period, eval_function, eval_after_train=True):\\n \\\"\\\"\\\"\\n Args:\\n eval_period (int): the period to run `eval_function`. Set to 0 to\\n not evaluate periodically (but still evaluate after the last iteration\\n if `eval_after_train` is True).\\n eval_function (callable): a function which takes no arguments, and\\n returns a nested dict of evaluation metrics.\\n eval_after_train (bool): whether to evaluate after the last iteration\\n\\n Note:\\n This hook must be enabled in all or none workers.\\n If you would like only certain workers to perform evaluation,\\n give other workers a no-op function (`eval_function=lambda: None`).\\n \\\"\\\"\\\"\\n self._period = eval_period\\n self._func = eval_function\\n self._eval_after_train = eval_after_train\\n\\n def _do_eval(self):\\n results = self._func()\\n\\n if results:\\n assert isinstance(\\n results, dict\\n ), \\\"Eval function must return a dict. Got {} instead.\\\".format(results)\\n\\n flattened_results = flatten_results_dict(results)\\n for k, v in flattened_results.items():\\n try:\\n v = float(v)\\n except Exception as e:\\n raise ValueError(\\n \\\"[EvalHook] eval_function should return a nested dict of float. \\\"\\n \\\"Got '{}: {}' instead.\\\".format(k, v)\\n ) from e\\n self.trainer.storage.put_scalars(**flattened_results, smoothing_hint=False)\\n\\n # Evaluation may take different time among workers.\\n # A barrier make them start the next iteration together.\\n comm.synchronize()\\n\\n def before_train(self):\\n \\\"\\\"\\\"\\n Called before the first iteration.\\n \\\"\\\"\\\"\\n if \\\"debug\\\" in self.trainer.cfg.OUTPUT_DIR:\\n pass\\n else:\\n results = self._func()\\n\\n if results:\\n assert isinstance(\\n results, dict\\n ), \\\"Eval function must return a dict. Got {} instead.\\\".format(results)\\n\\n flattened_results = flatten_results_dict(results)\\n for k, v in flattened_results.items():\\n try:\\n v = float(v)\\n except Exception as e:\\n raise ValueError(\\n \\\"[EvalHook] eval_function should return a nested dict of float. \\\"\\n \\\"Got '{}: {}' instead.\\\".format(k, v)\\n ) from e\\n self.trainer.storage.put_scalars(\\n **flattened_results, smoothing_hint=False\\n )\\n\\n def after_step(self):\\n next_iter = self.trainer.iter + 1\\n if self._period > 0 and next_iter % self._period == 0:\\n # do the last eval in after_train\\n if next_iter != self.trainer.max_iter:\\n self._do_eval()\\n\\n def after_train(self):\\n # This condition is to prevent the eval from running after a failed training\\n if self._eval_after_train and self.trainer.iter + 1 >= self.trainer.max_iter:\\n self._do_eval()\\n # func is likely a closure that holds reference to the trainer\\n # therefore we clean it to avoid circular reference in the end\\n del self._func\"\n },\n {\n \"identifier\": \"WandbWriter\",\n \"path\": \"clouds/utils/events.py\",\n \"snippet\": \"class WandbWriter(EventWriter):\\n \\\"\\\"\\\"\\n Write all scalars to a tensorboard file.\\n \\\"\\\"\\\"\\n\\n def __init__(self):\\n \\\"\\\"\\\"\\n Args:\\n log_dir (str): the directory to save the output events\\n kwargs: other arguments passed to `torch.utils.tensorboard.SummaryWriter(...)`\\n \\\"\\\"\\\"\\n self._last_write = -1\\n self._group_rules = [\\n (IsIn(\\\"/\\\"), BaseRule()),\\n (IsIn(\\\"loss\\\"), Prefix(\\\"train\\\")),\\n # (IsIn(\\\"sem_seg\\\"), Prefix(\\\"val\\\")),\\n (\\n IsInList([\\\"lr\\\", \\\"time\\\", \\\"eta_seconds\\\", \\\"rank_data_time\\\", \\\"data_time\\\"]),\\n Prefix(\\\"stats\\\"),\\n ),\\n ]\\n\\n def write(self):\\n storage = get_event_storage()\\n\\n def _group_name(scalar_name):\\n for rule, op in self._group_rules:\\n if rule(scalar_name):\\n return op(scalar_name)\\n return scalar_name\\n\\n stats = {\\n _group_name(name): scalars[0]\\n for name, scalars in storage.latest().items()\\n if scalars[1] > self._last_write\\n }\\n if len(stats) > 0:\\n self._last_write = max([v[1] for k, v in storage.latest().items()])\\n\\n # storage.put_{image,histogram} is only meant to be used by\\n # tensorboard writer. So we access its internal fields directly from here.\\n if len(storage._vis_data) >= 1:\\n stats[\\\"image\\\"] = [\\n wandb.Image(img, caption=img_name)\\n for img_name, img, step_num in storage._vis_data\\n ]\\n # Storage stores all image data and rely on this writer to clear them.\\n # As a result it assumes only one writer will use its image data.\\n # An alternative design is to let storage store limited recent\\n # data (e.g. only the most recent image) that all writers can access.\\n # In that case a writer may not see all image data if its period is long.\\n storage.clear_images()\\n\\n if len(storage._histograms) >= 1:\\n\\n def create_bar(tag, bucket_limits, bucket_counts, **kwargs):\\n data = [\\n [label, val] for (label, val) in zip(bucket_limits, bucket_counts)\\n ]\\n table = wandb.Table(data=data, columns=[\\\"label\\\", \\\"value\\\"])\\n return wandb.plot.bar(table, \\\"label\\\", \\\"value\\\", title=tag)\\n\\n stats[\\\"hist\\\"] = [create_bar(**params) for params in storage._histograms]\\n\\n storage.clear_histograms()\\n\\n if len(stats) == 0:\\n return\\n wandb.log(stats, step=storage.iter)\\n\\n def close(self):\\n wandb.finish()\"\n },\n {\n \"identifier\": \"setup_wandb\",\n \"path\": \"clouds/utils/events.py\",\n \"snippet\": \"def setup_wandb(cfg, args):\\n if comm.is_main_process():\\n init_args = {\\n k.lower(): v\\n for k, v in cfg.WANDB.items()\\n if isinstance(k, str) and k not in [\\\"config\\\", \\\"name\\\"]\\n }\\n if \\\"config_exclude_keys\\\" in init_args:\\n init_args[\\\"config\\\"] = cfg\\n init_args[\\\"config\\\"][\\\"cfg_file\\\"] = args.config_file\\n else:\\n init_args[\\\"config\\\"] = {\\n \\\"output_dir\\\": cfg.OUTPUT_DIR,\\n \\\"train\\\": extract_dataset_from_string(cfg.DATASETS.TRAIN),\\n \\\"test\\\": extract_dataset_from_string(cfg.DATASETS.TEST),\\n \\\"iter\\\": cfg.SOLVER.MAX_ITER,\\n \\\"lr\\\": cfg.SOLVER.BASE_LR,\\n \\\"batch_size\\\": cfg.SOLVER.IMS_PER_BATCH,\\n \\\"cfg_file\\\": args.config_file,\\n }\\n\\n init_args[\\\"group\\\"] = get_base_name(cfg)\\n if cfg.WANDB.NAME is not None:\\n init_args[\\\"name\\\"] = cfg.WANDB.NAME\\n else:\\n init_args[\\\"name\\\"] = get_full_name_xp(init_args[\\\"group\\\"], cfg)\\n if \\\"debug\\\" in cfg.OUTPUT_DIR:\\n init_args[\\\"project\\\"] = \\\"debug\\\"\\n wandb.init(**init_args)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":" from shapely.errors import ShapelyDeprecationWarning\nfrom collections import OrderedDict\nfrom typing import Any, Dict, List, Set\nfrom detectron2.checkpoint import DetectionCheckpointer\nfrom detectron2.config import get_cfg\nfrom detectron2.data import (\n MetadataCatalog,\n build_detection_train_loader,\n build_detection_test_loader,\n)\nfrom detectron2.engine import (\n DefaultTrainer,\n default_argument_parser,\n default_setup,\n launch,\n)\nfrom detectron2.modeling import build_model\nfrom detectron2.evaluation import (\n CityscapesInstanceEvaluator,\n CityscapesSemSegEvaluator,\n COCOEvaluator,\n COCOPanopticEvaluator,\n DatasetEvaluators,\n LVISEvaluator,\n SemSegEvaluator,\n verify_results,\n inference_on_dataset,\n print_csv_format,\n DatasetEvaluator,\n)\nfrom detectron2.projects.deeplab import add_deeplab_config, build_lr_scheduler\nfrom detectron2.solver.build import maybe_add_gradient_clipping\nfrom detectron2.utils.logger import setup_logger\nfrom detectron2.engine import hooks\nfrom fvcore.nn.precise_bn import get_bn_modules\nfrom clouds import (\n\n CityscapesSemSegEvaluator,\n ClassicalSemSegEvaluator,\n MapperTrain,\n MapperTest,\n\n add_maskformer2_config,\n add_clouds_config,\n add_wandb_config,\n add_prerocessing_training_set_config,\n PersoEvalHook,\n add_repeat_factors,\n)\nfrom clouds.utils import setup_wandb, WandbWriter\n import warnings\nimport copy\nimport itertools\nimport logging\nimport os\nimport ast\nimport torch\nimport detectron2.utils.comm as comm"},"token_num":{"kind":"number","value":14555,"string":"14,555"},"cropped_code":{"kind":"string","value":" evaluators (list[DatasetEvaluator] or None): if None, will call\n :meth:`build_evaluator`. Otherwise, must have the same length as\n ``cfg.DATASETS.TEST``.\n\n Returns:\n dict: a dict of result metrics\n \"\"\"\n logger = logging.getLogger(__name__)\n if isinstance(evaluators, DatasetEvaluator):\n evaluators = [evaluators]\n if evaluators is not None:\n assert len(cfg.DATASETS.TEST) == len(evaluators), \"{} != {}\".format(\n len(cfg.DATASETS.TEST), len(evaluators)\n )\n\n results = OrderedDict()\n for idx, dataset_name in enumerate(cfg.DATASETS.TEST):\n data_loader = cls.build_test_loader(cfg, dataset_name)\n # When evaluators are passed in as arguments,\n # implicitly assume that evaluators can be created before data_loader.\n if evaluators is not None:\n evaluator = evaluators[idx]\n else:\n try:\n evaluator = cls.build_evaluator(\n cfg, dataset_name, output_folder=output_folder\n )\n except NotImplementedError:\n logger.warn(\n \"No evaluator found. Use `DefaultTrainer.test(evaluators=)`, \"\n \"or implement its `build_evaluator` method.\"\n )\n results[dataset_name] = {}\n continue\n results_i = inference_on_dataset(model, data_loader, evaluator)\n results[dataset_name] = results_i\n if comm.is_main_process():\n assert isinstance(\n results_i, dict\n ), \"Evaluator must return a dict on the main process. Got {} instead.\".format(\n results_i\n )\n logger.info(\n \"Evaluation results for {} in csv format:\".format(dataset_name)\n )\n print_csv_format(results_i)\n\n if len(results) == 1:\n results = list(results.values())[0]\n return results\n\n def build_hooks(self):\n \"\"\"\n Build a list of default hooks, including timing, evaluation,\n checkpointing, lr scheduling, precise BN, writing events.\n\n Returns:\n list[HookBase]:\n \"\"\"\n cfg = self.cfg.clone()\n cfg.defrost()\n cfg.DATALOADER.NUM_WORKERS = 0 # save some memory and time for PreciseBN\n\n ret = [\n hooks.IterationTimer(),\n hooks.LRScheduler(),\n hooks.PreciseBN(\n # Run at the same freq as (but before) evaluation.\n cfg.TEST.EVAL_PERIOD,\n self.model,\n # Build a new data loader to not affect training\n self.build_train_loader(cfg),\n cfg.TEST.PRECISE_BN.NUM_ITER,\n )\n if cfg.TEST.PRECISE_BN.ENABLED and get_bn_modules(self.model)\n else None,\n ]\n\n # Do PreciseBN before checkpointer, because it updates the model and need to\n # be saved by checkpointer.\n # This is not always the best: if checkpointing has a different frequency,\n # some checkpoints may have more precise statistics than others.\n if comm.is_main_process():\n ret.append(\n hooks.PeriodicCheckpointer(self.checkpointer, cfg.TEST.EVAL_PERIOD * 5)\n )\n\n def test_and_save_results():\n self._last_eval_results = self.test(self.cfg, self.model)\n return self._last_eval_results\n\n # Do evaluation after checkpointer, because then if it fails,\n # we can use the saved checkpoint to debug.\n # ret.append(hooks.EvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))\n ret.append(PersoEvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))\n\n if comm.is_main_process():\n # Here the default print/log frequency of each writer is used.\n # run writers in the end, so that evaluation metrics are written\n ret.append(hooks.PeriodicWriter(self.build_writers(), period=20))\n return ret\n\n\ndef setup(args):\n \"\"\"\n Create configs and perform basic setups.\n \"\"\"\n cfg = get_cfg()\n # for poly lr schedule\n add_deeplab_config(cfg)\n add_maskformer2_config(cfg)\n add_clouds_config(cfg)\n add_wandb_config(cfg)\n add_prerocessing_training_set_config(cfg)\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n add_repeat_factors(cfg)\n cfg.freeze()\n default_setup(cfg, args)\n if not args.eval_only:\n"},"all_code":{"kind":"string","value":"\"\"\"\nCopyright 2023 Telecom Paris, Yasser BENIGMIM. All rights reserved.\nLicensed under the Apache License, Version 2.0\nReference: https://github.com/facebookresearch/Mask2Former/blob/main/train_net.py\n\nCLOUDS Training Script.\n\nThis script is a simplified version of the training script in detectron2/tools.\n\"\"\"\ntry:\n # ignore ShapelyDeprecationWarning from fvcore\n\n warnings.filterwarnings(\"ignore\", category=ShapelyDeprecationWarning)\nexcept:\n pass\n\n\n\n\n\n\nclass Trainer(DefaultTrainer):\n \"\"\"\n Extension of the Trainer class adapted to CLOUDS.\n \"\"\"\n\n def build_writers(self):\n writers = super().build_writers()\n # use wandb writer instead.\n writers[-1] = WandbWriter()\n return writers\n\n @classmethod\n def build_model(cls, cfg):\n \"\"\"\n Returns:\n torch.nn.Module:\n\n It now calls :func:`detectron2.modeling.build_model`.\n Overwrite it if you'd like a different model.\n \"\"\"\n model = build_model(cfg)\n # logger = logging.getLogger(__name__)\n # logger.info(\"Model:\\n{}\".format(model))\n return model\n\n # @classmethod\n # def build_model(cls, cfg):\n # \"\"\"\n # Returns:\n # torch.nn.Module:\n #\n # It now calls :func:`detectron2.modeling.build_model`.\n # Overwrite it if you'd like a different model.\n # \"\"\"\n # model = build_model(cfg)\n # # logger = logging.getLogger(__name__)\n # # logger.info(\"Model:\\n{}\".format(model))\n # return model\n @classmethod\n def build_evaluator(cls, cfg, dataset_name, output_folder=None):\n \"\"\"\n Create evaluator(s) for a given dataset.\n This uses the special metadata \"evaluator_type\" associated with each\n builtin dataset. For your own dataset, you can simply create an\n evaluator manually in your script and do not have to worry about the\n hacky if-else logic here.\n \"\"\"\n if output_folder is None:\n output_folder = os.path.join(cfg.OUTPUT_DIR, \"inference\")\n else:\n output_folder = os.path.join(cfg.OUTPUT_DIR, output_folder, \"inference\")\n evaluator_list = []\n evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type\n # semantic segmentation\n if (\n evaluator_type == \"bdd_sem_seg\"\n or evaluator_type == \"mapillary_sem_seg\"\n or evaluator_type == \"acdc_sem_seg\"\n ):\n evaluator_list.append(\n ClassicalSemSegEvaluator(\n dataset_name,\n distributed=True,\n output_dir=output_folder,\n save_pl=cfg.MODEL.SAVE_PSEUDO_LABELS,\n )\n )\n # Cityscapes\n if evaluator_type == \"cityscapes_sem_seg\":\n assert (\n torch.cuda.device_count() > comm.get_rank()\n ), \"CityscapesEvaluator currently do not work with multiple machines.\"\n # return CityscapesSemSegEvaluator(dataset_name)\n if cfg.MODEL.SAVE_PSEUDO_LABELS:\n return CityscapesSemSegEvaluator(\n dataset_name, save_pl=True, output_dir=output_folder\n )\n else:\n return CityscapesSemSegEvaluator(dataset_name)\n if len(evaluator_list) == 0:\n raise NotImplementedError(\n \"no Evaluator for the dataset {} with the type {}\".format(\n dataset_name, evaluator_type\n )\n )\n elif len(evaluator_list) == 1:\n return evaluator_list[0]\n return DatasetEvaluators(evaluator_list)\n\n @classmethod\n def build_train_loader(cls, cfg):\n # Semantic segmentation dataset mapper\n mapper = MapperTrain(cfg, True)\n return build_detection_train_loader(cfg, mapper=mapper)\n\n @classmethod\n def build_test_loader(cls, cfg, dataset_name):\n mapper = MapperTest(cfg, False)\n return build_detection_test_loader(\n cfg, dataset_name, batch_size=1, mapper=mapper\n )\n\n @classmethod\n def build_lr_scheduler(cls, cfg, optimizer):\n \"\"\"\n It now calls :func:`detectron2.solver.build_lr_scheduler`.\n Overwrite it if you'd like a different scheduler.\n \"\"\"\n return build_lr_scheduler(cfg, optimizer)\n\n @classmethod\n def build_optimizer(cls, cfg, model):\n weight_decay_norm = cfg.SOLVER.WEIGHT_DECAY_NORM\n weight_decay_embed = cfg.SOLVER.WEIGHT_DECAY_EMBED\n\n defaults = {}\n defaults[\"lr\"] = cfg.SOLVER.BASE_LR\n defaults[\"weight_decay\"] = cfg.SOLVER.WEIGHT_DECAY\n\n norm_module_types = (\n torch.nn.BatchNorm1d,\n torch.nn.BatchNorm2d,\n torch.nn.BatchNorm3d,\n torch.nn.SyncBatchNorm,\n # NaiveSyncBatchNorm inherits from BatchNorm2d\n torch.nn.GroupNorm,\n torch.nn.InstanceNorm1d,\n torch.nn.InstanceNorm2d,\n torch.nn.InstanceNorm3d,\n torch.nn.LayerNorm,\n torch.nn.LocalResponseNorm,\n )\n\n params: List[Dict[str, Any]] = []\n memo: Set[torch.nn.parameter.Parameter] = set()\n for module_name, module in model.named_modules():\n for module_param_name, value in module.named_parameters(recurse=False):\n if not value.requires_grad:\n continue\n if cfg.MODEL.CLOUDS.OVERWRITING:\n if any(\n ignored_module in module_name\n for ignored_module in [\"sem_seg_head_ema.\", \"sam.sam.\"]\n ):\n continue\n # Avoid duplicating parameters\n if value in memo:\n continue\n memo.add(value)\n\n hyperparams = copy.copy(defaults)\n if \"backbone\" in module_name:\n hyperparams[\"lr\"] = (\n hyperparams[\"lr\"] * cfg.SOLVER.BACKBONE_MULTIPLIER\n )\n if (\n \"relative_position_bias_table\" in module_param_name\n or \"absolute_pos_embed\" in module_param_name\n ):\n print(module_param_name)\n hyperparams[\"weight_decay\"] = 0.0\n if isinstance(module, norm_module_types):\n hyperparams[\"weight_decay\"] = weight_decay_norm\n if isinstance(module, torch.nn.Embedding):\n hyperparams[\"weight_decay\"] = weight_decay_embed\n params.append({\"params\": [value], **hyperparams})\n\n def maybe_add_full_model_gradient_clipping(optim):\n # detectron2 doesn't have full model gradient clipping now\n clip_norm_val = cfg.SOLVER.CLIP_GRADIENTS.CLIP_VALUE\n enable = (\n cfg.SOLVER.CLIP_GRADIENTS.ENABLED\n and cfg.SOLVER.CLIP_GRADIENTS.CLIP_TYPE == \"full_model\"\n and clip_norm_val > 0.0\n )\n\n class FullModelGradientClippingOptimizer(optim):\n def step(self, closure=None):\n all_params = itertools.chain(\n *[x[\"params\"] for x in self.param_groups]\n )\n torch.nn.utils.clip_grad_norm_(all_params, clip_norm_val)\n super().step(closure=closure)\n\n return FullModelGradientClippingOptimizer if enable else optim\n\n optimizer_type = cfg.SOLVER.OPTIMIZER\n if optimizer_type == \"SGD\":\n optimizer = maybe_add_full_model_gradient_clipping(torch.optim.SGD)(\n params, cfg.SOLVER.BASE_LR, momentum=cfg.SOLVER.MOMENTUM\n )\n elif optimizer_type == \"ADAMW\":\n optimizer = maybe_add_full_model_gradient_clipping(torch.optim.AdamW)(\n params, cfg.SOLVER.BASE_LR\n )\n else:\n raise NotImplementedError(f\"no optimizer type {optimizer_type}\")\n if not cfg.SOLVER.CLIP_GRADIENTS.CLIP_TYPE == \"full_model\":\n optimizer = maybe_add_gradient_clipping(cfg, optimizer)\n return optimizer\n\n @classmethod\n def test(cls, cfg, model, output_folder=None, evaluators=None):\n \"\"\"\n Evaluate the given model. The given model is expected to already contain\n weights to evaluate.\n\n Args:\n cfg (CfgNode):\n model (nn.Module):\n evaluators (list[DatasetEvaluator] or None): if None, will call\n :meth:`build_evaluator`. Otherwise, must have the same length as\n ``cfg.DATASETS.TEST``.\n\n Returns:\n dict: a dict of result metrics\n \"\"\"\n logger = logging.getLogger(__name__)\n if isinstance(evaluators, DatasetEvaluator):\n evaluators = [evaluators]\n if evaluators is not None:\n assert len(cfg.DATASETS.TEST) == len(evaluators), \"{} != {}\".format(\n len(cfg.DATASETS.TEST), len(evaluators)\n )\n\n results = OrderedDict()\n for idx, dataset_name in enumerate(cfg.DATASETS.TEST):\n data_loader = cls.build_test_loader(cfg, dataset_name)\n # When evaluators are passed in as arguments,\n # implicitly assume that evaluators can be created before data_loader.\n if evaluators is not None:\n evaluator = evaluators[idx]\n else:\n try:\n evaluator = cls.build_evaluator(\n cfg, dataset_name, output_folder=output_folder\n )\n except NotImplementedError:\n logger.warn(\n \"No evaluator found. Use `DefaultTrainer.test(evaluators=)`, \"\n \"or implement its `build_evaluator` method.\"\n )\n results[dataset_name] = {}\n continue\n results_i = inference_on_dataset(model, data_loader, evaluator)\n results[dataset_name] = results_i\n if comm.is_main_process():\n assert isinstance(\n results_i, dict\n ), \"Evaluator must return a dict on the main process. Got {} instead.\".format(\n results_i\n )\n logger.info(\n \"Evaluation results for {} in csv format:\".format(dataset_name)\n )\n print_csv_format(results_i)\n\n if len(results) == 1:\n results = list(results.values())[0]\n return results\n\n def build_hooks(self):\n \"\"\"\n Build a list of default hooks, including timing, evaluation,\n checkpointing, lr scheduling, precise BN, writing events.\n\n Returns:\n list[HookBase]:\n \"\"\"\n cfg = self.cfg.clone()\n cfg.defrost()\n cfg.DATALOADER.NUM_WORKERS = 0 # save some memory and time for PreciseBN\n\n ret = [\n hooks.IterationTimer(),\n hooks.LRScheduler(),\n hooks.PreciseBN(\n # Run at the same freq as (but before) evaluation.\n cfg.TEST.EVAL_PERIOD,\n self.model,\n # Build a new data loader to not affect training\n self.build_train_loader(cfg),\n cfg.TEST.PRECISE_BN.NUM_ITER,\n )\n if cfg.TEST.PRECISE_BN.ENABLED and get_bn_modules(self.model)\n else None,\n ]\n\n # Do PreciseBN before checkpointer, because it updates the model and need to\n # be saved by checkpointer.\n # This is not always the best: if checkpointing has a different frequency,\n # some checkpoints may have more precise statistics than others.\n if comm.is_main_process():\n ret.append(\n hooks.PeriodicCheckpointer(self.checkpointer, cfg.TEST.EVAL_PERIOD * 5)\n )\n\n def test_and_save_results():\n self._last_eval_results = self.test(self.cfg, self.model)\n return self._last_eval_results\n\n # Do evaluation after checkpointer, because then if it fails,\n # we can use the saved checkpoint to debug.\n # ret.append(hooks.EvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))\n ret.append(PersoEvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))\n\n if comm.is_main_process():\n # Here the default print/log frequency of each writer is used.\n # run writers in the end, so that evaluation metrics are written\n ret.append(hooks.PeriodicWriter(self.build_writers(), period=20))\n return ret\n\n\ndef setup(args):\n \"\"\"\n Create configs and perform basic setups.\n \"\"\"\n cfg = get_cfg()\n # for poly lr schedule\n add_deeplab_config(cfg)\n add_maskformer2_config(cfg)\n add_clouds_config(cfg)\n add_wandb_config(cfg)\n add_prerocessing_training_set_config(cfg)\n cfg.merge_from_file(args.config_file)\n cfg.merge_from_list(args.opts)\n add_repeat_factors(cfg)\n cfg.freeze()\n default_setup(cfg, args)\n if not args.eval_only:"},"next_line":{"kind":"string","value":" setup_wandb(cfg, args)"},"gold_snippet_index":{"kind":"number","value":11,"string":"11"},"created_at":{"kind":"string","value":"2023-12-15 15:40:58+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5675,"cells":{"repo_name":{"kind":"string","value":"Ruiyuan-Zhang/CCS"},"file_path":{"kind":"string","value":"multi_part_assembly/utils/wx_transformer_utilities/transformer_layer.py"},"context":{"kind":"list like","value":[{"identifier":"LayerNorm","path":"multi_part_assembly/utils/wx_transformer_utilities/layer_norm.py","snippet":"def LayerNorm(normalized_shape, eps=1e-5, elementwise_affine=True, export=False):\n if not export and torch.cuda.is_available() and has_fused_layernorm:\n return FusedLayerNorm(normalized_shape, eps, elementwise_affine)\n return torch.nn.LayerNorm(normalized_shape, eps, elementwise_affine)"},{"identifier":"MultiheadAttention","path":"multi_part_assembly/utils/wx_transformer_utilities/multihead_attention.py","snippet":"class MultiheadAttention(nn.Module):\n \"\"\"Multi-headed attention.\n\n See \"Attention Is All You Need\" for more details.\n \"\"\"\n\n def __init__(\n self,\n embed_dim,\n num_heads,\n kdim=None,\n vdim=None,\n dropout=0.0,\n bias=True,\n add_bias_kv=False,\n add_zero_attn=False,\n self_attention=False,\n encoder_decoder_attention=False,\n q_noise=0.0,\n qn_block_size=8,\n nblocks=1,\n top_k_ratio=None,\n use_value_competition=True,\n shared_memory_attention = False,\n use_topk = False,\n topk = 3,\n num_steps = 5,\n mem_slots = 4,\n null_attention = False,\n regressive = False\n ):\n super().__init__()\n self.embed_dim = embed_dim\n self.kdim = kdim if kdim is not None else embed_dim\n self.vdim = vdim if vdim is not None else embed_dim\n self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim\n\n self.num_heads = num_heads\n self.dropout_module = FairseqDropout(\n dropout, module_name=self.__class__.__name__\n )\n\n self.head_dim = embed_dim // num_heads\n self.shared_memory_attention = shared_memory_attention\n\n print('total heads', self.num_heads)\n print('head dim', self.head_dim)\n\n self.use_topk = use_topk\n self.topk = topk\n\n print('use topk?' + str(self.use_topk))\n print('topk:'+str(self.topk))\n\n assert (\n self.head_dim * num_heads == self.embed_dim\n ), \"embed_dim must be divisible by num_heads\"\n self.scaling = self.head_dim ** -0.5\n\n self.self_attention = self_attention\n self.encoder_decoder_attention = encoder_decoder_attention\n\n assert not self.self_attention or self.qkv_same_dim, (\n \"Self-attention requires query, key and \" \"value to be of the same size\"\n )\n if not self.shared_memory_attention: # 这里的共享memory_attention是什么内容呢？表示的是不在不同的layer之间共享memory吗？\n self.k_proj = quant_noise(GroupLinearLayer(self.kdim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\n self.v_proj = quant_noise(GroupLinearLayer(self.vdim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\n self.q_proj = quant_noise(GroupLinearLayer(embed_dim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\n self.out_proj = quant_noise(GroupLinearLayer(embed_dim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\n\n if add_bias_kv:\n self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))\n self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))\n if self.shared_memory_attention:\n self.bias_k_memory = Parameter(torch.Tensor(1, 1, embed_dim))\n self.bias_v_memory = Parameter(torch.Tensor(1, 1, embed_dim))\n else:\n self.bias_k = self.bias_v = None\n self.bias_k_memory = self.bias_v_memory = None\n\n self.add_zero_attn = add_zero_attn\n\n self.reset_parameters()\n\n self.onnx_trace = False\n self.tpu = False\n\n # 这里表示，如果共享memory_attention的话\n if self.shared_memory_attention:\n print('MEM SLOTS:' + str(mem_slots))\n print('Null attention:' + str(null_attention))\n print('USING SHARED MEMORY ATTENTION +++++++++')\n #self.num_heads = 1\n self.regressive = regressive\n if not regressive: \n self.relational_memory = RelationalMemory(\n mem_slots=mem_slots,\n head_size=self.head_dim , #128\n input_size=embed_dim,\n output_size=embed_dim,\n num_heads=self.num_heads, #1\n num_blocks=1,\n forget_bias=1,\n input_bias=0,\n gate_style=\"unit\",\n attention_mlp_layers=1,\n key_size=32,\n return_all_outputs=False,\n use_topk = self.use_topk,\n topk = self.topk,\n num_steps = num_steps, \n null_attention = null_attention\n )\n else:\n print('USING AUTO REGRESSIVE')\n self.relational_memory = RelationalMemoryRegressive(\n mem_slots=mem_slots,\n head_size=self.head_dim ,\n input_size=embed_dim,\n output_size=embed_dim,\n num_heads=self.num_heads,\n num_blocks=1,\n forget_bias=1,\n input_bias=0,\n gate_style=\"unit\",\n attention_mlp_layers=4,\n key_size=32,\n return_all_outputs=False,\n use_topk = self.use_topk,\n topk = self.topk,\n num_steps = num_steps,\n null_attention = False\n )\n self.memory_size = 128 #self.head_dim * self.num_heads\n '''\n self.mem_att = MHAMemory(\n n_head=4,\n d_model_read=embed_dim,\n d_model_write=self.memory_size,\n d_model_out=embed_dim,\n d_k=32,\n d_v=32,\n grad_sparse=False,\n )\n '''\n self.memory = None # 因为要共享self.memory，所以这里是为了占个位置\n\n def prepare_for_onnx_export_(self):\n self.onnx_trace = True\n\n def prepare_for_tpu_(self, **kwargs):\n self.tpu = True\n\n def reset_parameters(self):\n if self.qkv_same_dim:\n # Empirically observed the convergence to be much better with\n # the scaled initialization\n nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))\n if self.shared_memory_attention:\n nn.init.xavier_uniform_(self.k_proj_memory.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.v_proj_memory.weight, gain=1 / math.sqrt(2))\n nn.init.xavier_uniform_(self.q_proj_memory.weight, gain=1 / math.sqrt(2))\n\n else:\n nn.init.xavier_uniform_(self.k_proj.weight)\n nn.init.xavier_uniform_(self.v_proj.weight)\n nn.init.xavier_uniform_(self.q_proj.weight)\n\n #if self.shared_memory_attention:\n # nn.init.xavier_uniform_(self.k_proj_memory.weight)\n # nn.init.xavier_uniform_(self.v_proj_memory.weight)\n # nn.init.xavier_uniform_(self.q_proj_memory.weight)\n\n nn.init.xavier_uniform_(self.out_proj.weight)\n #if self.shared_memory_attention:\n # nn.init.xavier_uniform_(self.out_proj_memory.weight)\n \n if self.out_proj.bias is not None:\n nn.init.constant_(self.out_proj.bias, 0.)\n\n #if self.shared_memory_attention and self.out_proj_memory.bias is not None:\n # nn.init.constant_(self.out_proj.bias, 0.)\n \n if self.bias_k is not None:\n nn.init.xavier_normal_(self.bias_k)\n if self.bias_v is not None:\n nn.init.xavier_normal_(self.bias_v)\n\n #if self.shared_memory_attention:\n # if self.bias_k is not None:\n # nn.init.xavier_normal_(self.bias_k_memory)\n # if self.bias_v is not None:\n # nn.init.xavier_normal_(self.bias_v_memory)\n\n\n def forward(\n self,\n query,\n key: Optional[Tensor],\n value: Optional[Tensor],\n key_padding_mask: Optional[Tensor] = None,\n incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,\n need_weights: bool = True,\n static_kv: bool = False,\n attn_mask: Optional[Tensor] = None,\n before_softmax: bool = False,\n need_head_weights: bool = False,\n comp = None,\n memory = None\n ) -> Tuple[Tensor, Optional[Tensor]]:\n \"\"\"Input shape: Time x Batch x Channel\n\n Args:\n key_padding_mask (ByteTensor, optional): mask to exclude\n keys that are pads, of shape `(batch, src_len)`, where\n padding elements are indicated by 1s.\n need_weights (bool, optional): return the attention weights,\n averaged over heads (default: False).\n attn_mask (ByteTensor, optional): typically used to\n implement causal attention, where the mask prevents the\n attention from looking forward in time (default: None).\n before_softmax (bool, optional): return the raw attention\n weights and values before the attention softmax.\n need_head_weights (bool, optional): return the attention\n weights for each head. Implies *need_weights*. Default:\n return the average attention weights over all heads.\n \"\"\"\n if need_head_weights:\n need_weights = True\n\n tgt_len, bsz, embed_dim = query.size()\n assert embed_dim == self.embed_dim\n assert list(query.size()) == [tgt_len, bsz, embed_dim]\n\n if (\n not self.onnx_trace\n and not self.tpu # don't use PyTorch version on TPUs\n and incremental_state is None\n and not static_kv\n # A workaround for quantization to work. Otherwise JIT compilation\n # treats bias in linear module as method.\n and not torch.jit.is_scripting()\n and False\n ):\n assert key is not None and value is not None\n if self.shared_memory_attention:\n memory,_ = F.multi_head_attention_forward(\n memory,\n key,\n value,\n self.embed_dim,\n self.num_heads,\n torch.empty([0]),\n torch.cat((self.q_proj_memory.bias, self.k_proj.bias, self.v_proj.bias)),\n self.bias_k,\n self.bias_v,\n self.add_zero_attn,\n self.dropout_module.p,\n self.out_proj_memory.weight,\n self.out_proj_memory.bias,\n self.training or self.dropout_module.apply_during_inference,\n key_padding_mask,\n need_weights,\n attn_mask,\n use_separate_proj_weight=True,\n q_proj_weight=self.q_proj_memory.weight,\n k_proj_weight=self.k_proj.weight,\n v_proj_weight=self.v_proj.weight,\n )\n out,weights = F.multi_head_attention_forward(\n query,\n memory,\n memory,\n self.embed_dim,\n self.num_heads,\n torch.empty([0]),\n torch.cat((self.q_proj.bias, self.k_proj_memory.bias, self.v_proj_memory.bias)),\n self.bias_k_memory,\n self.bias_v_memory,\n self.add_zero_attn,\n self.dropout_module.p,\n self.out_proj.weight,\n self.out_proj.bias,\n self.training or self.dropout_module.apply_during_inference,\n key_padding_mask,\n need_weights,\n attn_mask,\n use_separate_proj_weight=True,\n q_proj_weight=self.q_proj.weight,\n k_proj_weight=self.k_proj_memory.weight,\n v_proj_weight=self.v_proj_memory.weight,\n )\n else:\n out, weights = F.multi_head_attention_forward(\n query,\n key,\n value,\n self.embed_dim,\n self.num_heads,\n torch.empty([0]),\n torch.cat((self.q_proj.bias, self.k_proj.bias, self.v_proj.bias)),\n self.bias_k,\n self.bias_v,\n self.add_zero_attn,\n self.dropout_module.p,\n self.out_proj.weight,\n self.out_proj.bias,\n self.training or self.dropout_module.apply_during_inference,\n key_padding_mask,\n need_weights,\n attn_mask,\n use_separate_proj_weight=True,\n q_proj_weight=self.q_proj.weight,\n k_proj_weight=self.k_proj.weight,\n v_proj_weight=self.v_proj.weight,\n\n ) \n\n return out, memory, weights\n\n if incremental_state is not None:\n saved_state = self._get_input_buffer(incremental_state)\n if saved_state is not None and \"prev_key\" in saved_state:\n # previous time steps are cached - no need to recompute\n # key and value if they are static\n if static_kv:\n assert self.encoder_decoder_attention and not self.self_attention\n key = value = None\n else:\n saved_state = None\n\n # 如果不共享memory attention\n if not self.shared_memory_attention:\n\n t1 = time.time()\n\n if self.self_attention:\n q = self.q_proj(query)\n k = self.k_proj(query)\n v = self.v_proj(query)\n elif self.encoder_decoder_attention:\n # encoder-decoder attention\n q = self.q_proj(query)\n if key is None:\n assert value is None\n k = v = None\n else:\n k = self.k_proj(key)\n v = self.v_proj(key)\n\n else:\n assert key is not None and value is not None\n \n q = self.q_proj(query)\n k = self.k_proj(key)\n v = self.v_proj(value)\n\n if comp is not None:\n v = v * comp\n #v_memory = v_memory * comp\n q *= self.scaling\n #q_memory *= self.scaling\n\n if self.bias_k is not None:\n assert self.bias_v is not None\n k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])\n v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])\n if attn_mask is not None:\n attn_mask = torch.cat(\n [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1\n )\n if key_padding_mask is not None:\n key_padding_mask = torch.cat(\n [\n key_padding_mask,\n key_padding_mask.new_zeros(key_padding_mask.size(0), 1),\n ],\n dim=1,\n )\n\n q = (\n q.contiguous()\n .view(tgt_len, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n if k is not None:\n k = (\n k.contiguous()\n .view(-1, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n if v is not None:\n v = (\n v.contiguous()\n .view(-1, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n \n if saved_state is not None:\n # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)\n if \"prev_key\" in saved_state:\n _prev_key = saved_state[\"prev_key\"]\n assert _prev_key is not None\n prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)\n if static_kv:\n k = prev_key\n else:\n assert k is not None\n k = torch.cat([prev_key, k], dim=1)\n if \"prev_value\" in saved_state:\n _prev_value = saved_state[\"prev_value\"]\n assert _prev_value is not None\n prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)\n if static_kv:\n v = prev_value\n else:\n assert v is not None\n v = torch.cat([prev_value, v], dim=1)\n prev_key_padding_mask: Optional[Tensor] = None\n if \"prev_key_padding_mask\" in saved_state:\n prev_key_padding_mask = saved_state[\"prev_key_padding_mask\"]\n assert k is not None and v is not None\n key_padding_mask = MultiheadAttention._append_prev_key_padding_mask(\n key_padding_mask=key_padding_mask,\n prev_key_padding_mask=prev_key_padding_mask,\n batch_size=bsz,\n src_len=k.size(1),\n static_kv=static_kv,\n )\n\n saved_state[\"prev_key\"] = k.view(bsz, self.num_heads, -1, self.head_dim)\n saved_state[\"prev_value\"] = v.view(bsz, self.num_heads, -1, self.head_dim)\n saved_state[\"prev_key_padding_mask\"] = key_padding_mask\n # In this branch incremental_state is never None\n assert incremental_state is not None\n incremental_state = self._set_input_buffer(incremental_state, saved_state)\n assert k is not None\n src_len = k.size(1)\n\n # This is part of a workaround to get around fork/join parallelism\n # not supporting Optional types.\n if key_padding_mask is not None and key_padding_mask.dim() == 0:\n key_padding_mask = None\n\n if key_padding_mask is not None:\n assert key_padding_mask.size(0) == bsz\n assert key_padding_mask.size(1) == src_len\n\n if self.add_zero_attn:\n assert v is not None\n src_len += 1\n k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)\n v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)\n if attn_mask is not None:\n attn_mask = torch.cat(\n [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1\n )\n if key_padding_mask is not None:\n key_padding_mask = torch.cat(\n [\n key_padding_mask,\n torch.zeros(key_padding_mask.size(0), 1).type_as(\n key_padding_mask\n ),\n ],\n dim=1,\n )\n\n attn_weights = torch.bmm(q, k.transpose(1, 2))\n attn_weights = MultiheadAttention.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)\n\n assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]\n\n if attn_mask is not None:\n attn_mask = attn_mask.unsqueeze(0)\n if self.onnx_trace:\n attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1)\n attn_weights += attn_mask\n\n if key_padding_mask is not None:\n # don't attend to padding symbols\n attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)\n if not self.tpu:\n attn_weights = attn_weights.masked_fill(\n key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),\n float(\"-inf\")\n )\n else:\n attn_weights = attn_weights.transpose(0, 2)\n attn_weights = attn_weights.masked_fill(key_padding_mask, float('-inf'))\n attn_weights = attn_weights.transpose(0, 2)\n attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)\n\n if before_softmax:\n return attn_weights, v\n \n # 是这个\n attn_weights_float = utils.softmax(\n attn_weights, dim=-1, onnx_trace=self.onnx_trace\n )\n attn_weights = attn_weights_float.type_as(attn_weights)\n attn_probs = self.dropout_module(attn_weights)\n\n assert v is not None\n if self.use_topk:\n k = torch.topk(attn_probs, dim = 2, k = self.topk)\n mask = torch.zeros(attn_probs.size()).to(attn_probs.device)\n mask.scatter_(2, k.indices, 1)\n attn_probs = attn_probs * mask\n attn = torch.bmm(attn_probs, v)\n assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]\n if self.onnx_trace and attn.size(1) == 1:\n # when ONNX tracing a single decoder step (sequence length == 1)\n # the transpose is a no-op copy before view, thus unnecessary\n attn = attn.contiguous().view(tgt_len, bsz, embed_dim)\n else:\n attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)\n attn = self.out_proj(attn)\n attn_weights: Optional[Tensor] = None\n if need_weights:\n attn_weights = attn_weights_float.view(\n bsz, self.num_heads, tgt_len, src_len\n ).transpose(1, 0)\n if not need_head_weights:\n # average attention weights over heads\n attn_weights = attn_weights.mean(dim=0)\n #print('time taken by default mha:' + str(time.time() - t1))\n return attn, None, attn_weights\n \n else: # 共享注意力机制 memory\n t1 = time.time()\n\n # 这个是共享memory的时候\n if self.memory is None:\n self.memory = self.relational_memory.initial_state(query.size(1), query.size(0)).to(query.device)\n\n self.memory = self.memory.to(query.device)\n\n #print(self.memory.size())\n \n \n key = key.transpose(1, 0)\n\n #print(key.size())\n #memory = self.memory[:key.size(0)]\n #print(self.memory.size())\n\n t2 = time.time()\n\n #print(self.memory)\n\n # self.memory只是一个memory更新的方式，它并不是workspace吧！！！ lm-workspace这篇代码是不是搞错了\n # 那这个 self.memory \n # 这里是对memory进行更新\n # 利用relational_memory 来对 workspace中的memory进行更新\n _,_, self.memory, out_hx_mem_new = self.relational_memory(\n inputs=key,\n memory=self.memory#.cuda(),\n )\n #print('time taken by relational:' + str(time.time() - t2))\n\n\n\n #query = query.transpose(1, 0)\n #if self.regressive:\n # B, T, D = query.size()\n # query = query.reshape(B * T, -1).unsqueeze(1)\n #out_hx_mem_new, _, _ = self.mem_att(\n # query,#.reshape((bsz, self.num_blocks_out, self.block_size_out)),\n # self.memory,\n # self.memory,\n # )\n\n #z = torch.zeros(self.memory.size(0) - memory.size(0), memory.size(1), memory.size(2)).to(memory.device)\n #memory = torch.cat((memory, z), dim = 0)\n #self.memory = self.memory + memory\n #print('time taken by shared mha:' + str(time.time() - t1))\n #if self.regressive:\n # out_hx_mem_new = out_hx_mem_new.squeeze(1)\n # out_hx_mem_new = out_hx_mem_new.reshape(B, T, -1)\n\n # 这里的memory实际上没啥用处了，emmm 我觉得\n return out_hx_mem_new.transpose(0, 1), memory, None\n \"\"\"\n\n tgt_len = memory.size(0)\n src_len = key.size(0)\n q_memory = self.q_proj_memory(memory)\n k = self.k_proj(key)\n v = self.v_proj(value)\n\n q_memory = (\n q_memory.contiguous()\n .view(memory.size(0), bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n k = (\n k.contiguous()\n .view(-1, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n v = (\n v.contiguous()\n .view(-1, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n \n\n attn_weights_1 = torch.bmm(q_memory, k.transpose(1, 2))\n\n if key_padding_mask is not None:\n # don't attend to padding symbols\n attn_weights_1 = attn_weights_1.view(bsz, self.num_heads, tgt_len, src_len)\n attn_weights_1 = attn_weights_1.masked_fill(\n key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),\n float(\"-inf\")\n )\n\n attn_weights_float_1 = utils.softmax(\n attn_weights_1, dim=-1, onnx_trace=self.onnx_trace\n )\n attn_weights_1 = attn_weights_float_1.type_as(attn_weights_1)\n attn_probs_1 = self.dropout_module(attn_weights_1)\n\n assert v is not None\n memory = torch.bmm(attn_probs_1, v)\n\n memory = memory.permute(1, 0, 2)\n memory = memory.reshape(memory.size(0), bsz, self.num_heads, -1)\n memory = memory.reshape(memory.size(0), bsz, -1)\n\n\n\n q = self.q_proj(query)\n \n k_memory = self.k_proj_memory(memory)\n v_memory = self.v_proj_memory(memory)\n\n q = (\n q.contiguous()\n .view(src_len, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n k_memory = (\n k.contiguous()\n .view(-1, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n v_memory = (\n v.contiguous()\n .view(-1, bsz * self.num_heads, self.head_dim)\n .transpose(0, 1)\n )\n\n attn_weights_2 = torch.bmm(q, k_memory.transpose(1, 2))\n \n attn_weights_float_2 = utils.softmax(\n attn_weights_2, dim=-1, onnx_trace=self.onnx_trace\n )\n \n attn_weights_2 = attn_weights_float_2.type_as(attn_weights_2)\n attn_probs_2 = self.dropout_module(attn_weights_2)\n\n out = torch.bmm(attn_probs_2, v)\n out = out.transpose(0, 1).contiguous().view(src_len, bsz, embed_dim)\n return out, memory, None\n \"\"\"\n \n # 共享参数的时候，或者是共享memory attn的时候，\n def init_memory(self, bs, ts = None, device = None):\n if not self.regressive:\n self.memory = self.relational_memory.initial_state(bs).to(device)\n else:\n self.memory = self.relational_memory.initial_state(bs, ts).to(device)\n\n\n @staticmethod\n def _append_prev_key_padding_mask(\n key_padding_mask: Optional[Tensor],\n prev_key_padding_mask: Optional[Tensor],\n batch_size: int,\n src_len: int,\n static_kv: bool,\n ) -> Optional[Tensor]:\n # saved key padding masks have shape (bsz, seq_len)\n if prev_key_padding_mask is not None and static_kv:\n new_key_padding_mask = prev_key_padding_mask\n elif prev_key_padding_mask is not None and key_padding_mask is not None:\n new_key_padding_mask = torch.cat(\n [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1\n )\n # During incremental decoding, as the padding token enters and\n # leaves the frame, there will be a time when prev or current\n # is None\n elif prev_key_padding_mask is not None:\n filler = torch.zeros(\n (batch_size, src_len - prev_key_padding_mask.size(1)),\n device=prev_key_padding_mask.device,\n )\n new_key_padding_mask = torch.cat(\n [prev_key_padding_mask.float(), filler.float()], dim=1\n )\n elif key_padding_mask is not None:\n filler = torch.zeros(\n (batch_size, src_len - key_padding_mask.size(1)),\n device=key_padding_mask.device,\n )\n new_key_padding_mask = torch.cat(\n [filler.float(), key_padding_mask.float()], dim=1\n )\n else:\n new_key_padding_mask = prev_key_padding_mask\n return new_key_padding_mask\n\n @torch.jit.export\n def reorder_incremental_state(\n self, incremental_state: Dict[str, Dict[str, Optional[Tensor]]], new_order: Tensor\n ):\n \"\"\"Reorder buffered internal state (for incremental generation).\"\"\"\n input_buffer = self._get_input_buffer(incremental_state)\n if input_buffer is not None:\n for k in input_buffer.keys():\n input_buffer_k = input_buffer[k]\n if input_buffer_k is not None:\n if self.encoder_decoder_attention and input_buffer_k.size(0) == new_order.size(0):\n break\n input_buffer[k] = input_buffer_k.index_select(0, new_order)\n incremental_state = self._set_input_buffer(incremental_state, input_buffer)\n return incremental_state\n\n def _get_input_buffer(\n self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]\n ) -> Dict[str, Optional[Tensor]]:\n result = self.get_incremental_state(incremental_state, \"attn_state\")\n if result is not None:\n return result\n else:\n empty_result: Dict[str, Optional[Tensor]] = {}\n return empty_result\n\n def _set_input_buffer(\n self,\n incremental_state: Dict[str, Dict[str, Optional[Tensor]]],\n buffer: Dict[str, Optional[Tensor]],\n ):\n return self.set_incremental_state(incremental_state, \"attn_state\", buffer)\n\n def apply_sparse_mask(attn_weights, tgt_len: int, src_len: int, bsz: int):\n return attn_weights\n\n def upgrade_state_dict_named(self, state_dict, name):\n prefix = name + \".\" if name != \"\" else \"\"\n items_to_add = {}\n keys_to_remove = []\n for k in state_dict.keys():\n if k.endswith(prefix + \"in_proj_weight\"):\n # in_proj_weight used to be q + k + v with same dimensions\n dim = int(state_dict[k].shape[0] / 3)\n items_to_add[prefix + \"q_proj.weight\"] = state_dict[k][:dim]\n items_to_add[prefix + \"k_proj.weight\"] = state_dict[k][dim : 2 * dim]\n items_to_add[prefix + \"v_proj.weight\"] = state_dict[k][2 * dim :]\n\n keys_to_remove.append(k)\n\n k_bias = prefix + \"in_proj_bias\"\n if k_bias in state_dict.keys():\n dim = int(state_dict[k].shape[0] / 3)\n items_to_add[prefix + \"q_proj.bias\"] = state_dict[k_bias][:dim]\n items_to_add[prefix + \"k_proj.bias\"] = state_dict[k_bias][\n dim : 2 * dim\n ]\n items_to_add[prefix + \"v_proj.bias\"] = state_dict[k_bias][2 * dim :]\n\n keys_to_remove.append(prefix + \"in_proj_bias\")\n\n for k in keys_to_remove:\n del state_dict[k]\n\n for key, value in items_to_add.items():\n state_dict[key] = value"},{"identifier":"RelationalMemory","path":"multi_part_assembly/utils/wx_transformer_utilities/relational_memory.py","snippet":"class RelationalMemory(nn.Module):\n \"\"\"\n Constructs a `RelationalMemory` object.\n This class is same as the RMC from relational_rnn_models.py, but without language modeling-specific variables.\n Args:\n mem_slots: The total number of memory slots to use.\n head_size: The size of an attention head.\n input_size: The size of input per step. i.e. the dimension of each input vector\n num_heads: The number of attention heads to use. Defaults to 1.\n num_blocks: Number of times to compute attention per time step. Defaults\n to 1.\n forget_bias: Bias to use for the forget gate, assuming we are using\n some form of gating. Defaults to 1.\n input_bias: Bias to use for the input gate, assuming we are using\n some form of gating. Defaults to 0.\n gate_style: Whether to use per-element gating ('unit'),\n per-memory slot gating ('memory'), or no gating at all (None).\n Defaults to `unit`.\n attention_mlp_layers: Number of layers to use in the post-attention\n MLP. Defaults to 2.\n key_size: Size of vector to use for key & query vectors in the attention\n computation. Defaults to None, in which case we use `head_size`.\n name: Name of the module.\n\n # NEW flag for this class\n return_all_outputs: Whether the model returns outputs for each step (like seq2seq) or only the final output.\n Raises:\n ValueError: gate_style not one of [None, 'memory', 'unit'].\n ValueError: num_blocks is < 1.\n ValueError: attention_mlp_layers is < 1.\n \"\"\"\n\n def __init__(self, mem_slots, head_size, input_size, output_size, num_heads=1, num_blocks=1, forget_bias=1., input_bias=0.,\n gate_style='unit', attention_mlp_layers=2, key_size=None, return_all_outputs=False, use_topk = False, topk = 3, num_steps = 5,\n null_attention = False):\n super(RelationalMemory, self).__init__()\n\n ########## generic parameters for RMC ##########\n self.mem_slots = mem_slots\n self.head_size = head_size\n self.num_heads = num_heads\n self.mem_size = self.head_size * self.num_heads\n self.use_topk = use_topk\n self.topk = topk\n self.attn_log = None\n\n # a new fixed params needed for pytorch port of RMC\n # +1 is the concatenated input per time step : we do self-attention with the concatenated memory & input\n # so if the mem_slots = 1, this value is 2\n self.mem_slots_plus_input = self.mem_slots + 1\n\n if num_blocks < 1:\n raise ValueError('num_blocks must be >=1. Got: {}.'.format(num_blocks))\n self.num_blocks = num_blocks\n\n if gate_style not in ['unit', 'memory', None]:\n raise ValueError(\n 'gate_style must be one of [\\'unit\\', \\'memory\\', None]. got: '\n '{}.'.format(gate_style))\n self.gate_style = gate_style\n\n if attention_mlp_layers < 1:\n raise ValueError('attention_mlp_layers must be >= 1. Got: {}.'.format(\n attention_mlp_layers))\n self.attention_mlp_layers = attention_mlp_layers\n\n self.key_size = key_size if key_size else self.head_size\n\n ########## parameters for multihead attention ##########\n # value_size is same as head_size\n self.value_size = self.head_size\n # total size for query-key-value\n self.qkv_size = 2 * self.key_size + self.value_size\n self.total_qkv_size = self.qkv_size * self.num_heads # denoted as F\n\n self.query_proj = nn.Linear(self.mem_size, self.key_size * self.num_heads)\n self.key_proj = nn.Linear(self.mem_size, self.key_size * self.num_heads)\n self.value_proj = nn.Linear(self.mem_size, self.value_size * self.num_heads)\n\n\n # each head has qkv_sized linear projector\n # just using one big param is more efficient, rather than this line\n # self.qkv_projector = [nn.Parameter(torch.randn((self.qkv_size, self.qkv_size))) for _ in range(self.num_heads)]\n self.qkv_projector = nn.Linear(self.mem_size, self.total_qkv_size)\n self.qkv_layernorm = nn.LayerNorm(self.total_qkv_size)\n\n # used for attend_over_memory function\n self.attention_mlp = nn.ModuleList([nn.Linear(self.mem_size, self.mem_size)] * self.attention_mlp_layers)\n self.attended_memory_layernorm = nn.LayerNorm( self.mem_size)\n self.attended_memory_layernorm2 = nn.LayerNorm(self.mem_size)\n\n ########## parameters for initial embedded input projection ##########\n self.input_size = input_size\n self.input_projector = nn.Linear(self.input_size, self.mem_size)\n\n self.output_projector = nn.Linear(self.output_size, self.input_size)\n\n ########## parameters for gating ##########\n self.num_gates = 2 * self.calculate_gate_size()\n print('input projector:'+str(self.mem_size))\n self.input_gate_projector = nn.Linear(self.mem_size * num_steps, self.num_gates)\n self.memory_gate_projector = nn.Linear(self.mem_size, self.num_gates)\n # trainable scalar gate bias tensors\n self.forget_bias = nn.Parameter(torch.tensor(forget_bias, dtype=torch.float32))\n self.input_bias = nn.Parameter(torch.tensor(input_bias, dtype=torch.float32))\n\n ########## number of outputs returned #####\n self.return_all_outputs = return_all_outputs\n\n self.null_attention = null_attention\n\n self.competition_mlp = nn.Sequential(nn.Linear(self.mem_slots * self.mem_size + self.mem_size, 256),\n nn.ReLU(),\n nn.Linear(256, 256),\n nn.ReLU(),\n nn.Linear(256, 256),\n nn.ReLU(),\n nn.Linear(256, 2))\n\n def repackage_hidden(self, h):\n \"\"\"Wraps hidden states in new Tensors, to detach them from their history.\"\"\"\n # needed for truncated BPTT, called at every batch forward pass\n if isinstance(h, torch.Tensor):\n return h.detach()\n else:\n return tuple(self.repackage_hidden(v) for v in h)\n\n def initial_state(self, batch_size, trainable=False):\n \"\"\"\n Creates the initial memory.\n We should ensure each row of the memory is initialized to be unique,\n so initialize the matrix to be the identity. We then pad or truncate\n as necessary so that init_state is of size\n (batch_size, self.mem_slots, self.mem_size).\n Args:\n batch_size: The size of the batch.\n trainable: Whether the initial state is trainable. This is always True.\n Returns:\n init_state: A truncated or padded matrix of size\n (batch_size, self.mem_slots, self.mem_size).\n \"\"\"\n init_state = torch.stack([torch.eye(self.mem_slots) for _ in range(batch_size)])\n\n # pad the matrix with zeros\n if self.mem_size > self.mem_slots:\n difference = self.mem_size - self.mem_slots\n pad = torch.zeros((batch_size, self.mem_slots, difference))\n init_state = torch.cat([init_state, pad], -1)\n\n # truncation. take the first 'self.mem_size' components\n elif self.mem_size < self.mem_slots:\n init_state = init_state[:, :, :self.mem_size]\n\n return init_state\n\n def multihead_attention(self, input, memory):\n \"\"\"\n Perform multi-head attention from 'Attention is All You Need'.\n Implementation of the attention mechanism from\n https://arxiv.org/abs/1706.03762.\n Args:\n memory: Memory tensor to perform attention on.\n Returns:\n new_memory: New memory tensor.\n \"\"\"\n\n q = self.query_proj(memory)\n k = self.key_proj(input)\n v = self.value_proj(input)\n\n q = q.reshape(q.size(0), q.size(1), self.num_heads, -1).permute(0, 2, 1, 3)\n k = k.reshape(k.size(0), k.size(1), self.num_heads, -1).permute(0, 2, 1, 3)\n v = v.reshape(v.size(0), v.size(1), self.num_heads, -1).permute(0, 2, 1, 3)\n scores = torch.matmul(q, k.transpose(2, 3))\n\n scores = torch.softmax(scores, dim = -1)\n self.attn_log = scores[0]\n if not self.null_attention:\n if self.use_topk:\n topk = torch.topk(scores, dim = -1, k = self.topk)\n mask = torch.zeros(scores.size()).to(scores.device)\n mask.scatter_(3, topk.indices, 1)\n scores = scores * mask\n else:\n memory_flat = memory.reshape(memory.size(0), -1).unsqueeze(1)\n memory_flat = memory_flat.repeat(1, input.shape[1], 1)\n\n N = torch.cat((input, memory_flat), dim = 2)\n N = self.competition_mlp(N)\n\n N = torch.nn.functional.gumbel_softmax(N, dim = 2, hard = True, tau = 0.5)\n\n N = N[:, :, 0]\n\n scores = scores * N.unsqueeze(1).unsqueeze(1)\n\n\n output = torch.matmul(scores, v)\n\n \"\"\"#print(memory.size())\n # First, a simple linear projection is used to construct queries\n qkv = self.qkv_projector(memory)\n # apply layernorm for every dim except the batch dim\n qkv = self.qkv_layernorm(qkv)\n\n # mem_slots needs to be dynamically computed since mem_slots got concatenated with inputs\n # example: self.mem_slots=10 and seq_length is 3, and then mem_slots is 10 + 1 = 11 for each 3 step forward pass\n # this is the same as self.mem_slots_plus_input, but defined to keep the sonnet implementation code style\n mem_slots = memory.shape[1] # denoted as N\n\n # split the qkv to multiple heads H\n # [B, N, F] => [B, N, H, F/H]\n qkv_reshape = qkv.view(qkv.shape[0], mem_slots, self.num_heads, self.qkv_size)\n\n # [B, N, H, F/H] => [B, H, N, F/H]\n qkv_transpose = qkv_reshape.permute(0, 2, 1, 3)\n\n # [B, H, N, key_size], [B, H, N, key_size], [B, H, N, value_size]\n q, k, v = torch.split(qkv_transpose, [self.key_size, self.key_size, self.value_size], -1)\n\n # scale q with d_k, the dimensionality of the key vectors\n q *= (self.key_size ** -0.5)\n\n # make it [B, H, N, N]\n dot_product = torch.matmul(q, k.permute(0, 1, 3, 2))\n weights = F.softmax(dot_product, dim=-1)\n\n if self.use_topk:\n topk = torch.topk(weights, dim = -1, k = self.topk)\n mask = torch.zeros(weights.size()).to(weights.device)\n mask.scatter_(3, topk.indices, 1)\n weights = weights * mask\n\n # output is [B, H, N, V]\n output = torch.matmul(weights, v)\"\"\"\n\n # [B, H, N, V] => [B, N, H, V] => [B, N, H*V]\n output_transpose = output.permute(0, 2, 1, 3).contiguous()\n new_memory = output_transpose.view((output_transpose.shape[0], output_transpose.shape[1], -1))\n\n return new_memory\n\n\n @property\n def state_size(self):\n return [self.mem_slots, self.mem_size]\n\n @property\n def output_size(self):\n return self.mem_slots * self.mem_size\n\n def calculate_gate_size(self):\n \"\"\"\n Calculate the gate size from the gate_style.\n Returns:\n The per sample, per head parameter size of each gate.\n \"\"\"\n if self.gate_style == 'unit':\n return self.mem_size\n elif self.gate_style == 'memory':\n return 1\n else: # self.gate_style == None\n return 0\n\n def print_log(self):\n print(self.attn_log)\n\n def create_gates(self, inputs, memory):\n \"\"\"\n Create input and forget gates for this step using `inputs` and `memory`.\n Args:\n inputs: Tensor input.\n memory: The current state of memory.\n Returns:\n input_gate: A LSTM-like insert gate.\n forget_gate: A LSTM-like forget gate.\n \"\"\"\n # We'll create the input and forget gates at once. Hence, calculate double\n # the gate size.\n\n # equation 8: since there is no output gate, h is just a tanh'ed m\n memory = torch.tanh(memory)\n\n # TODO: check this input flattening is correct\n # sonnet uses this, but i think it assumes time step of 1 for all cases\n # if inputs is (B, T, features) where T > 1, this gets incorrect\n # inputs = inputs.view(inputs.shape[0], -1)\n\n # fixed implementation\n if len(inputs.shape) == 3:\n #if inputs.shape[1] > 1:\n # raise ValueError(\n # \"input seq length is larger than 1. create_gate function is meant to be called for each step, with input seq length of 1\")\n inputs = inputs.view(inputs.shape[0], -1)\n # matmul for equation 4 and 5\n # there is no output gate, so equation 6 is not implemented\n gate_inputs = self.input_gate_projector(inputs)\n gate_inputs = gate_inputs.unsqueeze(dim=1)\n gate_memory = self.memory_gate_projector(memory)\n else:\n raise ValueError(\"input shape of create_gate function is 2, expects 3\")\n\n # this completes the equation 4 and 5\n #print(gate_inputs.size())\n #print(gate_memory.size())\n gates = gate_memory + gate_inputs\n gates = torch.split(gates, split_size_or_sections=int(gates.shape[2] / 2), dim=2)\n input_gate, forget_gate = gates\n assert input_gate.shape[2] == forget_gate.shape[2]\n\n # to be used for equation 7\n input_gate = torch.sigmoid(input_gate + self.input_bias)\n forget_gate = torch.sigmoid(forget_gate + self.forget_bias)\n\n return input_gate, forget_gate\n\n def attend_over_memory(self, inputs, memory):\n \"\"\"\n Perform multiheaded attention over `memory`.\n Args:\n memory: Current relational memory.\n Returns:\n The attended-over memory.\n \"\"\"\n for _ in range(self.num_blocks):\n attended_memory = self.multihead_attention(inputs, memory)\n\n # Add a skip connection to the multiheaded attention's input.\n memory = self.attended_memory_layernorm(memory + attended_memory)\n\n # add a skip connection to the attention_mlp's input.\n attention_mlp = memory\n for i, l in enumerate(self.attention_mlp):\n attention_mlp = self.attention_mlp[i](attention_mlp)\n attention_mlp = F.relu(attention_mlp)\n memory = self.multihead_attention(memory, memory, use_topk_ = False, store_log = False)\n memory = self.attended_memory_layernorm2(memory + attention_mlp)\n\n return memory\n\n def forward_step(self, inputs, memory, treat_input_as_matrix=False):\n \"\"\"\n Forward step of the relational memory core.\n Args:\n inputs: Tensor input.\n memory: Memory output from the previous time step.\n treat_input_as_matrix: Optional, whether to treat `input` as a sequence\n of matrices. Default to False, in which case the input is flattened\n into a vector.\n Returns:\n output: This time step's output.\n next_memory: The next version of memory to use.\n \"\"\"\n\n if treat_input_as_matrix:\n # keep (Batch, Seq, ...) dim (0, 1), flatten starting from dim 2\n inputs = inputs.view(inputs.shape[0], inputs.shape[1], -1)\n # apply linear layer for dim 2\n inputs_reshape = self.input_projector(inputs)\n else:\n # keep (Batch, ...) dim (0), flatten starting from dim 1\n inputs = inputs.view(inputs.shape[0], -1)\n # apply linear layer for dim 1\n inputs = self.input_projector(inputs)\n # unsqueeze the time step to dim 1\n inputs_reshape = inputs.unsqueeze(dim=1)\n\n #memory_plus_input = torch.cat([memory, inputs_reshape], dim=1)\n #print(memory_plus_input.size())\n next_memory = self.attend_over_memory(inputs_reshape, memory)\n\n # cut out the concatenated input vectors from the original memory slots\n #n = inputs_reshape.shape[1]\n #next_memory = next_memory[:, :-n, :]\n\n if self.gate_style == 'unit' or self.gate_style == 'memory':\n # these gates are sigmoid-applied ones for equation 7\n input_gate, forget_gate = self.create_gates(inputs_reshape, memory)\n # equation 7 calculation\n next_memory = input_gate * torch.tanh(next_memory)\n next_memory += forget_gate * memory\n\n\n output = next_memory.view(next_memory.shape[0], -1)\n return output, next_memory\n\n def forward(self, inputs, memory, parallel = True):\n # Starting each batch, we detach the hidden state from how it was previously produced.\n # If we didn't, the model would try backpropagating all the way to start of the dataset.\n # memory = self.repackage_hidden(memory)\n\n # for loop implementation of (entire) recurrent forward pass of the model\n # inputs is batch first [batch, seq], and output logit per step is [batch, vocab]\n # so the concatenated logits are [seq * batch, vocab]\n\n # targets are flattened [seq, batch] => [seq * batch], so the dimension is correct\n\n logits = []\n #print(inputs.size())\n #print(memory.size())\n #memory = self.repackage_hidden(memory)\n # shape[1] is seq_lenth T\n if not parallel:\n for idx_step in range(inputs.shape[1]):\n logit, memory = self.forward_step(inputs[:, idx_step], memory)\n logits.append(logit)\n logits = torch.cat(logits)\n else:\n logits, memory = self.forward_step(inputs, memory, treat_input_as_matrix = True)\n \n memory_out = self.output_projector(memory.view(memory.shape[0], -1))\n\n #print(inputs.size())\n #print(memory_out.size())\n #print('------')\n if self.return_all_outputs:\n return logits, memory_out , memory\n else:\n return logits, memory_out, memory"},{"identifier":"GroupLinearLayer","path":"multi_part_assembly/utils/wx_transformer_utilities/group_linear_layer.py","snippet":"class GroupLinearLayer(nn.Module):\n\n def __init__(self, din, dout, num_blocks, bias=True, a = None):\n super(GroupLinearLayer, self).__init__()\n self.nb = num_blocks\n self.dout = dout\n\n if a is None:\n a = 1. / math.sqrt(dout * num_blocks)\n\n #gain = 1.0 / math.sqrt(2)\n #a = gain * math.sqrt(6.0 / (din + dout))\n\n self.weight = nn.Parameter(torch.FloatTensor(num_blocks,din,dout).uniform_(-a,a))\n\n self.bias = bias\n\n if bias is True:\n self.bias = nn.Parameter(torch.FloatTensor(num_blocks,dout).uniform_(-a,a))\n #self.bias = nn.Parameter(torch.zeros(dout*num_blocks))\n else:\n self.bias = None\n\n def forward(self,x):\n\n\t#input: ts x bs x blocks*nhid\n\t#ts*bs , blocks, nhid\n\t#blocks, ts*bs, nhid\n ts,bs,m = x.shape\t\n\n x = x.reshape((ts*bs, self.nb, m//self.nb))\n x = x.permute(1,0,2)\n x = torch.bmm(x,self.weight)\n x = x.permute(1,0,2)\n \n if not self.bias is None:\n x = x + self.bias\n\n x = x.reshape((ts, bs, self.dout*self.nb))\n \n #if not self.bias is None:\n # x += self.bias\n\n return x"},{"identifier":"MemoryAttention","path":"multi_part_assembly/utils/wx_transformer_utilities/basic_mha.py","snippet":"class MemoryAttention(nn.Module):\n def __init__(self, n_blocks_query, n_blocks_val, dim_query, dim_val, n_heads=8):\n super(MemoryAttention, self).__init__()\n\n self.n_heads = n_heads\n self.n_blocks_val = n_blocks_val\n self.dim_val = dim_val\n self.block_dim_val = dim_val // self.n_blocks_val\n\n self.n_blocks_query = n_blocks_query\n self.dim_query = dim_query\n self.block_dim_query = dim_query // self.n_blocks_query\n\n self.head_dim = 64\n self.scale = self.head_dim ** -0.5\n\n #self.n_blocks_val * self.block_dim_val\n\n self.query_net = GroupLinearLayer(self.block_dim_query, self.head_dim * self.n_heads, n_blocks_query)\n self.key_net = GroupLinearLayer(self.block_dim_val, self.head_dim * self.n_heads, n_blocks_val)\n self.value_net = GroupLinearLayer(self.block_dim_val, self.head_dim * self.n_heads, n_blocks_val)\n self.final = GroupLinearLayer(self.head_dim * self.n_heads, self.block_dim_query, n_blocks_query)\n\n def forward(self, q, kv):\n\n #comes in as: bs, pos*emb.\n #positions_attend x T*bs x emb\n\n\n #q = q.permute(1,0,2)\n #kv = kv.permute(1,0,2)\n\n #print('kv shape after permute', kv.shape)\n\n seq_len_q,bsz,_ = q.shape\n seq_len_v,bsz,_ = kv.shape\n\n q = q.reshape((seq_len_q, bsz, self.n_blocks_query * self.block_dim_query))\n\n kv = kv.reshape((seq_len_v, bsz, self.n_blocks_val * self.block_dim_val))\n\n q = self.query_net(q).view(seq_len_q, bsz, self.n_blocks_query, self.n_heads, self.head_dim)\n k = self.key_net(kv).view(seq_len_v, bsz, self.n_blocks_val, self.n_heads, self.head_dim)\n v = self.value_net(kv).view(seq_len_v, bsz, self.n_blocks_val, self.n_heads, self.head_dim)\n\n q = q.transpose(2,3) * self.scale\n k = k.transpose(2,3)\n v = v.transpose(2,3)\n score = torch.matmul(q, k.transpose(3,4))\n #print('score shape', score.shape)\n score = F.softmax(score, dim=-1)\n out = torch.matmul(score, v).transpose(2,3)\n #print('out shape', out.shape)\n score = score.mean(dim=2)\n\n out = out.reshape(seq_len_q, bsz, self.n_blocks_query * self.head_dim * self.n_heads)\n out = self.final(out)\n out = out.view(seq_len_q, bsz, self.dim_query)\n\n\n return out, score"},{"identifier":"quant_noise","path":"multi_part_assembly/utils/wx_transformer_utilities/quant_noise.py","snippet":"def quant_noise(module, p, block_size):\n \"\"\"\n Wraps modules and applies quantization noise to the weights for\n subsequent quantization with Iterative Product Quantization as\n described in \"Training with Quantization Noise for Extreme Model Compression\"\n\n Args:\n - module: nn.Module\n - p: amount of Quantization Noise\n - block_size: size of the blocks for subsequent quantization with iPQ\n\n Remarks:\n - Module weights must have the right sizes wrt the block size\n - Only Linear, Embedding and Conv2d modules are supported for the moment\n - For more detail on how to quantize by blocks with convolutional weights,\n see \"And the Bit Goes Down: Revisiting the Quantization of Neural Networks\"\n - We implement the simplest form of noise here as stated in the paper\n which consists in randomly dropping blocks\n \"\"\"\n\n # if no quantization noise, don't register hook\n if p <= 0:\n return module\n\n # supported modules\n assert isinstance(module, (nn.Linear, nn.Embedding, nn.Conv2d))\n\n # test whether module.weight has the right sizes wrt block_size\n is_conv = module.weight.ndim == 4\n\n # 2D matrix\n if not is_conv:\n assert module.weight.size(1) % block_size == 0, \"Input features must be a multiple of block sizes\"\n\n # 4D matrix\n else:\n # 1x1 convolutions\n if module.kernel_size == (1, 1):\n assert module.in_channels % block_size == 0, \"Input channels must be a multiple of block sizes\"\n # regular convolutions\n else:\n k = module.kernel_size[0] * module.kernel_size[1]\n assert k % block_size == 0, \"Kernel size must be a multiple of block size\"\n\n def _forward_pre_hook(mod, input):\n # no noise for evaluation\n if mod.training:\n if not is_conv:\n # gather weight and sizes\n weight = mod.weight\n in_features = weight.size(1)\n out_features = weight.size(0)\n\n # split weight matrix into blocks and randomly drop selected blocks\n mask = torch.zeros(in_features // block_size * out_features, device=weight.device)\n mask.bernoulli_(p)\n mask = mask.repeat_interleave(block_size, -1).view(-1, in_features)\n\n else:\n # gather weight and sizes\n weight = mod.weight\n in_channels = mod.in_channels\n out_channels = mod.out_channels\n\n # split weight matrix into blocks and randomly drop selected blocks\n if mod.kernel_size == (1, 1):\n mask = torch.zeros(int(in_channels // block_size * out_channels), device=weight.device)\n mask.bernoulli_(p)\n mask = mask.repeat_interleave(block_size, -1).view(-1, in_channels)\n else:\n mask = torch.zeros(weight.size(0), weight.size(1), device=weight.device)\n mask.bernoulli_(p)\n mask = mask.unsqueeze(2).unsqueeze(3).repeat(1, 1, mod.kernel_size[0], mod.kernel_size[1])\n\n # scale weights and apply mask\n mask = mask.to(torch.bool) # x.bool() is not currently supported in TorchScript\n s = 1 / (1 - p)\n mod.weight.data = s * weight.masked_fill(mask, 0)\n\n module.register_forward_pre_hook(_forward_pre_hook)\n return module"},{"identifier":"FairseqDropout","path":"multi_part_assembly/utils/wx_transformer_utilities/fairseq_dropout.py","snippet":"class FairseqDropout(nn.Module):\n\n def __init__(self, p, module_name=None):\n super().__init__()\n self.p = p\n self.module_name = module_name\n self.apply_during_inference = False\n\n def forward(self, x, inplace: bool = False):\n if self.training or self.apply_during_inference:\n return F.dropout(x, p=self.p, training=True, inplace=inplace)\n else:\n return x\n\n def make_generation_fast_(\n self,\n name: str,\n retain_dropout: bool = False,\n retain_dropout_modules: Optional[List[str]] = None,\n **kwargs\n ):\n if retain_dropout:\n if retain_dropout_modules is not None and self.module_name is None:\n logger.warning(\n 'Cannot enable dropout during inference for module {} '\n 'because module_name was not set'.format(name)\n )\n elif (\n retain_dropout_modules is None # if None, apply to all modules\n or self.module_name in retain_dropout_modules\n ):\n logger.info(\n 'Enabling dropout during inference for module: {}'.format(name)\n )\n self.apply_during_inference = True\n else:\n logger.info('Disabling dropout for module: {}'.format(name))"}],"string":"[\n {\n \"identifier\": \"LayerNorm\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/layer_norm.py\",\n \"snippet\": \"def LayerNorm(normalized_shape, eps=1e-5, elementwise_affine=True, export=False):\\n if not export and torch.cuda.is_available() and has_fused_layernorm:\\n return FusedLayerNorm(normalized_shape, eps, elementwise_affine)\\n return torch.nn.LayerNorm(normalized_shape, eps, elementwise_affine)\"\n },\n {\n \"identifier\": \"MultiheadAttention\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/multihead_attention.py\",\n \"snippet\": \"class MultiheadAttention(nn.Module):\\n \\\"\\\"\\\"Multi-headed attention.\\n\\n See \\\"Attention Is All You Need\\\" for more details.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n embed_dim,\\n num_heads,\\n kdim=None,\\n vdim=None,\\n dropout=0.0,\\n bias=True,\\n add_bias_kv=False,\\n add_zero_attn=False,\\n self_attention=False,\\n encoder_decoder_attention=False,\\n q_noise=0.0,\\n qn_block_size=8,\\n nblocks=1,\\n top_k_ratio=None,\\n use_value_competition=True,\\n shared_memory_attention = False,\\n use_topk = False,\\n topk = 3,\\n num_steps = 5,\\n mem_slots = 4,\\n null_attention = False,\\n regressive = False\\n ):\\n super().__init__()\\n self.embed_dim = embed_dim\\n self.kdim = kdim if kdim is not None else embed_dim\\n self.vdim = vdim if vdim is not None else embed_dim\\n self.qkv_same_dim = self.kdim == embed_dim and self.vdim == embed_dim\\n\\n self.num_heads = num_heads\\n self.dropout_module = FairseqDropout(\\n dropout, module_name=self.__class__.__name__\\n )\\n\\n self.head_dim = embed_dim // num_heads\\n self.shared_memory_attention = shared_memory_attention\\n\\n print('total heads', self.num_heads)\\n print('head dim', self.head_dim)\\n\\n self.use_topk = use_topk\\n self.topk = topk\\n\\n print('use topk?' + str(self.use_topk))\\n print('topk:'+str(self.topk))\\n\\n assert (\\n self.head_dim * num_heads == self.embed_dim\\n ), \\\"embed_dim must be divisible by num_heads\\\"\\n self.scaling = self.head_dim ** -0.5\\n\\n self.self_attention = self_attention\\n self.encoder_decoder_attention = encoder_decoder_attention\\n\\n assert not self.self_attention or self.qkv_same_dim, (\\n \\\"Self-attention requires query, key and \\\" \\\"value to be of the same size\\\"\\n )\\n if not self.shared_memory_attention: # 这里的共享memory_attention是什么内容呢？表示的是不在不同的layer之间共享memory吗？\\n self.k_proj = quant_noise(GroupLinearLayer(self.kdim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\\n self.v_proj = quant_noise(GroupLinearLayer(self.vdim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\\n self.q_proj = quant_noise(GroupLinearLayer(embed_dim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\\n self.out_proj = quant_noise(GroupLinearLayer(embed_dim//nblocks, embed_dim//nblocks, nblocks, bias=bias), q_noise, qn_block_size)\\n\\n if add_bias_kv:\\n self.bias_k = Parameter(torch.Tensor(1, 1, embed_dim))\\n self.bias_v = Parameter(torch.Tensor(1, 1, embed_dim))\\n if self.shared_memory_attention:\\n self.bias_k_memory = Parameter(torch.Tensor(1, 1, embed_dim))\\n self.bias_v_memory = Parameter(torch.Tensor(1, 1, embed_dim))\\n else:\\n self.bias_k = self.bias_v = None\\n self.bias_k_memory = self.bias_v_memory = None\\n\\n self.add_zero_attn = add_zero_attn\\n\\n self.reset_parameters()\\n\\n self.onnx_trace = False\\n self.tpu = False\\n\\n # 这里表示，如果共享memory_attention的话\\n if self.shared_memory_attention:\\n print('MEM SLOTS:' + str(mem_slots))\\n print('Null attention:' + str(null_attention))\\n print('USING SHARED MEMORY ATTENTION +++++++++')\\n #self.num_heads = 1\\n self.regressive = regressive\\n if not regressive: \\n self.relational_memory = RelationalMemory(\\n mem_slots=mem_slots,\\n head_size=self.head_dim , #128\\n input_size=embed_dim,\\n output_size=embed_dim,\\n num_heads=self.num_heads, #1\\n num_blocks=1,\\n forget_bias=1,\\n input_bias=0,\\n gate_style=\\\"unit\\\",\\n attention_mlp_layers=1,\\n key_size=32,\\n return_all_outputs=False,\\n use_topk = self.use_topk,\\n topk = self.topk,\\n num_steps = num_steps, \\n null_attention = null_attention\\n )\\n else:\\n print('USING AUTO REGRESSIVE')\\n self.relational_memory = RelationalMemoryRegressive(\\n mem_slots=mem_slots,\\n head_size=self.head_dim ,\\n input_size=embed_dim,\\n output_size=embed_dim,\\n num_heads=self.num_heads,\\n num_blocks=1,\\n forget_bias=1,\\n input_bias=0,\\n gate_style=\\\"unit\\\",\\n attention_mlp_layers=4,\\n key_size=32,\\n return_all_outputs=False,\\n use_topk = self.use_topk,\\n topk = self.topk,\\n num_steps = num_steps,\\n null_attention = False\\n )\\n self.memory_size = 128 #self.head_dim * self.num_heads\\n '''\\n self.mem_att = MHAMemory(\\n n_head=4,\\n d_model_read=embed_dim,\\n d_model_write=self.memory_size,\\n d_model_out=embed_dim,\\n d_k=32,\\n d_v=32,\\n grad_sparse=False,\\n )\\n '''\\n self.memory = None # 因为要共享self.memory，所以这里是为了占个位置\\n\\n def prepare_for_onnx_export_(self):\\n self.onnx_trace = True\\n\\n def prepare_for_tpu_(self, **kwargs):\\n self.tpu = True\\n\\n def reset_parameters(self):\\n if self.qkv_same_dim:\\n # Empirically observed the convergence to be much better with\\n # the scaled initialization\\n nn.init.xavier_uniform_(self.k_proj.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.v_proj.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.q_proj.weight, gain=1 / math.sqrt(2))\\n if self.shared_memory_attention:\\n nn.init.xavier_uniform_(self.k_proj_memory.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.v_proj_memory.weight, gain=1 / math.sqrt(2))\\n nn.init.xavier_uniform_(self.q_proj_memory.weight, gain=1 / math.sqrt(2))\\n\\n else:\\n nn.init.xavier_uniform_(self.k_proj.weight)\\n nn.init.xavier_uniform_(self.v_proj.weight)\\n nn.init.xavier_uniform_(self.q_proj.weight)\\n\\n #if self.shared_memory_attention:\\n # nn.init.xavier_uniform_(self.k_proj_memory.weight)\\n # nn.init.xavier_uniform_(self.v_proj_memory.weight)\\n # nn.init.xavier_uniform_(self.q_proj_memory.weight)\\n\\n nn.init.xavier_uniform_(self.out_proj.weight)\\n #if self.shared_memory_attention:\\n # nn.init.xavier_uniform_(self.out_proj_memory.weight)\\n \\n if self.out_proj.bias is not None:\\n nn.init.constant_(self.out_proj.bias, 0.)\\n\\n #if self.shared_memory_attention and self.out_proj_memory.bias is not None:\\n # nn.init.constant_(self.out_proj.bias, 0.)\\n \\n if self.bias_k is not None:\\n nn.init.xavier_normal_(self.bias_k)\\n if self.bias_v is not None:\\n nn.init.xavier_normal_(self.bias_v)\\n\\n #if self.shared_memory_attention:\\n # if self.bias_k is not None:\\n # nn.init.xavier_normal_(self.bias_k_memory)\\n # if self.bias_v is not None:\\n # nn.init.xavier_normal_(self.bias_v_memory)\\n\\n\\n def forward(\\n self,\\n query,\\n key: Optional[Tensor],\\n value: Optional[Tensor],\\n key_padding_mask: Optional[Tensor] = None,\\n incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]] = None,\\n need_weights: bool = True,\\n static_kv: bool = False,\\n attn_mask: Optional[Tensor] = None,\\n before_softmax: bool = False,\\n need_head_weights: bool = False,\\n comp = None,\\n memory = None\\n ) -> Tuple[Tensor, Optional[Tensor]]:\\n \\\"\\\"\\\"Input shape: Time x Batch x Channel\\n\\n Args:\\n key_padding_mask (ByteTensor, optional): mask to exclude\\n keys that are pads, of shape `(batch, src_len)`, where\\n padding elements are indicated by 1s.\\n need_weights (bool, optional): return the attention weights,\\n averaged over heads (default: False).\\n attn_mask (ByteTensor, optional): typically used to\\n implement causal attention, where the mask prevents the\\n attention from looking forward in time (default: None).\\n before_softmax (bool, optional): return the raw attention\\n weights and values before the attention softmax.\\n need_head_weights (bool, optional): return the attention\\n weights for each head. Implies *need_weights*. Default:\\n return the average attention weights over all heads.\\n \\\"\\\"\\\"\\n if need_head_weights:\\n need_weights = True\\n\\n tgt_len, bsz, embed_dim = query.size()\\n assert embed_dim == self.embed_dim\\n assert list(query.size()) == [tgt_len, bsz, embed_dim]\\n\\n if (\\n not self.onnx_trace\\n and not self.tpu # don't use PyTorch version on TPUs\\n and incremental_state is None\\n and not static_kv\\n # A workaround for quantization to work. Otherwise JIT compilation\\n # treats bias in linear module as method.\\n and not torch.jit.is_scripting()\\n and False\\n ):\\n assert key is not None and value is not None\\n if self.shared_memory_attention:\\n memory,_ = F.multi_head_attention_forward(\\n memory,\\n key,\\n value,\\n self.embed_dim,\\n self.num_heads,\\n torch.empty([0]),\\n torch.cat((self.q_proj_memory.bias, self.k_proj.bias, self.v_proj.bias)),\\n self.bias_k,\\n self.bias_v,\\n self.add_zero_attn,\\n self.dropout_module.p,\\n self.out_proj_memory.weight,\\n self.out_proj_memory.bias,\\n self.training or self.dropout_module.apply_during_inference,\\n key_padding_mask,\\n need_weights,\\n attn_mask,\\n use_separate_proj_weight=True,\\n q_proj_weight=self.q_proj_memory.weight,\\n k_proj_weight=self.k_proj.weight,\\n v_proj_weight=self.v_proj.weight,\\n )\\n out,weights = F.multi_head_attention_forward(\\n query,\\n memory,\\n memory,\\n self.embed_dim,\\n self.num_heads,\\n torch.empty([0]),\\n torch.cat((self.q_proj.bias, self.k_proj_memory.bias, self.v_proj_memory.bias)),\\n self.bias_k_memory,\\n self.bias_v_memory,\\n self.add_zero_attn,\\n self.dropout_module.p,\\n self.out_proj.weight,\\n self.out_proj.bias,\\n self.training or self.dropout_module.apply_during_inference,\\n key_padding_mask,\\n need_weights,\\n attn_mask,\\n use_separate_proj_weight=True,\\n q_proj_weight=self.q_proj.weight,\\n k_proj_weight=self.k_proj_memory.weight,\\n v_proj_weight=self.v_proj_memory.weight,\\n )\\n else:\\n out, weights = F.multi_head_attention_forward(\\n query,\\n key,\\n value,\\n self.embed_dim,\\n self.num_heads,\\n torch.empty([0]),\\n torch.cat((self.q_proj.bias, self.k_proj.bias, self.v_proj.bias)),\\n self.bias_k,\\n self.bias_v,\\n self.add_zero_attn,\\n self.dropout_module.p,\\n self.out_proj.weight,\\n self.out_proj.bias,\\n self.training or self.dropout_module.apply_during_inference,\\n key_padding_mask,\\n need_weights,\\n attn_mask,\\n use_separate_proj_weight=True,\\n q_proj_weight=self.q_proj.weight,\\n k_proj_weight=self.k_proj.weight,\\n v_proj_weight=self.v_proj.weight,\\n\\n ) \\n\\n return out, memory, weights\\n\\n if incremental_state is not None:\\n saved_state = self._get_input_buffer(incremental_state)\\n if saved_state is not None and \\\"prev_key\\\" in saved_state:\\n # previous time steps are cached - no need to recompute\\n # key and value if they are static\\n if static_kv:\\n assert self.encoder_decoder_attention and not self.self_attention\\n key = value = None\\n else:\\n saved_state = None\\n\\n # 如果不共享memory attention\\n if not self.shared_memory_attention:\\n\\n t1 = time.time()\\n\\n if self.self_attention:\\n q = self.q_proj(query)\\n k = self.k_proj(query)\\n v = self.v_proj(query)\\n elif self.encoder_decoder_attention:\\n # encoder-decoder attention\\n q = self.q_proj(query)\\n if key is None:\\n assert value is None\\n k = v = None\\n else:\\n k = self.k_proj(key)\\n v = self.v_proj(key)\\n\\n else:\\n assert key is not None and value is not None\\n \\n q = self.q_proj(query)\\n k = self.k_proj(key)\\n v = self.v_proj(value)\\n\\n if comp is not None:\\n v = v * comp\\n #v_memory = v_memory * comp\\n q *= self.scaling\\n #q_memory *= self.scaling\\n\\n if self.bias_k is not None:\\n assert self.bias_v is not None\\n k = torch.cat([k, self.bias_k.repeat(1, bsz, 1)])\\n v = torch.cat([v, self.bias_v.repeat(1, bsz, 1)])\\n if attn_mask is not None:\\n attn_mask = torch.cat(\\n [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1\\n )\\n if key_padding_mask is not None:\\n key_padding_mask = torch.cat(\\n [\\n key_padding_mask,\\n key_padding_mask.new_zeros(key_padding_mask.size(0), 1),\\n ],\\n dim=1,\\n )\\n\\n q = (\\n q.contiguous()\\n .view(tgt_len, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n if k is not None:\\n k = (\\n k.contiguous()\\n .view(-1, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n if v is not None:\\n v = (\\n v.contiguous()\\n .view(-1, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n \\n if saved_state is not None:\\n # saved states are stored with shape (bsz, num_heads, seq_len, head_dim)\\n if \\\"prev_key\\\" in saved_state:\\n _prev_key = saved_state[\\\"prev_key\\\"]\\n assert _prev_key is not None\\n prev_key = _prev_key.view(bsz * self.num_heads, -1, self.head_dim)\\n if static_kv:\\n k = prev_key\\n else:\\n assert k is not None\\n k = torch.cat([prev_key, k], dim=1)\\n if \\\"prev_value\\\" in saved_state:\\n _prev_value = saved_state[\\\"prev_value\\\"]\\n assert _prev_value is not None\\n prev_value = _prev_value.view(bsz * self.num_heads, -1, self.head_dim)\\n if static_kv:\\n v = prev_value\\n else:\\n assert v is not None\\n v = torch.cat([prev_value, v], dim=1)\\n prev_key_padding_mask: Optional[Tensor] = None\\n if \\\"prev_key_padding_mask\\\" in saved_state:\\n prev_key_padding_mask = saved_state[\\\"prev_key_padding_mask\\\"]\\n assert k is not None and v is not None\\n key_padding_mask = MultiheadAttention._append_prev_key_padding_mask(\\n key_padding_mask=key_padding_mask,\\n prev_key_padding_mask=prev_key_padding_mask,\\n batch_size=bsz,\\n src_len=k.size(1),\\n static_kv=static_kv,\\n )\\n\\n saved_state[\\\"prev_key\\\"] = k.view(bsz, self.num_heads, -1, self.head_dim)\\n saved_state[\\\"prev_value\\\"] = v.view(bsz, self.num_heads, -1, self.head_dim)\\n saved_state[\\\"prev_key_padding_mask\\\"] = key_padding_mask\\n # In this branch incremental_state is never None\\n assert incremental_state is not None\\n incremental_state = self._set_input_buffer(incremental_state, saved_state)\\n assert k is not None\\n src_len = k.size(1)\\n\\n # This is part of a workaround to get around fork/join parallelism\\n # not supporting Optional types.\\n if key_padding_mask is not None and key_padding_mask.dim() == 0:\\n key_padding_mask = None\\n\\n if key_padding_mask is not None:\\n assert key_padding_mask.size(0) == bsz\\n assert key_padding_mask.size(1) == src_len\\n\\n if self.add_zero_attn:\\n assert v is not None\\n src_len += 1\\n k = torch.cat([k, k.new_zeros((k.size(0), 1) + k.size()[2:])], dim=1)\\n v = torch.cat([v, v.new_zeros((v.size(0), 1) + v.size()[2:])], dim=1)\\n if attn_mask is not None:\\n attn_mask = torch.cat(\\n [attn_mask, attn_mask.new_zeros(attn_mask.size(0), 1)], dim=1\\n )\\n if key_padding_mask is not None:\\n key_padding_mask = torch.cat(\\n [\\n key_padding_mask,\\n torch.zeros(key_padding_mask.size(0), 1).type_as(\\n key_padding_mask\\n ),\\n ],\\n dim=1,\\n )\\n\\n attn_weights = torch.bmm(q, k.transpose(1, 2))\\n attn_weights = MultiheadAttention.apply_sparse_mask(attn_weights, tgt_len, src_len, bsz)\\n\\n assert list(attn_weights.size()) == [bsz * self.num_heads, tgt_len, src_len]\\n\\n if attn_mask is not None:\\n attn_mask = attn_mask.unsqueeze(0)\\n if self.onnx_trace:\\n attn_mask = attn_mask.repeat(attn_weights.size(0), 1, 1)\\n attn_weights += attn_mask\\n\\n if key_padding_mask is not None:\\n # don't attend to padding symbols\\n attn_weights = attn_weights.view(bsz, self.num_heads, tgt_len, src_len)\\n if not self.tpu:\\n attn_weights = attn_weights.masked_fill(\\n key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),\\n float(\\\"-inf\\\")\\n )\\n else:\\n attn_weights = attn_weights.transpose(0, 2)\\n attn_weights = attn_weights.masked_fill(key_padding_mask, float('-inf'))\\n attn_weights = attn_weights.transpose(0, 2)\\n attn_weights = attn_weights.view(bsz * self.num_heads, tgt_len, src_len)\\n\\n if before_softmax:\\n return attn_weights, v\\n \\n # 是这个\\n attn_weights_float = utils.softmax(\\n attn_weights, dim=-1, onnx_trace=self.onnx_trace\\n )\\n attn_weights = attn_weights_float.type_as(attn_weights)\\n attn_probs = self.dropout_module(attn_weights)\\n\\n assert v is not None\\n if self.use_topk:\\n k = torch.topk(attn_probs, dim = 2, k = self.topk)\\n mask = torch.zeros(attn_probs.size()).to(attn_probs.device)\\n mask.scatter_(2, k.indices, 1)\\n attn_probs = attn_probs * mask\\n attn = torch.bmm(attn_probs, v)\\n assert list(attn.size()) == [bsz * self.num_heads, tgt_len, self.head_dim]\\n if self.onnx_trace and attn.size(1) == 1:\\n # when ONNX tracing a single decoder step (sequence length == 1)\\n # the transpose is a no-op copy before view, thus unnecessary\\n attn = attn.contiguous().view(tgt_len, bsz, embed_dim)\\n else:\\n attn = attn.transpose(0, 1).contiguous().view(tgt_len, bsz, embed_dim)\\n attn = self.out_proj(attn)\\n attn_weights: Optional[Tensor] = None\\n if need_weights:\\n attn_weights = attn_weights_float.view(\\n bsz, self.num_heads, tgt_len, src_len\\n ).transpose(1, 0)\\n if not need_head_weights:\\n # average attention weights over heads\\n attn_weights = attn_weights.mean(dim=0)\\n #print('time taken by default mha:' + str(time.time() - t1))\\n return attn, None, attn_weights\\n \\n else: # 共享注意力机制 memory\\n t1 = time.time()\\n\\n # 这个是共享memory的时候\\n if self.memory is None:\\n self.memory = self.relational_memory.initial_state(query.size(1), query.size(0)).to(query.device)\\n\\n self.memory = self.memory.to(query.device)\\n\\n #print(self.memory.size())\\n \\n \\n key = key.transpose(1, 0)\\n\\n #print(key.size())\\n #memory = self.memory[:key.size(0)]\\n #print(self.memory.size())\\n\\n t2 = time.time()\\n\\n #print(self.memory)\\n\\n # self.memory只是一个memory更新的方式，它并不是workspace吧！！！ lm-workspace这篇代码是不是搞错了\\n # 那这个 self.memory \\n # 这里是对memory进行更新\\n # 利用relational_memory 来对 workspace中的memory进行更新\\n _,_, self.memory, out_hx_mem_new = self.relational_memory(\\n inputs=key,\\n memory=self.memory#.cuda(),\\n )\\n #print('time taken by relational:' + str(time.time() - t2))\\n\\n\\n\\n #query = query.transpose(1, 0)\\n #if self.regressive:\\n # B, T, D = query.size()\\n # query = query.reshape(B * T, -1).unsqueeze(1)\\n #out_hx_mem_new, _, _ = self.mem_att(\\n # query,#.reshape((bsz, self.num_blocks_out, self.block_size_out)),\\n # self.memory,\\n # self.memory,\\n # )\\n\\n #z = torch.zeros(self.memory.size(0) - memory.size(0), memory.size(1), memory.size(2)).to(memory.device)\\n #memory = torch.cat((memory, z), dim = 0)\\n #self.memory = self.memory + memory\\n #print('time taken by shared mha:' + str(time.time() - t1))\\n #if self.regressive:\\n # out_hx_mem_new = out_hx_mem_new.squeeze(1)\\n # out_hx_mem_new = out_hx_mem_new.reshape(B, T, -1)\\n\\n # 这里的memory实际上没啥用处了，emmm 我觉得\\n return out_hx_mem_new.transpose(0, 1), memory, None\\n \\\"\\\"\\\"\\n\\n tgt_len = memory.size(0)\\n src_len = key.size(0)\\n q_memory = self.q_proj_memory(memory)\\n k = self.k_proj(key)\\n v = self.v_proj(value)\\n\\n q_memory = (\\n q_memory.contiguous()\\n .view(memory.size(0), bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n k = (\\n k.contiguous()\\n .view(-1, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n v = (\\n v.contiguous()\\n .view(-1, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n \\n\\n attn_weights_1 = torch.bmm(q_memory, k.transpose(1, 2))\\n\\n if key_padding_mask is not None:\\n # don't attend to padding symbols\\n attn_weights_1 = attn_weights_1.view(bsz, self.num_heads, tgt_len, src_len)\\n attn_weights_1 = attn_weights_1.masked_fill(\\n key_padding_mask.unsqueeze(1).unsqueeze(2).to(torch.bool),\\n float(\\\"-inf\\\")\\n )\\n\\n attn_weights_float_1 = utils.softmax(\\n attn_weights_1, dim=-1, onnx_trace=self.onnx_trace\\n )\\n attn_weights_1 = attn_weights_float_1.type_as(attn_weights_1)\\n attn_probs_1 = self.dropout_module(attn_weights_1)\\n\\n assert v is not None\\n memory = torch.bmm(attn_probs_1, v)\\n\\n memory = memory.permute(1, 0, 2)\\n memory = memory.reshape(memory.size(0), bsz, self.num_heads, -1)\\n memory = memory.reshape(memory.size(0), bsz, -1)\\n\\n\\n\\n q = self.q_proj(query)\\n \\n k_memory = self.k_proj_memory(memory)\\n v_memory = self.v_proj_memory(memory)\\n\\n q = (\\n q.contiguous()\\n .view(src_len, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n k_memory = (\\n k.contiguous()\\n .view(-1, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n v_memory = (\\n v.contiguous()\\n .view(-1, bsz * self.num_heads, self.head_dim)\\n .transpose(0, 1)\\n )\\n\\n attn_weights_2 = torch.bmm(q, k_memory.transpose(1, 2))\\n \\n attn_weights_float_2 = utils.softmax(\\n attn_weights_2, dim=-1, onnx_trace=self.onnx_trace\\n )\\n \\n attn_weights_2 = attn_weights_float_2.type_as(attn_weights_2)\\n attn_probs_2 = self.dropout_module(attn_weights_2)\\n\\n out = torch.bmm(attn_probs_2, v)\\n out = out.transpose(0, 1).contiguous().view(src_len, bsz, embed_dim)\\n return out, memory, None\\n \\\"\\\"\\\"\\n \\n # 共享参数的时候，或者是共享memory attn的时候，\\n def init_memory(self, bs, ts = None, device = None):\\n if not self.regressive:\\n self.memory = self.relational_memory.initial_state(bs).to(device)\\n else:\\n self.memory = self.relational_memory.initial_state(bs, ts).to(device)\\n\\n\\n @staticmethod\\n def _append_prev_key_padding_mask(\\n key_padding_mask: Optional[Tensor],\\n prev_key_padding_mask: Optional[Tensor],\\n batch_size: int,\\n src_len: int,\\n static_kv: bool,\\n ) -> Optional[Tensor]:\\n # saved key padding masks have shape (bsz, seq_len)\\n if prev_key_padding_mask is not None and static_kv:\\n new_key_padding_mask = prev_key_padding_mask\\n elif prev_key_padding_mask is not None and key_padding_mask is not None:\\n new_key_padding_mask = torch.cat(\\n [prev_key_padding_mask.float(), key_padding_mask.float()], dim=1\\n )\\n # During incremental decoding, as the padding token enters and\\n # leaves the frame, there will be a time when prev or current\\n # is None\\n elif prev_key_padding_mask is not None:\\n filler = torch.zeros(\\n (batch_size, src_len - prev_key_padding_mask.size(1)),\\n device=prev_key_padding_mask.device,\\n )\\n new_key_padding_mask = torch.cat(\\n [prev_key_padding_mask.float(), filler.float()], dim=1\\n )\\n elif key_padding_mask is not None:\\n filler = torch.zeros(\\n (batch_size, src_len - key_padding_mask.size(1)),\\n device=key_padding_mask.device,\\n )\\n new_key_padding_mask = torch.cat(\\n [filler.float(), key_padding_mask.float()], dim=1\\n )\\n else:\\n new_key_padding_mask = prev_key_padding_mask\\n return new_key_padding_mask\\n\\n @torch.jit.export\\n def reorder_incremental_state(\\n self, incremental_state: Dict[str, Dict[str, Optional[Tensor]]], new_order: Tensor\\n ):\\n \\\"\\\"\\\"Reorder buffered internal state (for incremental generation).\\\"\\\"\\\"\\n input_buffer = self._get_input_buffer(incremental_state)\\n if input_buffer is not None:\\n for k in input_buffer.keys():\\n input_buffer_k = input_buffer[k]\\n if input_buffer_k is not None:\\n if self.encoder_decoder_attention and input_buffer_k.size(0) == new_order.size(0):\\n break\\n input_buffer[k] = input_buffer_k.index_select(0, new_order)\\n incremental_state = self._set_input_buffer(incremental_state, input_buffer)\\n return incremental_state\\n\\n def _get_input_buffer(\\n self, incremental_state: Optional[Dict[str, Dict[str, Optional[Tensor]]]]\\n ) -> Dict[str, Optional[Tensor]]:\\n result = self.get_incremental_state(incremental_state, \\\"attn_state\\\")\\n if result is not None:\\n return result\\n else:\\n empty_result: Dict[str, Optional[Tensor]] = {}\\n return empty_result\\n\\n def _set_input_buffer(\\n self,\\n incremental_state: Dict[str, Dict[str, Optional[Tensor]]],\\n buffer: Dict[str, Optional[Tensor]],\\n ):\\n return self.set_incremental_state(incremental_state, \\\"attn_state\\\", buffer)\\n\\n def apply_sparse_mask(attn_weights, tgt_len: int, src_len: int, bsz: int):\\n return attn_weights\\n\\n def upgrade_state_dict_named(self, state_dict, name):\\n prefix = name + \\\".\\\" if name != \\\"\\\" else \\\"\\\"\\n items_to_add = {}\\n keys_to_remove = []\\n for k in state_dict.keys():\\n if k.endswith(prefix + \\\"in_proj_weight\\\"):\\n # in_proj_weight used to be q + k + v with same dimensions\\n dim = int(state_dict[k].shape[0] / 3)\\n items_to_add[prefix + \\\"q_proj.weight\\\"] = state_dict[k][:dim]\\n items_to_add[prefix + \\\"k_proj.weight\\\"] = state_dict[k][dim : 2 * dim]\\n items_to_add[prefix + \\\"v_proj.weight\\\"] = state_dict[k][2 * dim :]\\n\\n keys_to_remove.append(k)\\n\\n k_bias = prefix + \\\"in_proj_bias\\\"\\n if k_bias in state_dict.keys():\\n dim = int(state_dict[k].shape[0] / 3)\\n items_to_add[prefix + \\\"q_proj.bias\\\"] = state_dict[k_bias][:dim]\\n items_to_add[prefix + \\\"k_proj.bias\\\"] = state_dict[k_bias][\\n dim : 2 * dim\\n ]\\n items_to_add[prefix + \\\"v_proj.bias\\\"] = state_dict[k_bias][2 * dim :]\\n\\n keys_to_remove.append(prefix + \\\"in_proj_bias\\\")\\n\\n for k in keys_to_remove:\\n del state_dict[k]\\n\\n for key, value in items_to_add.items():\\n state_dict[key] = value\"\n },\n {\n \"identifier\": \"RelationalMemory\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/relational_memory.py\",\n \"snippet\": \"class RelationalMemory(nn.Module):\\n \\\"\\\"\\\"\\n Constructs a `RelationalMemory` object.\\n This class is same as the RMC from relational_rnn_models.py, but without language modeling-specific variables.\\n Args:\\n mem_slots: The total number of memory slots to use.\\n head_size: The size of an attention head.\\n input_size: The size of input per step. i.e. the dimension of each input vector\\n num_heads: The number of attention heads to use. Defaults to 1.\\n num_blocks: Number of times to compute attention per time step. Defaults\\n to 1.\\n forget_bias: Bias to use for the forget gate, assuming we are using\\n some form of gating. Defaults to 1.\\n input_bias: Bias to use for the input gate, assuming we are using\\n some form of gating. Defaults to 0.\\n gate_style: Whether to use per-element gating ('unit'),\\n per-memory slot gating ('memory'), or no gating at all (None).\\n Defaults to `unit`.\\n attention_mlp_layers: Number of layers to use in the post-attention\\n MLP. Defaults to 2.\\n key_size: Size of vector to use for key & query vectors in the attention\\n computation. Defaults to None, in which case we use `head_size`.\\n name: Name of the module.\\n\\n # NEW flag for this class\\n return_all_outputs: Whether the model returns outputs for each step (like seq2seq) or only the final output.\\n Raises:\\n ValueError: gate_style not one of [None, 'memory', 'unit'].\\n ValueError: num_blocks is < 1.\\n ValueError: attention_mlp_layers is < 1.\\n \\\"\\\"\\\"\\n\\n def __init__(self, mem_slots, head_size, input_size, output_size, num_heads=1, num_blocks=1, forget_bias=1., input_bias=0.,\\n gate_style='unit', attention_mlp_layers=2, key_size=None, return_all_outputs=False, use_topk = False, topk = 3, num_steps = 5,\\n null_attention = False):\\n super(RelationalMemory, self).__init__()\\n\\n ########## generic parameters for RMC ##########\\n self.mem_slots = mem_slots\\n self.head_size = head_size\\n self.num_heads = num_heads\\n self.mem_size = self.head_size * self.num_heads\\n self.use_topk = use_topk\\n self.topk = topk\\n self.attn_log = None\\n\\n # a new fixed params needed for pytorch port of RMC\\n # +1 is the concatenated input per time step : we do self-attention with the concatenated memory & input\\n # so if the mem_slots = 1, this value is 2\\n self.mem_slots_plus_input = self.mem_slots + 1\\n\\n if num_blocks < 1:\\n raise ValueError('num_blocks must be >=1. Got: {}.'.format(num_blocks))\\n self.num_blocks = num_blocks\\n\\n if gate_style not in ['unit', 'memory', None]:\\n raise ValueError(\\n 'gate_style must be one of [\\\\'unit\\\\', \\\\'memory\\\\', None]. got: '\\n '{}.'.format(gate_style))\\n self.gate_style = gate_style\\n\\n if attention_mlp_layers < 1:\\n raise ValueError('attention_mlp_layers must be >= 1. Got: {}.'.format(\\n attention_mlp_layers))\\n self.attention_mlp_layers = attention_mlp_layers\\n\\n self.key_size = key_size if key_size else self.head_size\\n\\n ########## parameters for multihead attention ##########\\n # value_size is same as head_size\\n self.value_size = self.head_size\\n # total size for query-key-value\\n self.qkv_size = 2 * self.key_size + self.value_size\\n self.total_qkv_size = self.qkv_size * self.num_heads # denoted as F\\n\\n self.query_proj = nn.Linear(self.mem_size, self.key_size * self.num_heads)\\n self.key_proj = nn.Linear(self.mem_size, self.key_size * self.num_heads)\\n self.value_proj = nn.Linear(self.mem_size, self.value_size * self.num_heads)\\n\\n\\n # each head has qkv_sized linear projector\\n # just using one big param is more efficient, rather than this line\\n # self.qkv_projector = [nn.Parameter(torch.randn((self.qkv_size, self.qkv_size))) for _ in range(self.num_heads)]\\n self.qkv_projector = nn.Linear(self.mem_size, self.total_qkv_size)\\n self.qkv_layernorm = nn.LayerNorm(self.total_qkv_size)\\n\\n # used for attend_over_memory function\\n self.attention_mlp = nn.ModuleList([nn.Linear(self.mem_size, self.mem_size)] * self.attention_mlp_layers)\\n self.attended_memory_layernorm = nn.LayerNorm( self.mem_size)\\n self.attended_memory_layernorm2 = nn.LayerNorm(self.mem_size)\\n\\n ########## parameters for initial embedded input projection ##########\\n self.input_size = input_size\\n self.input_projector = nn.Linear(self.input_size, self.mem_size)\\n\\n self.output_projector = nn.Linear(self.output_size, self.input_size)\\n\\n ########## parameters for gating ##########\\n self.num_gates = 2 * self.calculate_gate_size()\\n print('input projector:'+str(self.mem_size))\\n self.input_gate_projector = nn.Linear(self.mem_size * num_steps, self.num_gates)\\n self.memory_gate_projector = nn.Linear(self.mem_size, self.num_gates)\\n # trainable scalar gate bias tensors\\n self.forget_bias = nn.Parameter(torch.tensor(forget_bias, dtype=torch.float32))\\n self.input_bias = nn.Parameter(torch.tensor(input_bias, dtype=torch.float32))\\n\\n ########## number of outputs returned #####\\n self.return_all_outputs = return_all_outputs\\n\\n self.null_attention = null_attention\\n\\n self.competition_mlp = nn.Sequential(nn.Linear(self.mem_slots * self.mem_size + self.mem_size, 256),\\n nn.ReLU(),\\n nn.Linear(256, 256),\\n nn.ReLU(),\\n nn.Linear(256, 256),\\n nn.ReLU(),\\n nn.Linear(256, 2))\\n\\n def repackage_hidden(self, h):\\n \\\"\\\"\\\"Wraps hidden states in new Tensors, to detach them from their history.\\\"\\\"\\\"\\n # needed for truncated BPTT, called at every batch forward pass\\n if isinstance(h, torch.Tensor):\\n return h.detach()\\n else:\\n return tuple(self.repackage_hidden(v) for v in h)\\n\\n def initial_state(self, batch_size, trainable=False):\\n \\\"\\\"\\\"\\n Creates the initial memory.\\n We should ensure each row of the memory is initialized to be unique,\\n so initialize the matrix to be the identity. We then pad or truncate\\n as necessary so that init_state is of size\\n (batch_size, self.mem_slots, self.mem_size).\\n Args:\\n batch_size: The size of the batch.\\n trainable: Whether the initial state is trainable. This is always True.\\n Returns:\\n init_state: A truncated or padded matrix of size\\n (batch_size, self.mem_slots, self.mem_size).\\n \\\"\\\"\\\"\\n init_state = torch.stack([torch.eye(self.mem_slots) for _ in range(batch_size)])\\n\\n # pad the matrix with zeros\\n if self.mem_size > self.mem_slots:\\n difference = self.mem_size - self.mem_slots\\n pad = torch.zeros((batch_size, self.mem_slots, difference))\\n init_state = torch.cat([init_state, pad], -1)\\n\\n # truncation. take the first 'self.mem_size' components\\n elif self.mem_size < self.mem_slots:\\n init_state = init_state[:, :, :self.mem_size]\\n\\n return init_state\\n\\n def multihead_attention(self, input, memory):\\n \\\"\\\"\\\"\\n Perform multi-head attention from 'Attention is All You Need'.\\n Implementation of the attention mechanism from\\n https://arxiv.org/abs/1706.03762.\\n Args:\\n memory: Memory tensor to perform attention on.\\n Returns:\\n new_memory: New memory tensor.\\n \\\"\\\"\\\"\\n\\n q = self.query_proj(memory)\\n k = self.key_proj(input)\\n v = self.value_proj(input)\\n\\n q = q.reshape(q.size(0), q.size(1), self.num_heads, -1).permute(0, 2, 1, 3)\\n k = k.reshape(k.size(0), k.size(1), self.num_heads, -1).permute(0, 2, 1, 3)\\n v = v.reshape(v.size(0), v.size(1), self.num_heads, -1).permute(0, 2, 1, 3)\\n scores = torch.matmul(q, k.transpose(2, 3))\\n\\n scores = torch.softmax(scores, dim = -1)\\n self.attn_log = scores[0]\\n if not self.null_attention:\\n if self.use_topk:\\n topk = torch.topk(scores, dim = -1, k = self.topk)\\n mask = torch.zeros(scores.size()).to(scores.device)\\n mask.scatter_(3, topk.indices, 1)\\n scores = scores * mask\\n else:\\n memory_flat = memory.reshape(memory.size(0), -1).unsqueeze(1)\\n memory_flat = memory_flat.repeat(1, input.shape[1], 1)\\n\\n N = torch.cat((input, memory_flat), dim = 2)\\n N = self.competition_mlp(N)\\n\\n N = torch.nn.functional.gumbel_softmax(N, dim = 2, hard = True, tau = 0.5)\\n\\n N = N[:, :, 0]\\n\\n scores = scores * N.unsqueeze(1).unsqueeze(1)\\n\\n\\n output = torch.matmul(scores, v)\\n\\n \\\"\\\"\\\"#print(memory.size())\\n # First, a simple linear projection is used to construct queries\\n qkv = self.qkv_projector(memory)\\n # apply layernorm for every dim except the batch dim\\n qkv = self.qkv_layernorm(qkv)\\n\\n # mem_slots needs to be dynamically computed since mem_slots got concatenated with inputs\\n # example: self.mem_slots=10 and seq_length is 3, and then mem_slots is 10 + 1 = 11 for each 3 step forward pass\\n # this is the same as self.mem_slots_plus_input, but defined to keep the sonnet implementation code style\\n mem_slots = memory.shape[1] # denoted as N\\n\\n # split the qkv to multiple heads H\\n # [B, N, F] => [B, N, H, F/H]\\n qkv_reshape = qkv.view(qkv.shape[0], mem_slots, self.num_heads, self.qkv_size)\\n\\n # [B, N, H, F/H] => [B, H, N, F/H]\\n qkv_transpose = qkv_reshape.permute(0, 2, 1, 3)\\n\\n # [B, H, N, key_size], [B, H, N, key_size], [B, H, N, value_size]\\n q, k, v = torch.split(qkv_transpose, [self.key_size, self.key_size, self.value_size], -1)\\n\\n # scale q with d_k, the dimensionality of the key vectors\\n q *= (self.key_size ** -0.5)\\n\\n # make it [B, H, N, N]\\n dot_product = torch.matmul(q, k.permute(0, 1, 3, 2))\\n weights = F.softmax(dot_product, dim=-1)\\n\\n if self.use_topk:\\n topk = torch.topk(weights, dim = -1, k = self.topk)\\n mask = torch.zeros(weights.size()).to(weights.device)\\n mask.scatter_(3, topk.indices, 1)\\n weights = weights * mask\\n\\n # output is [B, H, N, V]\\n output = torch.matmul(weights, v)\\\"\\\"\\\"\\n\\n # [B, H, N, V] => [B, N, H, V] => [B, N, H*V]\\n output_transpose = output.permute(0, 2, 1, 3).contiguous()\\n new_memory = output_transpose.view((output_transpose.shape[0], output_transpose.shape[1], -1))\\n\\n return new_memory\\n\\n\\n @property\\n def state_size(self):\\n return [self.mem_slots, self.mem_size]\\n\\n @property\\n def output_size(self):\\n return self.mem_slots * self.mem_size\\n\\n def calculate_gate_size(self):\\n \\\"\\\"\\\"\\n Calculate the gate size from the gate_style.\\n Returns:\\n The per sample, per head parameter size of each gate.\\n \\\"\\\"\\\"\\n if self.gate_style == 'unit':\\n return self.mem_size\\n elif self.gate_style == 'memory':\\n return 1\\n else: # self.gate_style == None\\n return 0\\n\\n def print_log(self):\\n print(self.attn_log)\\n\\n def create_gates(self, inputs, memory):\\n \\\"\\\"\\\"\\n Create input and forget gates for this step using `inputs` and `memory`.\\n Args:\\n inputs: Tensor input.\\n memory: The current state of memory.\\n Returns:\\n input_gate: A LSTM-like insert gate.\\n forget_gate: A LSTM-like forget gate.\\n \\\"\\\"\\\"\\n # We'll create the input and forget gates at once. Hence, calculate double\\n # the gate size.\\n\\n # equation 8: since there is no output gate, h is just a tanh'ed m\\n memory = torch.tanh(memory)\\n\\n # TODO: check this input flattening is correct\\n # sonnet uses this, but i think it assumes time step of 1 for all cases\\n # if inputs is (B, T, features) where T > 1, this gets incorrect\\n # inputs = inputs.view(inputs.shape[0], -1)\\n\\n # fixed implementation\\n if len(inputs.shape) == 3:\\n #if inputs.shape[1] > 1:\\n # raise ValueError(\\n # \\\"input seq length is larger than 1. create_gate function is meant to be called for each step, with input seq length of 1\\\")\\n inputs = inputs.view(inputs.shape[0], -1)\\n # matmul for equation 4 and 5\\n # there is no output gate, so equation 6 is not implemented\\n gate_inputs = self.input_gate_projector(inputs)\\n gate_inputs = gate_inputs.unsqueeze(dim=1)\\n gate_memory = self.memory_gate_projector(memory)\\n else:\\n raise ValueError(\\\"input shape of create_gate function is 2, expects 3\\\")\\n\\n # this completes the equation 4 and 5\\n #print(gate_inputs.size())\\n #print(gate_memory.size())\\n gates = gate_memory + gate_inputs\\n gates = torch.split(gates, split_size_or_sections=int(gates.shape[2] / 2), dim=2)\\n input_gate, forget_gate = gates\\n assert input_gate.shape[2] == forget_gate.shape[2]\\n\\n # to be used for equation 7\\n input_gate = torch.sigmoid(input_gate + self.input_bias)\\n forget_gate = torch.sigmoid(forget_gate + self.forget_bias)\\n\\n return input_gate, forget_gate\\n\\n def attend_over_memory(self, inputs, memory):\\n \\\"\\\"\\\"\\n Perform multiheaded attention over `memory`.\\n Args:\\n memory: Current relational memory.\\n Returns:\\n The attended-over memory.\\n \\\"\\\"\\\"\\n for _ in range(self.num_blocks):\\n attended_memory = self.multihead_attention(inputs, memory)\\n\\n # Add a skip connection to the multiheaded attention's input.\\n memory = self.attended_memory_layernorm(memory + attended_memory)\\n\\n # add a skip connection to the attention_mlp's input.\\n attention_mlp = memory\\n for i, l in enumerate(self.attention_mlp):\\n attention_mlp = self.attention_mlp[i](attention_mlp)\\n attention_mlp = F.relu(attention_mlp)\\n memory = self.multihead_attention(memory, memory, use_topk_ = False, store_log = False)\\n memory = self.attended_memory_layernorm2(memory + attention_mlp)\\n\\n return memory\\n\\n def forward_step(self, inputs, memory, treat_input_as_matrix=False):\\n \\\"\\\"\\\"\\n Forward step of the relational memory core.\\n Args:\\n inputs: Tensor input.\\n memory: Memory output from the previous time step.\\n treat_input_as_matrix: Optional, whether to treat `input` as a sequence\\n of matrices. Default to False, in which case the input is flattened\\n into a vector.\\n Returns:\\n output: This time step's output.\\n next_memory: The next version of memory to use.\\n \\\"\\\"\\\"\\n\\n if treat_input_as_matrix:\\n # keep (Batch, Seq, ...) dim (0, 1), flatten starting from dim 2\\n inputs = inputs.view(inputs.shape[0], inputs.shape[1], -1)\\n # apply linear layer for dim 2\\n inputs_reshape = self.input_projector(inputs)\\n else:\\n # keep (Batch, ...) dim (0), flatten starting from dim 1\\n inputs = inputs.view(inputs.shape[0], -1)\\n # apply linear layer for dim 1\\n inputs = self.input_projector(inputs)\\n # unsqueeze the time step to dim 1\\n inputs_reshape = inputs.unsqueeze(dim=1)\\n\\n #memory_plus_input = torch.cat([memory, inputs_reshape], dim=1)\\n #print(memory_plus_input.size())\\n next_memory = self.attend_over_memory(inputs_reshape, memory)\\n\\n # cut out the concatenated input vectors from the original memory slots\\n #n = inputs_reshape.shape[1]\\n #next_memory = next_memory[:, :-n, :]\\n\\n if self.gate_style == 'unit' or self.gate_style == 'memory':\\n # these gates are sigmoid-applied ones for equation 7\\n input_gate, forget_gate = self.create_gates(inputs_reshape, memory)\\n # equation 7 calculation\\n next_memory = input_gate * torch.tanh(next_memory)\\n next_memory += forget_gate * memory\\n\\n\\n output = next_memory.view(next_memory.shape[0], -1)\\n return output, next_memory\\n\\n def forward(self, inputs, memory, parallel = True):\\n # Starting each batch, we detach the hidden state from how it was previously produced.\\n # If we didn't, the model would try backpropagating all the way to start of the dataset.\\n # memory = self.repackage_hidden(memory)\\n\\n # for loop implementation of (entire) recurrent forward pass of the model\\n # inputs is batch first [batch, seq], and output logit per step is [batch, vocab]\\n # so the concatenated logits are [seq * batch, vocab]\\n\\n # targets are flattened [seq, batch] => [seq * batch], so the dimension is correct\\n\\n logits = []\\n #print(inputs.size())\\n #print(memory.size())\\n #memory = self.repackage_hidden(memory)\\n # shape[1] is seq_lenth T\\n if not parallel:\\n for idx_step in range(inputs.shape[1]):\\n logit, memory = self.forward_step(inputs[:, idx_step], memory)\\n logits.append(logit)\\n logits = torch.cat(logits)\\n else:\\n logits, memory = self.forward_step(inputs, memory, treat_input_as_matrix = True)\\n \\n memory_out = self.output_projector(memory.view(memory.shape[0], -1))\\n\\n #print(inputs.size())\\n #print(memory_out.size())\\n #print('------')\\n if self.return_all_outputs:\\n return logits, memory_out , memory\\n else:\\n return logits, memory_out, memory\"\n },\n {\n \"identifier\": \"GroupLinearLayer\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/group_linear_layer.py\",\n \"snippet\": \"class GroupLinearLayer(nn.Module):\\n\\n def __init__(self, din, dout, num_blocks, bias=True, a = None):\\n super(GroupLinearLayer, self).__init__()\\n self.nb = num_blocks\\n self.dout = dout\\n\\n if a is None:\\n a = 1. / math.sqrt(dout * num_blocks)\\n\\n #gain = 1.0 / math.sqrt(2)\\n #a = gain * math.sqrt(6.0 / (din + dout))\\n\\n self.weight = nn.Parameter(torch.FloatTensor(num_blocks,din,dout).uniform_(-a,a))\\n\\n self.bias = bias\\n\\n if bias is True:\\n self.bias = nn.Parameter(torch.FloatTensor(num_blocks,dout).uniform_(-a,a))\\n #self.bias = nn.Parameter(torch.zeros(dout*num_blocks))\\n else:\\n self.bias = None\\n\\n def forward(self,x):\\n\\n\\t#input: ts x bs x blocks*nhid\\n\\t#ts*bs , blocks, nhid\\n\\t#blocks, ts*bs, nhid\\n ts,bs,m = x.shape\\t\\n\\n x = x.reshape((ts*bs, self.nb, m//self.nb))\\n x = x.permute(1,0,2)\\n x = torch.bmm(x,self.weight)\\n x = x.permute(1,0,2)\\n \\n if not self.bias is None:\\n x = x + self.bias\\n\\n x = x.reshape((ts, bs, self.dout*self.nb))\\n \\n #if not self.bias is None:\\n # x += self.bias\\n\\n return x\"\n },\n {\n \"identifier\": \"MemoryAttention\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/basic_mha.py\",\n \"snippet\": \"class MemoryAttention(nn.Module):\\n def __init__(self, n_blocks_query, n_blocks_val, dim_query, dim_val, n_heads=8):\\n super(MemoryAttention, self).__init__()\\n\\n self.n_heads = n_heads\\n self.n_blocks_val = n_blocks_val\\n self.dim_val = dim_val\\n self.block_dim_val = dim_val // self.n_blocks_val\\n\\n self.n_blocks_query = n_blocks_query\\n self.dim_query = dim_query\\n self.block_dim_query = dim_query // self.n_blocks_query\\n\\n self.head_dim = 64\\n self.scale = self.head_dim ** -0.5\\n\\n #self.n_blocks_val * self.block_dim_val\\n\\n self.query_net = GroupLinearLayer(self.block_dim_query, self.head_dim * self.n_heads, n_blocks_query)\\n self.key_net = GroupLinearLayer(self.block_dim_val, self.head_dim * self.n_heads, n_blocks_val)\\n self.value_net = GroupLinearLayer(self.block_dim_val, self.head_dim * self.n_heads, n_blocks_val)\\n self.final = GroupLinearLayer(self.head_dim * self.n_heads, self.block_dim_query, n_blocks_query)\\n\\n def forward(self, q, kv):\\n\\n #comes in as: bs, pos*emb.\\n #positions_attend x T*bs x emb\\n\\n\\n #q = q.permute(1,0,2)\\n #kv = kv.permute(1,0,2)\\n\\n #print('kv shape after permute', kv.shape)\\n\\n seq_len_q,bsz,_ = q.shape\\n seq_len_v,bsz,_ = kv.shape\\n\\n q = q.reshape((seq_len_q, bsz, self.n_blocks_query * self.block_dim_query))\\n\\n kv = kv.reshape((seq_len_v, bsz, self.n_blocks_val * self.block_dim_val))\\n\\n q = self.query_net(q).view(seq_len_q, bsz, self.n_blocks_query, self.n_heads, self.head_dim)\\n k = self.key_net(kv).view(seq_len_v, bsz, self.n_blocks_val, self.n_heads, self.head_dim)\\n v = self.value_net(kv).view(seq_len_v, bsz, self.n_blocks_val, self.n_heads, self.head_dim)\\n\\n q = q.transpose(2,3) * self.scale\\n k = k.transpose(2,3)\\n v = v.transpose(2,3)\\n score = torch.matmul(q, k.transpose(3,4))\\n #print('score shape', score.shape)\\n score = F.softmax(score, dim=-1)\\n out = torch.matmul(score, v).transpose(2,3)\\n #print('out shape', out.shape)\\n score = score.mean(dim=2)\\n\\n out = out.reshape(seq_len_q, bsz, self.n_blocks_query * self.head_dim * self.n_heads)\\n out = self.final(out)\\n out = out.view(seq_len_q, bsz, self.dim_query)\\n\\n\\n return out, score\"\n },\n {\n \"identifier\": \"quant_noise\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/quant_noise.py\",\n \"snippet\": \"def quant_noise(module, p, block_size):\\n \\\"\\\"\\\"\\n Wraps modules and applies quantization noise to the weights for\\n subsequent quantization with Iterative Product Quantization as\\n described in \\\"Training with Quantization Noise for Extreme Model Compression\\\"\\n\\n Args:\\n - module: nn.Module\\n - p: amount of Quantization Noise\\n - block_size: size of the blocks for subsequent quantization with iPQ\\n\\n Remarks:\\n - Module weights must have the right sizes wrt the block size\\n - Only Linear, Embedding and Conv2d modules are supported for the moment\\n - For more detail on how to quantize by blocks with convolutional weights,\\n see \\\"And the Bit Goes Down: Revisiting the Quantization of Neural Networks\\\"\\n - We implement the simplest form of noise here as stated in the paper\\n which consists in randomly dropping blocks\\n \\\"\\\"\\\"\\n\\n # if no quantization noise, don't register hook\\n if p <= 0:\\n return module\\n\\n # supported modules\\n assert isinstance(module, (nn.Linear, nn.Embedding, nn.Conv2d))\\n\\n # test whether module.weight has the right sizes wrt block_size\\n is_conv = module.weight.ndim == 4\\n\\n # 2D matrix\\n if not is_conv:\\n assert module.weight.size(1) % block_size == 0, \\\"Input features must be a multiple of block sizes\\\"\\n\\n # 4D matrix\\n else:\\n # 1x1 convolutions\\n if module.kernel_size == (1, 1):\\n assert module.in_channels % block_size == 0, \\\"Input channels must be a multiple of block sizes\\\"\\n # regular convolutions\\n else:\\n k = module.kernel_size[0] * module.kernel_size[1]\\n assert k % block_size == 0, \\\"Kernel size must be a multiple of block size\\\"\\n\\n def _forward_pre_hook(mod, input):\\n # no noise for evaluation\\n if mod.training:\\n if not is_conv:\\n # gather weight and sizes\\n weight = mod.weight\\n in_features = weight.size(1)\\n out_features = weight.size(0)\\n\\n # split weight matrix into blocks and randomly drop selected blocks\\n mask = torch.zeros(in_features // block_size * out_features, device=weight.device)\\n mask.bernoulli_(p)\\n mask = mask.repeat_interleave(block_size, -1).view(-1, in_features)\\n\\n else:\\n # gather weight and sizes\\n weight = mod.weight\\n in_channels = mod.in_channels\\n out_channels = mod.out_channels\\n\\n # split weight matrix into blocks and randomly drop selected blocks\\n if mod.kernel_size == (1, 1):\\n mask = torch.zeros(int(in_channels // block_size * out_channels), device=weight.device)\\n mask.bernoulli_(p)\\n mask = mask.repeat_interleave(block_size, -1).view(-1, in_channels)\\n else:\\n mask = torch.zeros(weight.size(0), weight.size(1), device=weight.device)\\n mask.bernoulli_(p)\\n mask = mask.unsqueeze(2).unsqueeze(3).repeat(1, 1, mod.kernel_size[0], mod.kernel_size[1])\\n\\n # scale weights and apply mask\\n mask = mask.to(torch.bool) # x.bool() is not currently supported in TorchScript\\n s = 1 / (1 - p)\\n mod.weight.data = s * weight.masked_fill(mask, 0)\\n\\n module.register_forward_pre_hook(_forward_pre_hook)\\n return module\"\n },\n {\n \"identifier\": \"FairseqDropout\",\n \"path\": \"multi_part_assembly/utils/wx_transformer_utilities/fairseq_dropout.py\",\n \"snippet\": \"class FairseqDropout(nn.Module):\\n\\n def __init__(self, p, module_name=None):\\n super().__init__()\\n self.p = p\\n self.module_name = module_name\\n self.apply_during_inference = False\\n\\n def forward(self, x, inplace: bool = False):\\n if self.training or self.apply_during_inference:\\n return F.dropout(x, p=self.p, training=True, inplace=inplace)\\n else:\\n return x\\n\\n def make_generation_fast_(\\n self,\\n name: str,\\n retain_dropout: bool = False,\\n retain_dropout_modules: Optional[List[str]] = None,\\n **kwargs\\n ):\\n if retain_dropout:\\n if retain_dropout_modules is not None and self.module_name is None:\\n logger.warning(\\n 'Cannot enable dropout during inference for module {} '\\n 'because module_name was not set'.format(name)\\n )\\n elif (\\n retain_dropout_modules is None # if None, apply to all modules\\n or self.module_name in retain_dropout_modules\\n ):\\n logger.info(\\n 'Enabling dropout during inference for module: {}'.format(name)\\n )\\n self.apply_during_inference = True\\n else:\\n logger.info('Disabling dropout for module: {}'.format(name))\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from typing import Dict, List, Optional\nfrom .layer_norm import LayerNorm\nfrom .multihead_attention import MultiheadAttention\nfrom .relational_memory import RelationalMemory\nfrom .group_linear_layer import GroupLinearLayer\nfrom .basic_mha import MemoryAttention\nfrom .quant_noise import quant_noise\nfrom .fairseq_dropout import FairseqDropout\nfrom torch import Tensor\nimport torch\nimport torch.nn as nn\nimport multi_part_assembly.utils.wx_transformer_utilities.fairseq_utils as utils \nimport random\nimport torch.nn.functional as F"},"token_num":{"kind":"number","value":15532,"string":"15,532"},"cropped_code":{"kind":"string","value":"\n# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\n\n\n#from fairseq.modules.shared_group_linear_layer import SharedGroupLinearLayer\n\n\n\n\n\n\nclass TransformerEncoderLayerVanilla(nn.Module):\n \"\"\"Encoder layer block.\n In the original paper each operation (multi-head attention or FFN) is\n postprocessed with: `dropout -> add residual -> layernorm`. In the\n tensor2tensor code they suggest that learning is more robust when\n preprocessing each layer with layernorm and postprocessing with:\n `dropout -> add residual`. We default to the approach in the paper, but the\n tensor2tensor approach can be enabled by setting\n *args.encoder_normalize_before* to ``True``.\n Args:\n args (argparse.Namespace): parsed command-line arguments\n \"\"\"\n\n def __init__(self, args, out_proj = None):\n super().__init__()\n self.embed_dim = args.encoder_embed_dim\n self.self_attn = self.build_self_attention(self.embed_dim, args)\n self.self_attn_layer_norm = LayerNorm(self.embed_dim, eps=1e-5) \n self.dropout = args.dropout\n self.activation_fn = utils.get_activation_fn( \n activation=getattr(args, \"activation_fn\", \"relu\")\n )\n self.activation_dropout = getattr(args, \"activation_dropout\", 0)\n if self.activation_dropout == 0:\n # for backwards compatibility with models that use args.relu_dropout\n self.activation_dropout = getattr(args, \"relu_dropout\", 0)\n self.normalize_before = args.encoder_normalize_before\n self.fc1 = self.build_fc1(self.embed_dim, args.encoder_ffn_embed_dim)\n self.fc2 = self.build_fc2(args.encoder_ffn_embed_dim, self.embed_dim)\n self.final_layer_norm = LayerNorm(self.embed_dim, eps=1e-5)\n\n if out_proj is not None:\n self.final_linear = nn.Linear(args.encoder_embed_dim, out_proj)\n else:\n self.final_linear = None\n\n def build_fc1(self, input_dim, output_dim):\n return nn.Linear(input_dim, output_dim)\n\n def build_fc2(self, input_dim, output_dim):\n return nn.Linear(input_dim, output_dim)\n\n def build_self_attention(self, embed_dim, args):\n"},"all_code":{"kind":"string","value":"\n# Copyright (c) Facebook, Inc. and its affiliates.\n#\n# This source code is licensed under the MIT license found in the\n# LICENSE file in the root directory of this source tree.\n\n\n\n#from fairseq.modules.shared_group_linear_layer import SharedGroupLinearLayer\n\n\n\n\n\n\nclass TransformerEncoderLayerVanilla(nn.Module):\n \"\"\"Encoder layer block.\n In the original paper each operation (multi-head attention or FFN) is\n postprocessed with: `dropout -> add residual -> layernorm`. In the\n tensor2tensor code they suggest that learning is more robust when\n preprocessing each layer with layernorm and postprocessing with:\n `dropout -> add residual`. We default to the approach in the paper, but the\n tensor2tensor approach can be enabled by setting\n *args.encoder_normalize_before* to ``True``.\n Args:\n args (argparse.Namespace): parsed command-line arguments\n \"\"\"\n\n def __init__(self, args, out_proj = None):\n super().__init__()\n self.embed_dim = args.encoder_embed_dim\n self.self_attn = self.build_self_attention(self.embed_dim, args)\n self.self_attn_layer_norm = LayerNorm(self.embed_dim, eps=1e-5) \n self.dropout = args.dropout\n self.activation_fn = utils.get_activation_fn( \n activation=getattr(args, \"activation_fn\", \"relu\")\n )\n self.activation_dropout = getattr(args, \"activation_dropout\", 0)\n if self.activation_dropout == 0:\n # for backwards compatibility with models that use args.relu_dropout\n self.activation_dropout = getattr(args, \"relu_dropout\", 0)\n self.normalize_before = args.encoder_normalize_before\n self.fc1 = self.build_fc1(self.embed_dim, args.encoder_ffn_embed_dim)\n self.fc2 = self.build_fc2(args.encoder_ffn_embed_dim, self.embed_dim)\n self.final_layer_norm = LayerNorm(self.embed_dim, eps=1e-5)\n\n if out_proj is not None:\n self.final_linear = nn.Linear(args.encoder_embed_dim, out_proj)\n else:\n self.final_linear = None\n\n def build_fc1(self, input_dim, output_dim):\n return nn.Linear(input_dim, output_dim)\n\n def build_fc2(self, input_dim, output_dim):\n return nn.Linear(input_dim, output_dim)\n\n def build_self_attention(self, embed_dim, args):"},"next_line":{"kind":"string","value":" return MultiheadAttention("},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-12-15 13:13:01+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5676,"cells":{"repo_name":{"kind":"string","value":"m-abr/FCPCodebase"},"file_path":{"kind":"string","value":"world/World.py"},"context":{"kind":"list like","value":[{"identifier":"Logger","path":"logs/Logger.py","snippet":"class Logger():\n _folder = None\n\n def __init__(self, is_enabled:bool, topic:str) -> None:\n self.no_of_entries = 0 \n self.enabled = is_enabled\n self.topic = topic\n\n def write(self, msg:str, timestamp:bool=True, step:int=None) -> None:\n '''\n Write `msg` to file named `self.topic`\n\n Parameters\n ----------\n msg : str\n message to be written\n step : int\n simulation step is written before the message to provide additional information\n default is `None` (nothing is written before the message)\n '''\n if not self.enabled: return\n\n # The log folder is only created if needed\n if Logger._folder is None: \n rnd = ''.join(random.choices(ascii_uppercase, k=6)) # Useful if multiple processes are running in parallel \n Logger._folder = \"./logs/\" + datetime.now().strftime(\"%Y-%m-%d_%H.%M.%S__\") + rnd + \"/\"\n print(\"\\nLogger Info: see\",Logger._folder)\n Path(Logger._folder).mkdir(parents=True, exist_ok=True)\n\n self.no_of_entries += 1\n\n with open(Logger._folder + self.topic + \".log\", 'a+') as f:\n prefix = \"\"\n write_step = step is not None\n if timestamp or write_step:\n prefix = \"{\"\n if timestamp: \n prefix += datetime.now().strftime(\"%a %H:%M:%S\")\n if write_step: prefix += \" \"\n if write_step:\n prefix += f'Step:{step}'\n prefix += \"} \"\n f.write(prefix + msg + \"\\n\")"},{"identifier":"Matrix_4x4","path":"math_ops/Matrix_4x4.py","snippet":"class Matrix_4x4():\n\n def __init__(self, matrix = None) -> None:\n '''\n Constructor examples:\n a = Matrix_4x4( ) # create identity matrix\n b = Matrix_4x4( [[1,1,1,1],[2,2,2,2],[3,3,3,3],[4,4,4,4]] ) # manually initialize matrix\n c = Matrix_4x4( [1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4] ) # manually initialize matrix\n d = Matrix_4x4( b ) # copy constructor\n '''\n if matrix is None:\n self.m = np.identity(4)\n elif type(matrix) == Matrix_4x4: \n self.m = np.copy(matrix.m)\n elif type(matrix) == Matrix_3x3: \n self.m = np.identity(4)\n self.m[0:3,0:3] = matrix.m\n else:\n self.m = np.asarray(matrix)\n self.m.shape = (4,4) #reshape if needed, throw error if impossible\n\n\n @classmethod\n def from_translation(cls, translation_vec):\n '''\n Create transformation matrix from translation_vec translation\n e.g. Matrix_4x4.from_translation((a,b,c))\n output: [[1,0,0,a],[0,1,0,b],[0,0,1,c],[0,0,0,1]]\n '''\n mat = np.identity(4)\n mat[0:3,3] = translation_vec\n return cls(mat)\n\n @classmethod\n def from_3x3_and_translation(cls, mat3x3:Matrix_3x3, translation_vec):\n '''\n Create transformation matrix from rotation matrix (3x3) and translation\n e.g. Matrix_4x4.from_3x3_and_translation(r,(a,b,c)) \n output: [[r00,r01,r02,a],[r10,r11,r12,b],[r20,r21,r22,c],[0,0,0,1]]\n '''\n mat = np.identity(4)\n mat[0:3,0:3] = mat3x3.m\n mat[0:3,3] = translation_vec\n return cls(mat)\n\n def translate(self, translation_vec, in_place=False):\n '''\n Translates the current transformation matrix\n\n Parameters\n ----------\n translation_vec : array_like, length 3\n translation vector\n in_place: bool, optional\n * True: the internal matrix is changed in-place\n * False: a new matrix is returned and the current one is not changed \n\n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n vec = np.array([*translation_vec,1])# conversion to 4D vector\n np.matmul(self.m, vec, out=vec) # compute only 4th column\n\n if in_place:\n self.m[:,3] = vec\n return self\n else:\n ret = Matrix_4x4(self.m)\n ret.m[:,3] = vec\n return ret\n\n\n def get_translation(self):\n ''' Get translation vector (x,y,z) '''\n return self.m[0:3,3] # return view\n\n def get_x(self):\n return self.m[0,3]\n\n def get_y(self):\n return self.m[1,3]\n\n def get_z(self):\n return self.m[2,3]\n\n def get_rotation_4x4(self):\n ''' Get Matrix_4x4 without translation ''' \n mat = Matrix_4x4(self)\n mat.m[0:3,3] = 0\n return mat\n\n def get_rotation(self):\n ''' Get rotation Matrix_3x3 '''\n return Matrix_3x3(self.m[0:3,0:3])\n\n def get_distance(self):\n ''' Get translation vector length '''\n return np.linalg.norm(self.m[0:3,3])\n\n def get_roll_deg(self):\n ''' Get angle around the x-axis in degrees, Rotation order: RotZ*RotY*RotX=Rot '''\n if self.m[2,1] == 0 and self.m[2,2] == 0: \n return 180\n return atan2(self.m[2,1], self.m[2,2]) * 180 / pi\n\n def get_pitch_deg(self):\n ''' Get angle around the y-axis in degrees, Rotation order: RotZ*RotY*RotX=Rot '''\n return atan2(-self.m[2,0], sqrt(self.m[2,1]*self.m[2,1] + self.m[2,2]*self.m[2,2])) * 180 / pi\n\n def get_yaw_deg(self):\n ''' Get angle around the z-axis in degrees, Rotation order: RotZ*RotY*RotX=Rot '''\n if self.m[1,0] == 0 and self.m[0,0] == 0: \n return atan2(self.m[0,1], self.m[1,1]) * 180 / pi\n return atan2(self.m[1,0], self.m[0,0]) * 180 / pi\n \n def get_inclination_deg(self):\n ''' Get inclination of z-axis in relation to reference z-axis '''\n return 90 - (asin(np.clip(self.m[2,2],-1,1)) * 180 / pi)\n\n def rotate_deg(self, rotation_vec, rotation_deg, in_place=False):\n '''\n Rotates the current transformation matrix\n\n Parameters\n ----------\n rotation_vec : array_like, length 3\n rotation vector\n rotation_rad : float\n rotation in degrees\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n return self.rotate_rad(rotation_vec, rotation_deg * (pi/180) , in_place)\n\n \n def rotate_rad(self, rotation_vec, rotation_rad, in_place=False):\n '''\n Rotates the current transformation matrix\n\n Parameters\n ----------\n rotation_vec : array_like, length 3\n rotation vector\n rotation_rad : float\n rotation in radians\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n\n if rotation_rad == 0: \n return self if in_place else Matrix_4x4(self)\n\n # shortcuts for rotation around 1 axis\n if rotation_vec[0]==0:\n if rotation_vec[1]==0:\n if rotation_vec[2]==1:\n return self.rotate_z_rad(rotation_rad, in_place)\n elif rotation_vec[2]==-1:\n return self.rotate_z_rad(-rotation_rad, in_place)\n elif rotation_vec[2]==0:\n if rotation_vec[1]==1:\n return self.rotate_y_rad(rotation_rad, in_place)\n elif rotation_vec[1]==-1:\n return self.rotate_y_rad(-rotation_rad, in_place)\n elif rotation_vec[1]==0 and rotation_vec[2]==0:\n if rotation_vec[0]==1:\n return self.rotate_x_rad(rotation_rad, in_place)\n elif rotation_vec[0]==-1:\n return self.rotate_x_rad(-rotation_rad, in_place)\n \n c = np.math.cos(rotation_rad)\n c1 = 1 - c\n s = np.math.sin(rotation_rad)\n x = rotation_vec[0]\n y = rotation_vec[1]\n z = rotation_vec[2]\n xxc1 = x * x * c1\n yyc1 = y * y * c1\n zzc1 = z * z * c1\n xyc1 = x * y * c1\n xzc1 = x * z * c1\n yzc1 = y * z * c1\n xs = x * s\n ys = y * s\n zs = z * s\n\n mat = np.array([\n [xxc1 + c, xyc1 - zs, xzc1 + ys, 0],\n [xyc1 + zs, yyc1 + c, yzc1 - xs, 0],\n [xzc1 - ys, yzc1 + xs, zzc1 + c, 0],\n [0, 0, 0, 1]])\n\n return self.multiply(mat, in_place)\n\n\n def rotate_x_rad(self, rotation_rad, in_place=False):\n '''\n Rotates the current transformation matrix around the x-axis\n\n Parameters\n ----------\n rotation_rad : float\n rotation in radians\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n if rotation_rad == 0: \n return self if in_place else Matrix_4x4(self)\n \n c = np.math.cos(rotation_rad)\n s = np.math.sin(rotation_rad)\n\n mat = np.array([\n [1, 0, 0, 0],\n [0, c,-s, 0],\n [0, s, c, 0],\n [0, 0, 0, 1]])\n\n return self.multiply(mat, in_place)\n\n def rotate_y_rad(self, rotation_rad, in_place=False):\n '''\n Rotates the current transformation matrix around the y-axis\n\n Parameters\n ----------\n rotation_rad : float\n rotation in radians\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n if rotation_rad == 0: \n return self if in_place else Matrix_4x4(self)\n \n c = np.math.cos(rotation_rad)\n s = np.math.sin(rotation_rad)\n\n mat = np.array([\n [ c, 0, s, 0],\n [ 0, 1, 0, 0],\n [-s, 0, c, 0],\n [ 0, 0, 0, 1]])\n\n return self.multiply(mat, in_place)\n\n def rotate_z_rad(self, rotation_rad, in_place=False):\n '''\n Rotates the current transformation matrix around the z-axis\n\n Parameters\n ----------\n rotation_rad : float\n rotation in radians\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n if rotation_rad == 0: \n return self if in_place else Matrix_4x4(self)\n \n c = np.math.cos(rotation_rad)\n s = np.math.sin(rotation_rad)\n\n mat = np.array([\n [ c,-s, 0, 0],\n [ s, c, 0, 0],\n [ 0, 0, 1, 0],\n [ 0, 0, 0, 1]])\n\n return self.multiply(mat, in_place)\n\n def rotate_x_deg(self, rotation_deg, in_place=False):\n '''\n Rotates the current transformation matrix around the x-axis\n\n Parameters\n ----------\n rotation_rad : float\n rotation in degrees\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n return self.rotate_x_rad(rotation_deg * (pi/180), in_place)\n\n def rotate_y_deg(self, rotation_deg, in_place=False):\n '''\n Rotates the current transformation matrix around the y-axis\n\n Parameters\n ----------\n rotation_rad : float\n rotation in degrees\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n return self.rotate_y_rad(rotation_deg * (pi/180), in_place)\n\n def rotate_z_deg(self, rotation_deg, in_place=False):\n '''\n Rotates the current transformation matrix around the z-axis\n\n Parameters\n ----------\n rotation_rad : float\n rotation in degrees\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n return self.rotate_z_rad(rotation_deg * (pi/180), in_place)\n\n def invert(self, in_place=False):\n '''\n Inverts the current transformation matrix\n\n Parameters\n ----------\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed \n \n Returns\n -------\n result : Matrix_4x4 \n self is returned if in_place is True\n '''\n\n if in_place:\n self.m = np.linalg.inv(self.m)\n return self\n else:\n return Matrix_4x4(np.linalg.inv(self.m))\n\n def multiply(self,mat, in_place=False):\n '''\n Multiplies the current transformation matrix by mat\n\n Parameters\n ----------\n mat : Matrix_4x4 or array_like\n multiplier matrix or 3D vector\n in_place: bool, optional\n * True: the internal matrix is changed in-place (default)\n * False: a new matrix is returned and the current one is not changed (if mat is a 4x4 matrix)\n \n Returns\n -------\n result : Matrix_4x4 | array_like\n Matrix_4x4 is returned if mat is a matrix (self is returned if in_place is True); \n a 3D vector is returned if mat is a vector\n '''\n if type(mat) == Matrix_4x4: \n mat = mat.m\n else:\n mat = np.asarray(mat) # conversion to array, if needed\n if mat.ndim == 1: # multiplication by 3D vector\n vec = np.append(mat,1) # conversion to 4D vector\n return np.matmul(self.m, vec)[0:3] # conversion to 3D vector\n\n if in_place:\n np.matmul(self.m, mat, self.m)\n return self\n else:\n return Matrix_4x4(np.matmul(self.m, mat))\n\n def __call__(self,mat, is_spherical=False):\n '''\n Multiplies the current transformation matrix by mat and returns a new matrix or vector\n\n Parameters\n ----------\n mat : Matrix_4x4 or array_like\n multiplier matrix or 3D vector\n is_spherical : bool\n only relevant if mat is a 3D vector, True if it uses spherical coordinates\n \n Returns\n -------\n result : Matrix_4x4 | array_like\n Matrix_4x4 is returned if mat is a matrix; \n a 3D vector is returned if mat is a vector\n '''\n\n if is_spherical and mat.ndim == 1: mat = M.deg_sph2cart(mat)\n return self.multiply(mat,False)"},{"identifier":"Draw","path":"world/commons/Draw.py","snippet":"class Draw():\n _socket = None\n\n def __init__(self, is_enabled:bool, unum:int, host:str, port:int) -> None:\n self.enabled = is_enabled \n self._is_team_right = None\n self._unum = unum \n self._prefix = f'?{unum}_'.encode() # temporary prefix that should never be used in normal circumstances\n \n #Create one socket for all instances\n if Draw._socket is None:\n Draw._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM )\n Draw._socket.connect((host, port))\n Draw.clear_all()\n\n\n def set_team_side(self, is_right):\n ''' Called by world parser to switch side '''\n '''\n Generate an appropriate player ID\n RoboViz has a bug/feature: we send \"swap buffers for player: 'l_1' and RoboViz\n will swap every buffer that contains 'l_1' in the name, including \n 'l_10' and 'l_11'. To avoid that, we swap the separator to 'l-10', 'l-11'\n '''\n self._is_team_right = is_right\n self._prefix = f\"{'r' if is_right else 'l'}{'_' if self._unum < 10 else '-'}{self._unum}_\".encode() #e.g. b'l_5', b'l-10'\n\n\n @staticmethod\n def _send(msg, id, flush):\n ''' Private method to send message if RoboViz is accessible '''\n try:\n if flush:\n Draw._socket.send(msg + id + b'\\x00\\x00\\x00' + id + b'\\x00')\n else:\n Draw._socket.send(msg + id + b'\\x00')\n except ConnectionRefusedError:\n pass\n\n \n def circle(self, pos2d, radius, thickness, color:bytes, id:str, flush=True):\n ''' \n Draw circle\n\n Examples\n ----------\n Circle in 2D (z=0): circle((-1,2), 3, 2, Draw.Color.red, \"my_circle\")\n '''\n if not self.enabled: return\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n assert not np.isnan(pos2d).any(), \"Argument 'pos2d' contains 'nan' values\"\n\n if self._is_team_right:\n pos2d = (-pos2d[0],-pos2d[1]) \n\n msg = b'\\x01\\x00' + (\n f'{f\"{pos2d[0] :.4f}\":.6s}'\n f'{f\"{pos2d[1] :.4f}\":.6s}'\n f'{f\"{radius :.4f}\":.6s}'\n f'{f\"{thickness :.4f}\":.6s}').encode() + color\n \n Draw._send(msg, self._prefix + id.encode(), flush)\n\n\n def line(self, p1, p2, thickness, color:bytes, id:str, flush=True):\n ''' \n Draw line\n\n Examples\n ----------\n Line in 3D: line((0,0,0), (0,0,2), 3, Draw.Color.red, \"my_line\") \n Line in 2D (z=0): line((0,0), (0,1), 3, Draw.Color.red, \"my_line\") \n '''\n if not self.enabled: return\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n assert not np.isnan(p1).any(), \"Argument 'p1' contains 'nan' values\"\n assert not np.isnan(p2).any(), \"Argument 'p2' contains 'nan' values\"\n\n z1 = p1[2] if len(p1)==3 else 0\n z2 = p2[2] if len(p2)==3 else 0\n\n if self._is_team_right: \n p1 = (-p1[0],-p1[1],p1[2]) if len(p1)==3 else (-p1[0],-p1[1])\n p2 = (-p2[0],-p2[1],p2[2]) if len(p2)==3 else (-p2[0],-p2[1])\n\n msg = b'\\x01\\x01' + (\n f'{f\"{p1[0] :.4f}\":.6s}'\n f'{f\"{p1[1] :.4f}\":.6s}'\n f'{f\"{z1 :.4f}\":.6s}'\n f'{f\"{p2[0] :.4f}\":.6s}'\n f'{f\"{p2[1] :.4f}\":.6s}'\n f'{f\"{z2 :.4f}\":.6s}'\n f'{f\"{thickness :.4f}\":.6s}').encode() + color\n\n Draw._send(msg, self._prefix + id.encode(), flush)\n \n\n def point(self, pos, size, color:bytes, id:str, flush=True):\n ''' \n Draw point\n\n Examples\n ----------\n Point in 3D: point((1,1,1), 3, Draw.Color.red, \"my_point\")\n Point in 2D (z=0): point((1,1), 3, Draw.Color.red, \"my_point\")\n '''\n if not self.enabled: return\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n assert not np.isnan(pos).any(), \"Argument 'pos' contains 'nan' values\"\n\n z = pos[2] if len(pos)==3 else 0\n\n if self._is_team_right: \n pos = (-pos[0],-pos[1],pos[2]) if len(pos)==3 else (-pos[0],-pos[1])\n\n msg = b'\\x01\\x02' + (\n f'{f\"{pos[0] :.4f}\":.6s}'\n f'{f\"{pos[1] :.4f}\":.6s}'\n f'{f\"{z :.4f}\":.6s}'\n f'{f\"{size :.4f}\":.6s}').encode() + color\n \n Draw._send(msg, self._prefix + id.encode(), flush)\n\n\n def sphere(self, pos, radius, color:bytes, id:str, flush=True):\n ''' \n Draw sphere\n\n Examples\n ----------\n Sphere in 3D: sphere((1,1,1), 3, Draw.Color.red, \"my_sphere\")\n Sphere in 2D (z=0): sphere((1,1), 3, Draw.Color.red, \"my_sphere\")\n '''\n if not self.enabled: return\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n assert not np.isnan(pos).any(), \"Argument 'pos' contains 'nan' values\"\n\n z = pos[2] if len(pos)==3 else 0\n\n if self._is_team_right: \n pos = (-pos[0],-pos[1],pos[2]) if len(pos)==3 else (-pos[0],-pos[1])\n\n msg = b'\\x01\\x03' + (\n f'{f\"{pos[0] :.4f}\":.6s}'\n f'{f\"{pos[1] :.4f}\":.6s}'\n f'{f\"{z :.4f}\":.6s}'\n f'{f\"{radius :.4f}\":.6s}').encode() + color\n \n Draw._send(msg, self._prefix + id.encode(), flush)\n\n\n def polygon(self, vertices, color:bytes, alpha:int, id:str, flush=True):\n ''' \n Draw polygon\n\n Examples\n ----------\n Polygon in 3D: polygon(((0,0,0),(1,0,0),(0,1,0)), Draw.Color.red, 255, \"my_polygon\")\n '''\n if not self.enabled: return\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n assert 0<=alpha<=255, \"The alpha channel (degree of opacity) must be in range [0,255]\"\n\n if self._is_team_right: \n vertices = [(-v[0],-v[1],v[2]) for v in vertices]\n\n msg = b'\\x01\\x04' + bytes([len(vertices)]) + color + alpha.to_bytes(1,'big')\n\n for v in vertices:\n msg += (\n f'{f\"{v[0] :.4f}\":.6s}'\n f'{f\"{v[1] :.4f}\":.6s}'\n f'{f\"{v[2] :.4f}\":.6s}').encode()\n \n Draw._send(msg, self._prefix + id.encode(), flush)\n\n\n def annotation(self, pos, text, color:bytes, id:str, flush=True):\n ''' \n Draw annotation\n\n Examples\n ----------\n Annotation in 3D: annotation((1,1,1), \"SOMEtext!\", Draw.Color.red, \"my_annotation\")\n Annotation in 2D (z=0): annotation((1,1), \"SOMEtext!\", Draw.Color.red, \"my_annotation\")\n '''\n if not self.enabled: return\n if type(text) != bytes: text = str(text).encode()\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n z = pos[2] if len(pos)==3 else 0\n\n if self._is_team_right: \n pos = (-pos[0],-pos[1],pos[2]) if len(pos)==3 else (-pos[0],-pos[1])\n\n msg = b'\\x02\\x00' + (\n f'{f\"{pos[0] :.4f}\":.6s}'\n f'{f\"{pos[1] :.4f}\":.6s}'\n f'{f\"{z :.4f}\":.6s}').encode() + color + text + b'\\x00'\n \n Draw._send(msg, self._prefix + id.encode(), flush)\n\n \n def arrow(self, p1, p2, arrowhead_size, thickness, color:bytes, id:str, flush=True):\n ''' \n Draw arrow\n\n Examples\n ----------\n Arrow in 3D: arrow((0,0,0), (0,0,2), 0.1, 3, Draw.Color.red, \"my_arrow\")\n Arrow in 2D (z=0): arrow((0,0), (0,1), 0.1, 3, Draw.Color.red, \"my_arrow\")\n '''\n if not self.enabled: return\n assert type(color)==bytes, \"The RGB color must be a bytes object, e.g. red: b'\\xFF\\x00\\x00'\"\n\n # No need to invert sides, the called shapes will handle that\n if len(p1)==2: p1 = M.to_3d(p1) \n else: p1 = np.asarray(p1)\n if len(p2)==2: p2 = M.to_3d(p2) \n else: p2 = np.asarray(p2)\n\n vec = p2-p1\n vec_size = np.linalg.norm(vec)\n if vec_size == 0: return #return without warning/error\n if arrowhead_size > vec_size: arrowhead_size = vec_size\n\n ground_proj_perpendicular = np.array([ vec[1], -vec[0], 0 ])\n\n if np.all(ground_proj_perpendicular == 0): #vertical arrow\n ground_proj_perpendicular = np.array([ arrowhead_size/2, 0, 0 ])\n else:\n ground_proj_perpendicular *= arrowhead_size/2 / np.linalg.norm(ground_proj_perpendicular)\n\n head_start = p2 - vec * (arrowhead_size/vec_size)\n head_pt1 = head_start + ground_proj_perpendicular\n head_pt2 = head_start - ground_proj_perpendicular\n\n self.line(p1,p2,thickness,color,id,False)\n self.line(p2,head_pt1,thickness,color,id,False)\n self.line(p2,head_pt2,thickness,color,id,flush)\n\n\n def flush(self, id):\n ''' Flush specific drawing by ID '''\n if not self.enabled: return\n\n Draw._send(b'\\x00\\x00', self._prefix + id.encode(), False)\n\n def clear(self, id):\n ''' Clear specific drawing by ID '''\n if not self.enabled: return\n\n Draw._send(b'\\x00\\x00', self._prefix + id.encode(), True) #swap buffer twice\n\n\n def clear_player(self):\n ''' Clear all drawings made by this player '''\n if not self.enabled: return\n\n Draw._send(b'\\x00\\x00', self._prefix, True) #swap buffer twice\n\n\n @staticmethod\n def clear_all():\n ''' Clear all drawings of all players '''\n if Draw._socket is not None:\n Draw._send(b'\\x00\\x00\\x00\\x00\\x00',b'',False) #swap buffer twice using no id\n\n\n class Color():\n '''\n Based on X11 colors\n The names are restructured to make better suggestions\n '''\n pink_violet = b'\\xC7\\x15\\x85'\n pink_hot = b'\\xFF\\x14\\x93'\n pink_violet_pale = b'\\xDB\\x70\\x93'\n pink = b'\\xFF\\x69\\xB4'\n pink_pale = b'\\xFF\\xB6\\xC1'\n \n red_dark = b'\\x8B\\x00\\x00'\n red = b'\\xFF\\x00\\x00'\n red_brick = b'\\xB2\\x22\\x22'\n red_crimson = b'\\xDC\\x14\\x3C'\n red_indian = b'\\xCD\\x5C\\x5C'\n red_salmon = b'\\xFA\\x80\\x72'\n\n orange_red = b'\\xFF\\x45\\x00'\n orange = b'\\xFF\\x8C\\x00'\n orange_ligth = b'\\xFF\\xA5\\x00'\n\n yellow_gold = b'\\xFF\\xD7\\x00'\n yellow = b'\\xFF\\xFF\\x00'\n yellow_light = b'\\xBD\\xB7\\x6B'\n\n brown_maroon =b'\\x80\\x00\\x00'\n brown_dark = b'\\x8B\\x45\\x13'\n brown = b'\\xA0\\x52\\x2D'\n brown_gold = b'\\xB8\\x86\\x0B'\n brown_light = b'\\xCD\\x85\\x3F'\n brown_pale = b'\\xDE\\xB8\\x87'\n\n green_dark = b'\\x00\\x64\\x00' \n green = b'\\x00\\x80\\x00' \n green_lime = b'\\x32\\xCD\\x32' \n green_light = b'\\x00\\xFF\\x00' \n green_lawn = b'\\x7C\\xFC\\x00' \n green_pale = b'\\x90\\xEE\\x90' \n\n cyan_dark = b'\\x00\\x80\\x80' \n cyan_medium = b'\\x00\\xCE\\xD1' \n cyan = b'\\x00\\xFF\\xFF' \n cyan_light = b'\\xAF\\xEE\\xEE'\n\n blue_dark = b'\\x00\\x00\\x8B' \n blue = b'\\x00\\x00\\xFF' \n blue_royal = b'\\x41\\x69\\xE1' \n blue_medium = b'\\x1E\\x90\\xFF' \n blue_light = b'\\x00\\xBF\\xFF'\n blue_pale = b'\\x87\\xCE\\xEB'\n\n purple_violet = b'\\x94\\x00\\xD3' \n purple_magenta = b'\\xFF\\x00\\xFF' \n purple_light = b'\\xBA\\x55\\xD3' \n purple_pale = b'\\xDD\\xA0\\xDD'\n\n white = b'\\xFF\\xFF\\xFF'\n gray_10 = b'\\xE6\\xE6\\xE6'\n gray_20 = b'\\xCC\\xCC\\xCC'\n gray_30 = b'\\xB2\\xB2\\xB2' \n gray_40 = b'\\x99\\x99\\x99'\n gray_50 = b'\\x80\\x80\\x80'\n gray_60 = b'\\x66\\x66\\x66'\n gray_70 = b'\\x4C\\x4C\\x4C'\n gray_80 = b'\\x33\\x33\\x33'\n gray_90 = b'\\x1A\\x1A\\x1A'\n black = b'\\x00\\x00\\x00' \n\n @staticmethod\n def get(r,g,b):\n ''' Get RGB color (0-255) '''\n return bytes([int(r),int(g),int(b)])"},{"identifier":"Other_Robot","path":"world/commons/Other_Robot.py","snippet":"class Other_Robot():\n def __init__(self, unum, is_teammate) -> None:\n self.unum = unum # convenient variable to indicate uniform number (same as other robot's index + 1)\n self.is_self = False # convenient flag to indicate if this robot is self\n self.is_teammate = is_teammate # convenient variable to indicate if this robot is from our team\n self.is_visible = False # True if this robot was seen in the last message from the server (it doesn't mean we know its absolute location)\n self.body_parts_cart_rel_pos = dict() # cartesian relative position of the robot's visible body parts\n self.body_parts_sph_rel_pos = dict() # spherical relative position of the robot's visible body parts\n self.vel_filter = 0.3 # EMA filter coefficient applied to self.state_filtered_velocity\n self.vel_decay = 0.95 # velocity decay at every vision cycle (neutralized if velocity is updated)\n\n\n # State variables: these are computed when this robot is visible and when the original robot is able to self-locate\n self.state_fallen = False # true if the robot is lying down (updated when head is visible)\n self.state_last_update = 0 # World.time_local_ms when the state was last updated\n self.state_horizontal_dist = 0 # horizontal head distance if head is visible, otherwise, average horizontal distance of visible body parts (the distance is updated by vision or radio when state_abs_pos gets a new value, but also when the other player is not visible, by assuming its last position)\n self.state_abs_pos = None # 3D head position if head is visible, otherwise, 2D average position of visible body parts, or, 2D radio head position\n self.state_orientation = 0 # orientation based on pair of lower arms or feet, or average of both (WARNING: may be older than state_last_update) \n self.state_ground_area = None # (pt_2d,radius) projection of player area on ground (circle), not precise if farther than 3m (for performance), useful for obstacle avoidance when it falls\n self.state_body_parts_abs_pos = dict() # 3D absolute position of each body part\n self.state_filtered_velocity = np.zeros(3) # 3D filtered velocity (m/s) (if the head is not visible, the 2D part is updated and v.z decays)"},{"identifier":"Robot","path":"world/Robot.py","snippet":"class Robot():\n STEPTIME = 0.02 # Fixed step time\n VISUALSTEP = 0.04 # Fixed visual step time\n SQ_STEPTIME = STEPTIME * STEPTIME\n GRAVITY = np.array([0,0,-9.81])\n IMU_DECAY = 0.996 #IMU's velocity decay\n \n #------------------ constants to force symmetry in joints/effectors\n\n MAP_PERCEPTOR_TO_INDEX = {\"hj1\":0, \"hj2\":1, \"llj1\":2, \"rlj1\":3,\n \"llj2\":4, \"rlj2\":5, \"llj3\":6, \"rlj3\":7,\n \"llj4\":8, \"rlj4\":9, \"llj5\":10,\"rlj5\":11,\n \"llj6\":12,\"rlj6\":13,\"laj1\":14,\"raj1\":15,\n \"laj2\":16,\"raj2\":17,\"laj3\":18,\"raj3\":19,\n \"laj4\":20,\"raj4\":21,\"llj7\":22,\"rlj7\":23 }\n\n # Fix symmetry issues 1a/4 (identification) \n FIX_PERCEPTOR_SET = {'rlj2','rlj6','raj2','laj3','laj4'}\n FIX_INDICES_LIST = [5,13,17,18,20]\n\n # Recommended height for unofficial beam (near ground)\n BEAM_HEIGHTS = [0.4, 0.43, 0.4, 0.46, 0.4]\n\n\n def __init__(self, unum:int, robot_type:int) -> None:\n robot_xml = \"nao\"+str(robot_type)+\".xml\" # Typical NAO file name\n self.type = robot_type\n self.beam_height = Robot.BEAM_HEIGHTS[robot_type]\n self.no_of_joints = 24 if robot_type == 4 else 22 \n\n #Fix symmetry issues 1b/4 (identification) \n self.FIX_EFFECTOR_MASK = np.ones(self.no_of_joints)\n self.FIX_EFFECTOR_MASK[Robot.FIX_INDICES_LIST] = -1\n\n self.body_parts = dict() # keys='body part names' (given by the robot's XML), values='Body_Part objects'\n self.unum = unum # Robot's uniform number\n self.gyro = np.zeros(3) # Angular velocity along the three axes of freedom of the robot's torso (deg/s)\n self.acc = np.zeros(3) # Proper acceleration along the three axes of freedom of the robot's torso (m/s2)\n self.frp = dict() # foot \"lf\"/\"rf\", toe \"lf1\"/\"rf1\" resistance perceptor (relative [p]oint of origin + [f]orce vector) e.g. {\"lf\":(px,py,pz,fx,fy,fz)}\n self.feet_toes_last_touch = {\"lf\":0,\"rf\":0,\"lf1\":0,\"rf1\":0} # foot \"lf\"/\"rf\", toe \"lf1\"/\"rf1\" World.time_local_ms when foot/toe last touched any surface\n self.feet_toes_are_touching = {\"lf\":False,\"rf\":False,\"lf1\":False,\"rf1\":False} # foot \"lf\"/\"rf\", toe \"lf1\"/\"rf1\" True if touching in last received server message\n self.fwd_kinematics_list = None # List of body parts, ordered according to dependencies\n self.rel_cart_CoM_position = np.zeros(3) # Center of Mass position, relative to head, in cartesian coordinates (m)\n\n # Joint variables are optimized for performance / array operations\n self.joints_position = np.zeros(self.no_of_joints) # Joints' angular position (deg)\n self.joints_speed = np.zeros(self.no_of_joints) # Joints' angular speed (rad/s)\n self.joints_target_speed = np.zeros(self.no_of_joints) # Joints' target speed (rad/s) (max: 6.1395 rad/s, see rcssserver3d/data/rsg/agent/nao/hingejoint.rsg)\n self.joints_target_last_speed = np.zeros(self.no_of_joints) # Joints' last target speed (rad/s) (max: 6.1395 rad/s, see rcssserver3d/data/rsg/agent/nao/hingejoint.rsg)\n self.joints_info = [None] * self.no_of_joints # Joints' constant information (see class Joint_Info)\n self.joints_transform = [Matrix_4x4() for _ in range(self.no_of_joints)] # Joints' transformation matrix\n\n # Localization variables relative to head\n self.loc_head_to_field_transform = Matrix_4x4() # Transformation matrix from head to field\n self.loc_field_to_head_transform = Matrix_4x4() # Transformation matrix from field to head\n self.loc_rotation_head_to_field = Matrix_3x3() # Rotation matrix from head to field\n self.loc_rotation_field_to_head = Matrix_3x3() # Rotation matrix from field to head\n self.loc_head_position = np.zeros(3) # Absolute head position (m)\n self.loc_head_position_history = deque(maxlen=40)# Absolute head position history (queue with up to 40 old positions at intervals of 0.04s, where index 0 is the previous position)\n self.loc_head_velocity = np.zeros(3) # Absolute head velocity (m/s) (Warning: possibly noisy)\n self.loc_head_orientation = 0 # Head orientation (deg)\n self.loc_is_up_to_date = False # False if this is not a visual step, or not enough elements are visible\n self.loc_last_update = 0 # World.time_local_ms when the localization was last updated\n self.loc_head_position_last_update = 0 # World.time_local_ms when loc_head_position was last updated by vision or radio\n self.radio_fallen_state = False # True if (radio says we fell) and (radio is significantly more recent than loc)\n self.radio_last_update = 0 # World.time_local_ms when radio_fallen_state was last updated (and possibly loc_head_position)\n\n # Localization variables relative to torso\n self.loc_torso_to_field_rotation = Matrix_3x3() # Rotation matrix from torso to field \n self.loc_torso_to_field_transform = Matrix_4x4() # Transformation matrix from torso to field\n self.loc_torso_roll = 0 # Torso roll (deg)\n self.loc_torso_pitch = 0 # Torso pitch (deg) \n self.loc_torso_orientation = 0 # Torso orientation (deg)\n self.loc_torso_inclination = 0 # Torso inclination (deg) (inclination of z-axis in relation to field z-axis)\n self.loc_torso_position = np.zeros(3) # Absolute torso position (m)\n self.loc_torso_velocity = np.zeros(3) # Absolute torso velocity (m/s)\n self.loc_torso_acceleration = np.zeros(3) # Absolute Coordinate acceleration (m/s2)\n\n # Other localization variables\n self.cheat_abs_pos = np.zeros(3) # Absolute head position provided by the server as cheat (m)\n self.cheat_ori = 0.0 # Absolute head orientation provided by the server as cheat (deg)\n self.loc_CoM_position = np.zeros(3) # Absolute CoM position (m)\n self.loc_CoM_velocity = np.zeros(3) # Absolute CoM velocity (m/s)\n\n # Localization special variables\n '''\n self.loc_head_z is often equivalent to self.loc_head_position[2], but sometimes it differs.\n There are situations in which the rotation and translation cannot be computed, \n but the z-coordinate can still be found through vision, in which case:\n self.loc_is_up_to_date is False\n self.loc_head_z_is_up_to_date is True\n It should be used in applications which rely on z as an independent coordinate, such\n as detecting if the robot has fallen, or as an observation for machine learning.\n It should NEVER be used for 3D transformations.\n '''\n self.loc_head_z = 0 # Absolute head position (z) - see above for explanation (m)\n self.loc_head_z_is_up_to_date = False # False if this is not a visual step, or not enough elements are visible\n self.loc_head_z_last_update = 0 # World.time_local_ms when loc_head_z was last computed\n self.loc_head_z_vel = 0 # Absolute head velocity (z) (m/s)\n\n # Localization + Gyroscope\n # These variables are reliable. The gyroscope is used to update the rotation when waiting for the next visual cycle\n self.imu_torso_roll = 0 # Torso roll (deg) (src: Localization + Gyro)\n self.imu_torso_pitch = 0 # Torso pitch (deg) (src: Localization + Gyro)\n self.imu_torso_orientation = 0 # Torso orientation (deg) (src: Localization + Gyro)\n self.imu_torso_inclination = 0 # Torso inclination (deg) (src: Localization + Gyro)\n self.imu_torso_to_field_rotation = Matrix_3x3() # Rotation matrix from torso to field (src: Localization + Gyro)\n self.imu_last_visual_update = 0 # World.time_local_ms when the IMU data was last updated with visual information \n\n # Localization + Gyroscope + Accelerometer\n # Warning: these variables are unreliable, since small errors in the Localization Orientation lead to \n # wrong acceleration -> wrong velocity -> wrong position\n self.imu_weak_torso_to_field_transform = Matrix_4x4() # Transformation matrix from torso to field (src: Localization + Gyro + Acc)\n self.imu_weak_head_to_field_transform = Matrix_4x4() # Transformation matrix from head to field (src: Localization + Gyro + Acc)\n self.imu_weak_field_to_head_transform = Matrix_4x4() # Transformation matrix from field to head (src: Localization + Gyro + Acc)\n self.imu_weak_torso_position = np.zeros(3) # Absolute torso position (m) (src: Localization + Gyro + Acc)\n self.imu_weak_torso_velocity = np.zeros(3) # Absolute torso velocity (m/s) (src: Localization + Gyro + Acc)\n self.imu_weak_torso_acceleration = np.zeros(3) # Absolute torso acceleration (m/s2) (src: Localization + Gyro + Acc)\n self.imu_weak_torso_next_position = np.zeros(3) # Absolute position in next step estimate (m) (src: Localization + Gyro + Acc)\n self.imu_weak_torso_next_velocity = np.zeros(3) # Absolute velocity in next step estimate (m/s) (src: Localization + Gyro + Acc)\n self.imu_weak_CoM_position = np.zeros(3) # Absolute CoM position (m) (src: Localization + Gyro + Acc)\n self.imu_weak_CoM_velocity = np.zeros(3) # Absolute CoM velocity (m/s) (src: Localization + Gyro + Acc)\n\n\n #Using explicit variables to enable IDE suggestions\n self.J_HEAD_YAW = 0\n self.J_HEAD_PITCH = 1\n self.J_LLEG_YAW_PITCH = 2\n self.J_RLEG_YAW_PITCH = 3\n self.J_LLEG_ROLL = 4\n self.J_RLEG_ROLL = 5\n self.J_LLEG_PITCH = 6\n self.J_RLEG_PITCH = 7\n self.J_LKNEE = 8\n self.J_RKNEE = 9\n self.J_LFOOT_PITCH = 10\n self.J_RFOOT_PITCH = 11\n self.J_LFOOT_ROLL = 12\n self.J_RFOOT_ROLL = 13\n self.J_LARM_PITCH = 14\n self.J_RARM_PITCH = 15\n self.J_LARM_ROLL = 16\n self.J_RARM_ROLL = 17\n self.J_LELBOW_YAW = 18\n self.J_RELBOW_YAW = 19\n self.J_LELBOW_ROLL = 20\n self.J_RELBOW_ROLL = 21\n self.J_LTOE_PITCH = 22\n self.J_RTOE_PITCH = 23\n\n\n #------------------ parse robot xml\n\n dir = M.get_active_directory(\"/world/commons/robots/\")\n robot_xml_root = xmlp.parse(dir + robot_xml).getroot()\n\n joint_no = 0\n for child in robot_xml_root:\n if child.tag == \"bodypart\":\n self.body_parts[child.attrib['name']] = Body_Part(child.attrib['mass'])\n elif child.tag == \"joint\":\n self.joints_info[joint_no] = Joint_Info(child)\n self.joints_position[joint_no] = 0.0\n ji = self.joints_info[joint_no]\n\n #save joint if body part is 1st anchor (to simplify model traversal in a single direction)\n self.body_parts[ji.anchor0_part].joints.append(Robot.MAP_PERCEPTOR_TO_INDEX[ji.perceptor]) \n\n joint_no += 1\n if joint_no == self.no_of_joints: break #ignore extra joints\n\n else:\n raise NotImplementedError\n\n assert joint_no == self.no_of_joints, \"The Robot XML and the robot type don't match!\"\n\n\n def get_head_abs_vel(self, history_steps:int):\n '''\n Get robot's head absolute velocity (m/s)\n\n Parameters\n ----------\n history_steps : int\n number of history steps to consider [1,40]\n\n Examples\n --------\n get_head_abs_vel(1) is equivalent to (current abs pos - last abs pos) / 0.04\n get_head_abs_vel(2) is equivalent to (current abs pos - abs pos 0.08s ago) / 0.08\n get_head_abs_vel(3) is equivalent to (current abs pos - abs pos 0.12s ago) / 0.12\n '''\n assert 1 <= history_steps <= 40, \"Argument 'history_steps' must be in range [1,40]\"\n\n if len(self.loc_head_position_history) == 0:\n return np.zeros(3)\n\n h_step = min(history_steps, len(self.loc_head_position_history))\n t = h_step * Robot.VISUALSTEP\n\n return (self.loc_head_position - self.loc_head_position_history[h_step-1]) / t\n \n\n def _initialize_kinematics(self):\n\n #starting with head\n parts={\"head\"}\n sequential_body_parts = [\"head\"]\n\n while len(parts) > 0:\n part = parts.pop()\n\n for j in self.body_parts[part].joints:\n\n p = self.joints_info[j].anchor1_part\n\n if len(self.body_parts[p].joints) > 0: #add body part if it is the 1st anchor of some joint\n parts.add(p)\n sequential_body_parts.append(p)\n\n self.fwd_kinematics_list = [(self.body_parts[part],j, self.body_parts[self.joints_info[j].anchor1_part] ) \n for part in sequential_body_parts for j in self.body_parts[part].joints]\n\n #Fix symmetry issues 4/4 (kinematics)\n for i in Robot.FIX_INDICES_LIST:\n self.joints_info[i].axes *= -1\n aux = self.joints_info[i].min\n self.joints_info[i].min = -self.joints_info[i].max\n self.joints_info[i].max = -aux\n\n\n def update_localization(self, localization_raw, time_local_ms): \n\n # parse raw data\n loc = localization_raw.astype(float) #32bits to 64bits for consistency\n self.loc_is_up_to_date = bool(loc[32])\n self.loc_head_z_is_up_to_date = bool(loc[34])\n\n if self.loc_head_z_is_up_to_date:\n time_diff = (time_local_ms - self.loc_head_z_last_update) / 1000 \n self.loc_head_z_vel = (loc[33] - self.loc_head_z) / time_diff\n self.loc_head_z = loc[33]\n self.loc_head_z_last_update = time_local_ms\n\n # Save last position to history at every vision cycle (even if not up to date) (update_localization is only called at vision cycles)\n self.loc_head_position_history.appendleft(np.copy(self.loc_head_position))\n\n if self.loc_is_up_to_date:\n time_diff = (time_local_ms - self.loc_last_update) / 1000\n self.loc_last_update = time_local_ms\n self.loc_head_to_field_transform.m[:] = loc[0:16].reshape((4,4))\n self.loc_field_to_head_transform.m[:] = loc[16:32].reshape((4,4))\n \n # extract data (related to the robot's head)\n self.loc_rotation_head_to_field = self.loc_head_to_field_transform.get_rotation()\n self.loc_rotation_field_to_head = self.loc_field_to_head_transform.get_rotation()\n p = self.loc_head_to_field_transform.get_translation()\n self.loc_head_velocity = (p - self.loc_head_position) / time_diff\n self.loc_head_position = p\n self.loc_head_position_last_update = time_local_ms\n self.loc_head_orientation = self.loc_head_to_field_transform.get_yaw_deg()\n self.radio_fallen_state = False\n\n # extract data (related to the center of mass)\n p = self.loc_head_to_field_transform(self.rel_cart_CoM_position)\n self.loc_CoM_velocity = (p - self.loc_CoM_position) / time_diff\n self.loc_CoM_position = p\n\n # extract data (related to the robot's torso)\n t = self.get_body_part_to_field_transform('torso')\n self.loc_torso_to_field_transform = t\n self.loc_torso_to_field_rotation = t.get_rotation()\n self.loc_torso_orientation = t.get_yaw_deg()\n self.loc_torso_pitch = t.get_pitch_deg()\n self.loc_torso_roll = t.get_roll_deg()\n self.loc_torso_inclination = t.get_inclination_deg()\n p = t.get_translation()\n self.loc_torso_velocity = (p - self.loc_torso_position) / time_diff\n self.loc_torso_position = p\n self.loc_torso_acceleration = self.loc_torso_to_field_rotation.multiply(self.acc) + Robot.GRAVITY\n\n\n def head_to_body_part_transform(self, body_part_name, coords, is_batch=False):\n '''\n If coord is a vector or list of vectors:\n Convert cartesian coordinates that are relative to head to coordinates that are relative to a body part \n\n If coord is a Matrix_4x4 or a list of Matrix_4x4:\n Convert pose that is relative to head to a pose that is relative to a body part \n \n Parameters\n ----------\n body_part_name : `str`\n name of body part (given by the robot's XML)\n coords : array_like\n One 3D position or list of 3D positions\n is_batch : `bool`\n Indicates if coords is a batch of 3D positions\n\n Returns\n -------\n coord : `list` or ndarray\n A numpy array is returned if is_batch is False, otherwise, a list of arrays is returned\n '''\n head_to_bp_transform : Matrix_4x4 = self.body_parts[body_part_name].transform.invert()\n \n if is_batch:\n return [head_to_bp_transform(c) for c in coords]\n else:\n return head_to_bp_transform(coords)\n\n\n\n def get_body_part_to_field_transform(self, body_part_name) -> Matrix_4x4:\n '''\n Computes the transformation matrix from body part to field, from which we can extract its absolute position and rotation.\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\n will not be synced with the localization data and strange results may occur.\n '''\n return self.loc_head_to_field_transform.multiply(self.body_parts[body_part_name].transform)\n\n def get_body_part_abs_position(self, body_part_name) -> np.ndarray:\n '''\n Computes the absolute position of a body part considering the localization data and forward kinematics.\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\n will not be synced with the localization data and strange results may occur.\n '''\n return self.get_body_part_to_field_transform(body_part_name).get_translation()\n\n def get_joint_to_field_transform(self, joint_index) -> Matrix_4x4:\n '''\n Computes the transformation matrix from joint to field, from which we can extract its absolute position and rotation.\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\n will not be synced with the localization data and strange results may occur.\n '''\n return self.loc_head_to_field_transform.multiply(self.joints_transform[joint_index])\n\n def get_joint_abs_position(self, joint_index) -> np.ndarray:\n '''\n Computes the absolute position of a joint considering the localization data and forward kinematics.\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\n will not be synced with the localization data and strange results may occur.\n '''\n return self.get_joint_to_field_transform(joint_index).get_translation()\n\n def update_pose(self):\n\n if self.fwd_kinematics_list is None:\n self._initialize_kinematics()\n\n for body_part, j, child_body_part in self.fwd_kinematics_list:\n ji = self.joints_info[j]\n self.joints_transform[j].m[:] = body_part.transform.m\n self.joints_transform[j].translate(ji.anchor0_axes, True)\n child_body_part.transform.m[:] = self.joints_transform[j].m\n child_body_part.transform.rotate_deg(ji.axes, self.joints_position[j], True)\n child_body_part.transform.translate(ji.anchor1_axes_neg, True)\n\n self.rel_cart_CoM_position = np.average([b.transform.get_translation() for b in self.body_parts.values()], 0,\n [b.mass for b in self.body_parts.values()])\n\n\n def update_imu(self, time_local_ms):\n\n # update IMU\n if self.loc_is_up_to_date:\n self.imu_torso_roll = self.loc_torso_roll\n self.imu_torso_pitch = self.loc_torso_pitch \n self.imu_torso_orientation = self.loc_torso_orientation\n self.imu_torso_inclination = self.loc_torso_inclination\n self.imu_torso_to_field_rotation.m[:] = self.loc_torso_to_field_rotation.m\n self.imu_weak_torso_to_field_transform.m[:] = self.loc_torso_to_field_transform.m\n self.imu_weak_head_to_field_transform.m[:] = self.loc_head_to_field_transform.m\n self.imu_weak_field_to_head_transform.m[:] = self.loc_field_to_head_transform.m\n self.imu_weak_torso_position[:] = self.loc_torso_position\n self.imu_weak_torso_velocity[:] = self.loc_torso_velocity\n self.imu_weak_torso_acceleration[:] = self.loc_torso_acceleration\n self.imu_weak_torso_next_position = self.loc_torso_position + self.loc_torso_velocity * Robot.STEPTIME + self.loc_torso_acceleration * (0.5 * Robot.SQ_STEPTIME)\n self.imu_weak_torso_next_velocity = self.loc_torso_velocity + self.loc_torso_acceleration * Robot.STEPTIME\n self.imu_weak_CoM_position[:] = self.loc_CoM_position\n self.imu_weak_CoM_velocity[:] = self.loc_CoM_velocity\n self.imu_last_visual_update = time_local_ms\n else:\n g = self.gyro / 50 # convert degrees per second to degrees per step\n\n self.imu_torso_to_field_rotation.multiply( Matrix_3x3.from_rotation_deg(g), in_place=True, reverse_order=True)\n\n self.imu_torso_orientation = self.imu_torso_to_field_rotation.get_yaw_deg()\n self.imu_torso_pitch = self.imu_torso_to_field_rotation.get_pitch_deg()\n self.imu_torso_roll = self.imu_torso_to_field_rotation.get_roll_deg()\n\n self.imu_torso_inclination = atan(sqrt(tan(self.imu_torso_roll/180*pi)**2+tan(self.imu_torso_pitch/180*pi)**2))*180/pi\n\n # Update position and velocity until 0.2 seconds has passed since last visual update\n if time_local_ms < self.imu_last_visual_update + 200:\n self.imu_weak_torso_position[:] = self.imu_weak_torso_next_position\n if self.imu_weak_torso_position[2] < 0: self.imu_weak_torso_position[2] = 0 # limit z coordinate to positive values\n self.imu_weak_torso_velocity[:] = self.imu_weak_torso_next_velocity * Robot.IMU_DECAY # stability tradeoff\n else:\n self.imu_weak_torso_velocity *= 0.97 # without visual updates for 0.2s, the position is locked, and the velocity decays to zero\n\n # convert proper acceleration to coordinate acceleration and fix rounding bias\n self.imu_weak_torso_acceleration = self.imu_torso_to_field_rotation.multiply(self.acc) + Robot.GRAVITY\n self.imu_weak_torso_to_field_transform = Matrix_4x4.from_3x3_and_translation(self.imu_torso_to_field_rotation,self.imu_weak_torso_position)\n self.imu_weak_head_to_field_transform = self.imu_weak_torso_to_field_transform.multiply(self.body_parts[\"torso\"].transform.invert())\n self.imu_weak_field_to_head_transform = self.imu_weak_head_to_field_transform.invert()\n p = self.imu_weak_head_to_field_transform(self.rel_cart_CoM_position)\n self.imu_weak_CoM_velocity = (p-self.imu_weak_CoM_position)/Robot.STEPTIME\n self.imu_weak_CoM_position = p\n\n # Next Position = x0 + v0*t + 0.5*a*t^2, Next velocity = v0 + a*t\n self.imu_weak_torso_next_position = self.imu_weak_torso_position + self.imu_weak_torso_velocity * Robot.STEPTIME + self.imu_weak_torso_acceleration * (0.5 * Robot.SQ_STEPTIME)\n self.imu_weak_torso_next_velocity = self.imu_weak_torso_velocity + self.imu_weak_torso_acceleration * Robot.STEPTIME\n\n\n\n def set_joints_target_position_direct(self,indices,values:np.ndarray,harmonize=True,max_speed=7.03,tolerance=0.012,limit_joints=True) -> int:\n '''\n Computes the speed of a list of joints, taking as argument the target position\n\n Parameters\n ----------\n indices : `int`/`list`/`slice`/numpy array\n joint indices\n values : numpy array \n target position for each listed joint index\n harmonize : `bool`\n if True, all joints reach target at same time\n max_speed : `float`\n max. speed for all joints in deg/step\n Most joints have a maximum speed of 351.77 deg/s according to rcssserver3d/data/rsg/agent/nao/hingejoint.rsg\n That translates as 7.0354 deg/step or 6.1395 rad/s\n tolerance : `float`\n angle error tolerance (in degrees) to return that target was reached (returns -1)\n limit_joints : `bool`\n limit values to the joints' range of motion\n\n Returns\n -------\n remaining_steps : `int`\n predicted number of remaining steps or -1 if target was already reached\n\n Examples\n -------\n (let p[tx] be the joint position at t=x)\n\n Example for return value: moving joint[0] from 0deg to 10deg\n pos[t0]: 0, speed[t0]: 7deg/step, ret=2 # target will predictedly be reached in 2 steps\n pos[t1]: 7, speed[t1]: 3deg/step, ret=1 # target will predictedly be reached in 1 step (send final action)\n pos[t2]: 10, speed[t2]: 0deg/step, ret=0 # target was predictedly already reached \n pos[t3]: 10, speed[t3]: 0deg/step, ret=-1 # (best case scenario) server reported with delay, that target was reached (see tolerance)\n pos[t?]: 10, speed[t?]: 0deg/step, ret=-1 # if there is friction, it may take some additional steps \n\n If everything worked as predicted we could stop calling this function when ret==1\n If we need precision, it is recommended to wait for ret==-1\n\n Example 1:\n set_joints_target_position_direct(range(2,4),np.array([10.0,5.0]),harmonize=True) \n Joint[2] p[t0]: 0 target pos: 10 -> p[t1]=5, p[t2]=10\n Joint[3] p[t0]: 0 target pos: 5 -> p[t1]=2.5, p[t2]=5\n\n Example 2:\n set_joints_target_position_direct([2,3],np.array([10.0,5.0]),harmonize=False) \n Joint[2] p[t0]: 0 target pos: 10 -> p[t1]=7, p[t2]=10\n Joint[3] p[t0]: 0 target pos: 5 -> p[t1]=5, p[t2]=5 \n '''\n\n assert type(values) == np.ndarray, \"'values' argument must be a numpy array\"\n np.nan_to_num(values, copy=False) # Replace NaN with zero and infinity with large finite numbers\n\n # limit range of joints\n if limit_joints: \n if type(indices) == list or type(indices) == np.ndarray:\n for i in range(len(indices)):\n values[i] = np.clip(values[i], self.joints_info[indices[i]].min, self.joints_info[indices[i]].max)\n elif type(indices) == slice:\n info = self.joints_info[indices]\n for i in range(len(info)):\n values[i] = np.clip(values[i], info[i].min, info[i].max)\n else: # int\n values[0] = np.clip(values[0], self.joints_info[indices].min, self.joints_info[indices].max)\n\n #predicted_diff: predicted difference between reported position and actual position\n\n predicted_diff = self.joints_target_last_speed[indices] * 1.1459156 #rad/s to deg/step\n predicted_diff = np.asarray(predicted_diff)\n np.clip(predicted_diff,-7.03,7.03,out=predicted_diff) #saturate predicted movement in-place\n\n #reported_dist: difference between reported position and target position\n\n reported_dist = values - self.joints_position[indices]\n if np.all((np.abs(reported_dist) < tolerance)) and np.all((np.abs(predicted_diff) < tolerance)):\n self.joints_target_speed[indices] = 0\n return -1\n \n deg_per_step = reported_dist - predicted_diff\n\n relative_max = np.max( np.abs(deg_per_step) ) / max_speed\n remaining_steps = np.ceil( relative_max )\n\n if remaining_steps == 0:\n self.joints_target_speed[indices] = 0\n return 0\n\n if harmonize: \n deg_per_step /= remaining_steps\n else:\n np.clip(deg_per_step,-max_speed,max_speed,out=deg_per_step) #limit maximum speed\n\n self.joints_target_speed[indices] = deg_per_step * 0.87266463 #convert to rad/s\n\n return remaining_steps\n\n\n\n def get_command(self) -> bytes:\n '''\n Builds commands string from self.joints_target_speed\n '''\n j_speed = self.joints_target_speed * self.FIX_EFFECTOR_MASK #Fix symmetry issues 3/4 (effectors)\n cmd = \"\".join(f\"({self.joints_info[i].effector} {j_speed[i]:.5f})\" for i in range(self.no_of_joints)).encode('utf-8')\n\n self.joints_target_last_speed = self.joints_target_speed #1. both point to the same array\n self.joints_target_speed = np.zeros_like(self.joints_target_speed) #2. create new array for joints_target_speed\n return cmd"}],"string":"[\n {\n \"identifier\": \"Logger\",\n \"path\": \"logs/Logger.py\",\n \"snippet\": \"class Logger():\\n _folder = None\\n\\n def __init__(self, is_enabled:bool, topic:str) -> None:\\n self.no_of_entries = 0 \\n self.enabled = is_enabled\\n self.topic = topic\\n\\n def write(self, msg:str, timestamp:bool=True, step:int=None) -> None:\\n '''\\n Write `msg` to file named `self.topic`\\n\\n Parameters\\n ----------\\n msg : str\\n message to be written\\n step : int\\n simulation step is written before the message to provide additional information\\n default is `None` (nothing is written before the message)\\n '''\\n if not self.enabled: return\\n\\n # The log folder is only created if needed\\n if Logger._folder is None: \\n rnd = ''.join(random.choices(ascii_uppercase, k=6)) # Useful if multiple processes are running in parallel \\n Logger._folder = \\\"./logs/\\\" + datetime.now().strftime(\\\"%Y-%m-%d_%H.%M.%S__\\\") + rnd + \\\"/\\\"\\n print(\\\"\\\\nLogger Info: see\\\",Logger._folder)\\n Path(Logger._folder).mkdir(parents=True, exist_ok=True)\\n\\n self.no_of_entries += 1\\n\\n with open(Logger._folder + self.topic + \\\".log\\\", 'a+') as f:\\n prefix = \\\"\\\"\\n write_step = step is not None\\n if timestamp or write_step:\\n prefix = \\\"{\\\"\\n if timestamp: \\n prefix += datetime.now().strftime(\\\"%a %H:%M:%S\\\")\\n if write_step: prefix += \\\" \\\"\\n if write_step:\\n prefix += f'Step:{step}'\\n prefix += \\\"} \\\"\\n f.write(prefix + msg + \\\"\\\\n\\\")\"\n },\n {\n \"identifier\": \"Matrix_4x4\",\n \"path\": \"math_ops/Matrix_4x4.py\",\n \"snippet\": \"class Matrix_4x4():\\n\\n def __init__(self, matrix = None) -> None:\\n '''\\n Constructor examples:\\n a = Matrix_4x4( ) # create identity matrix\\n b = Matrix_4x4( [[1,1,1,1],[2,2,2,2],[3,3,3,3],[4,4,4,4]] ) # manually initialize matrix\\n c = Matrix_4x4( [1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4] ) # manually initialize matrix\\n d = Matrix_4x4( b ) # copy constructor\\n '''\\n if matrix is None:\\n self.m = np.identity(4)\\n elif type(matrix) == Matrix_4x4: \\n self.m = np.copy(matrix.m)\\n elif type(matrix) == Matrix_3x3: \\n self.m = np.identity(4)\\n self.m[0:3,0:3] = matrix.m\\n else:\\n self.m = np.asarray(matrix)\\n self.m.shape = (4,4) #reshape if needed, throw error if impossible\\n\\n\\n @classmethod\\n def from_translation(cls, translation_vec):\\n '''\\n Create transformation matrix from translation_vec translation\\n e.g. Matrix_4x4.from_translation((a,b,c))\\n output: [[1,0,0,a],[0,1,0,b],[0,0,1,c],[0,0,0,1]]\\n '''\\n mat = np.identity(4)\\n mat[0:3,3] = translation_vec\\n return cls(mat)\\n\\n @classmethod\\n def from_3x3_and_translation(cls, mat3x3:Matrix_3x3, translation_vec):\\n '''\\n Create transformation matrix from rotation matrix (3x3) and translation\\n e.g. Matrix_4x4.from_3x3_and_translation(r,(a,b,c)) \\n output: [[r00,r01,r02,a],[r10,r11,r12,b],[r20,r21,r22,c],[0,0,0,1]]\\n '''\\n mat = np.identity(4)\\n mat[0:3,0:3] = mat3x3.m\\n mat[0:3,3] = translation_vec\\n return cls(mat)\\n\\n def translate(self, translation_vec, in_place=False):\\n '''\\n Translates the current transformation matrix\\n\\n Parameters\\n ----------\\n translation_vec : array_like, length 3\\n translation vector\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place\\n * False: a new matrix is returned and the current one is not changed \\n\\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n vec = np.array([*translation_vec,1])# conversion to 4D vector\\n np.matmul(self.m, vec, out=vec) # compute only 4th column\\n\\n if in_place:\\n self.m[:,3] = vec\\n return self\\n else:\\n ret = Matrix_4x4(self.m)\\n ret.m[:,3] = vec\\n return ret\\n\\n\\n def get_translation(self):\\n ''' Get translation vector (x,y,z) '''\\n return self.m[0:3,3] # return view\\n\\n def get_x(self):\\n return self.m[0,3]\\n\\n def get_y(self):\\n return self.m[1,3]\\n\\n def get_z(self):\\n return self.m[2,3]\\n\\n def get_rotation_4x4(self):\\n ''' Get Matrix_4x4 without translation ''' \\n mat = Matrix_4x4(self)\\n mat.m[0:3,3] = 0\\n return mat\\n\\n def get_rotation(self):\\n ''' Get rotation Matrix_3x3 '''\\n return Matrix_3x3(self.m[0:3,0:3])\\n\\n def get_distance(self):\\n ''' Get translation vector length '''\\n return np.linalg.norm(self.m[0:3,3])\\n\\n def get_roll_deg(self):\\n ''' Get angle around the x-axis in degrees, Rotation order: RotZ*RotY*RotX=Rot '''\\n if self.m[2,1] == 0 and self.m[2,2] == 0: \\n return 180\\n return atan2(self.m[2,1], self.m[2,2]) * 180 / pi\\n\\n def get_pitch_deg(self):\\n ''' Get angle around the y-axis in degrees, Rotation order: RotZ*RotY*RotX=Rot '''\\n return atan2(-self.m[2,0], sqrt(self.m[2,1]*self.m[2,1] + self.m[2,2]*self.m[2,2])) * 180 / pi\\n\\n def get_yaw_deg(self):\\n ''' Get angle around the z-axis in degrees, Rotation order: RotZ*RotY*RotX=Rot '''\\n if self.m[1,0] == 0 and self.m[0,0] == 0: \\n return atan2(self.m[0,1], self.m[1,1]) * 180 / pi\\n return atan2(self.m[1,0], self.m[0,0]) * 180 / pi\\n \\n def get_inclination_deg(self):\\n ''' Get inclination of z-axis in relation to reference z-axis '''\\n return 90 - (asin(np.clip(self.m[2,2],-1,1)) * 180 / pi)\\n\\n def rotate_deg(self, rotation_vec, rotation_deg, in_place=False):\\n '''\\n Rotates the current transformation matrix\\n\\n Parameters\\n ----------\\n rotation_vec : array_like, length 3\\n rotation vector\\n rotation_rad : float\\n rotation in degrees\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n return self.rotate_rad(rotation_vec, rotation_deg * (pi/180) , in_place)\\n\\n \\n def rotate_rad(self, rotation_vec, rotation_rad, in_place=False):\\n '''\\n Rotates the current transformation matrix\\n\\n Parameters\\n ----------\\n rotation_vec : array_like, length 3\\n rotation vector\\n rotation_rad : float\\n rotation in radians\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n\\n if rotation_rad == 0: \\n return self if in_place else Matrix_4x4(self)\\n\\n # shortcuts for rotation around 1 axis\\n if rotation_vec[0]==0:\\n if rotation_vec[1]==0:\\n if rotation_vec[2]==1:\\n return self.rotate_z_rad(rotation_rad, in_place)\\n elif rotation_vec[2]==-1:\\n return self.rotate_z_rad(-rotation_rad, in_place)\\n elif rotation_vec[2]==0:\\n if rotation_vec[1]==1:\\n return self.rotate_y_rad(rotation_rad, in_place)\\n elif rotation_vec[1]==-1:\\n return self.rotate_y_rad(-rotation_rad, in_place)\\n elif rotation_vec[1]==0 and rotation_vec[2]==0:\\n if rotation_vec[0]==1:\\n return self.rotate_x_rad(rotation_rad, in_place)\\n elif rotation_vec[0]==-1:\\n return self.rotate_x_rad(-rotation_rad, in_place)\\n \\n c = np.math.cos(rotation_rad)\\n c1 = 1 - c\\n s = np.math.sin(rotation_rad)\\n x = rotation_vec[0]\\n y = rotation_vec[1]\\n z = rotation_vec[2]\\n xxc1 = x * x * c1\\n yyc1 = y * y * c1\\n zzc1 = z * z * c1\\n xyc1 = x * y * c1\\n xzc1 = x * z * c1\\n yzc1 = y * z * c1\\n xs = x * s\\n ys = y * s\\n zs = z * s\\n\\n mat = np.array([\\n [xxc1 + c, xyc1 - zs, xzc1 + ys, 0],\\n [xyc1 + zs, yyc1 + c, yzc1 - xs, 0],\\n [xzc1 - ys, yzc1 + xs, zzc1 + c, 0],\\n [0, 0, 0, 1]])\\n\\n return self.multiply(mat, in_place)\\n\\n\\n def rotate_x_rad(self, rotation_rad, in_place=False):\\n '''\\n Rotates the current transformation matrix around the x-axis\\n\\n Parameters\\n ----------\\n rotation_rad : float\\n rotation in radians\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n if rotation_rad == 0: \\n return self if in_place else Matrix_4x4(self)\\n \\n c = np.math.cos(rotation_rad)\\n s = np.math.sin(rotation_rad)\\n\\n mat = np.array([\\n [1, 0, 0, 0],\\n [0, c,-s, 0],\\n [0, s, c, 0],\\n [0, 0, 0, 1]])\\n\\n return self.multiply(mat, in_place)\\n\\n def rotate_y_rad(self, rotation_rad, in_place=False):\\n '''\\n Rotates the current transformation matrix around the y-axis\\n\\n Parameters\\n ----------\\n rotation_rad : float\\n rotation in radians\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n if rotation_rad == 0: \\n return self if in_place else Matrix_4x4(self)\\n \\n c = np.math.cos(rotation_rad)\\n s = np.math.sin(rotation_rad)\\n\\n mat = np.array([\\n [ c, 0, s, 0],\\n [ 0, 1, 0, 0],\\n [-s, 0, c, 0],\\n [ 0, 0, 0, 1]])\\n\\n return self.multiply(mat, in_place)\\n\\n def rotate_z_rad(self, rotation_rad, in_place=False):\\n '''\\n Rotates the current transformation matrix around the z-axis\\n\\n Parameters\\n ----------\\n rotation_rad : float\\n rotation in radians\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n if rotation_rad == 0: \\n return self if in_place else Matrix_4x4(self)\\n \\n c = np.math.cos(rotation_rad)\\n s = np.math.sin(rotation_rad)\\n\\n mat = np.array([\\n [ c,-s, 0, 0],\\n [ s, c, 0, 0],\\n [ 0, 0, 1, 0],\\n [ 0, 0, 0, 1]])\\n\\n return self.multiply(mat, in_place)\\n\\n def rotate_x_deg(self, rotation_deg, in_place=False):\\n '''\\n Rotates the current transformation matrix around the x-axis\\n\\n Parameters\\n ----------\\n rotation_rad : float\\n rotation in degrees\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n return self.rotate_x_rad(rotation_deg * (pi/180), in_place)\\n\\n def rotate_y_deg(self, rotation_deg, in_place=False):\\n '''\\n Rotates the current transformation matrix around the y-axis\\n\\n Parameters\\n ----------\\n rotation_rad : float\\n rotation in degrees\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n return self.rotate_y_rad(rotation_deg * (pi/180), in_place)\\n\\n def rotate_z_deg(self, rotation_deg, in_place=False):\\n '''\\n Rotates the current transformation matrix around the z-axis\\n\\n Parameters\\n ----------\\n rotation_rad : float\\n rotation in degrees\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n return self.rotate_z_rad(rotation_deg * (pi/180), in_place)\\n\\n def invert(self, in_place=False):\\n '''\\n Inverts the current transformation matrix\\n\\n Parameters\\n ----------\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed \\n \\n Returns\\n -------\\n result : Matrix_4x4 \\n self is returned if in_place is True\\n '''\\n\\n if in_place:\\n self.m = np.linalg.inv(self.m)\\n return self\\n else:\\n return Matrix_4x4(np.linalg.inv(self.m))\\n\\n def multiply(self,mat, in_place=False):\\n '''\\n Multiplies the current transformation matrix by mat\\n\\n Parameters\\n ----------\\n mat : Matrix_4x4 or array_like\\n multiplier matrix or 3D vector\\n in_place: bool, optional\\n * True: the internal matrix is changed in-place (default)\\n * False: a new matrix is returned and the current one is not changed (if mat is a 4x4 matrix)\\n \\n Returns\\n -------\\n result : Matrix_4x4 | array_like\\n Matrix_4x4 is returned if mat is a matrix (self is returned if in_place is True); \\n a 3D vector is returned if mat is a vector\\n '''\\n if type(mat) == Matrix_4x4: \\n mat = mat.m\\n else:\\n mat = np.asarray(mat) # conversion to array, if needed\\n if mat.ndim == 1: # multiplication by 3D vector\\n vec = np.append(mat,1) # conversion to 4D vector\\n return np.matmul(self.m, vec)[0:3] # conversion to 3D vector\\n\\n if in_place:\\n np.matmul(self.m, mat, self.m)\\n return self\\n else:\\n return Matrix_4x4(np.matmul(self.m, mat))\\n\\n def __call__(self,mat, is_spherical=False):\\n '''\\n Multiplies the current transformation matrix by mat and returns a new matrix or vector\\n\\n Parameters\\n ----------\\n mat : Matrix_4x4 or array_like\\n multiplier matrix or 3D vector\\n is_spherical : bool\\n only relevant if mat is a 3D vector, True if it uses spherical coordinates\\n \\n Returns\\n -------\\n result : Matrix_4x4 | array_like\\n Matrix_4x4 is returned if mat is a matrix; \\n a 3D vector is returned if mat is a vector\\n '''\\n\\n if is_spherical and mat.ndim == 1: mat = M.deg_sph2cart(mat)\\n return self.multiply(mat,False)\"\n },\n {\n \"identifier\": \"Draw\",\n \"path\": \"world/commons/Draw.py\",\n \"snippet\": \"class Draw():\\n _socket = None\\n\\n def __init__(self, is_enabled:bool, unum:int, host:str, port:int) -> None:\\n self.enabled = is_enabled \\n self._is_team_right = None\\n self._unum = unum \\n self._prefix = f'?{unum}_'.encode() # temporary prefix that should never be used in normal circumstances\\n \\n #Create one socket for all instances\\n if Draw._socket is None:\\n Draw._socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM )\\n Draw._socket.connect((host, port))\\n Draw.clear_all()\\n\\n\\n def set_team_side(self, is_right):\\n ''' Called by world parser to switch side '''\\n '''\\n Generate an appropriate player ID\\n RoboViz has a bug/feature: we send \\\"swap buffers for player: 'l_1' and RoboViz\\n will swap every buffer that contains 'l_1' in the name, including \\n 'l_10' and 'l_11'. To avoid that, we swap the separator to 'l-10', 'l-11'\\n '''\\n self._is_team_right = is_right\\n self._prefix = f\\\"{'r' if is_right else 'l'}{'_' if self._unum < 10 else '-'}{self._unum}_\\\".encode() #e.g. b'l_5', b'l-10'\\n\\n\\n @staticmethod\\n def _send(msg, id, flush):\\n ''' Private method to send message if RoboViz is accessible '''\\n try:\\n if flush:\\n Draw._socket.send(msg + id + b'\\\\x00\\\\x00\\\\x00' + id + b'\\\\x00')\\n else:\\n Draw._socket.send(msg + id + b'\\\\x00')\\n except ConnectionRefusedError:\\n pass\\n\\n \\n def circle(self, pos2d, radius, thickness, color:bytes, id:str, flush=True):\\n ''' \\n Draw circle\\n\\n Examples\\n ----------\\n Circle in 2D (z=0): circle((-1,2), 3, 2, Draw.Color.red, \\\"my_circle\\\")\\n '''\\n if not self.enabled: return\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n assert not np.isnan(pos2d).any(), \\\"Argument 'pos2d' contains 'nan' values\\\"\\n\\n if self._is_team_right:\\n pos2d = (-pos2d[0],-pos2d[1]) \\n\\n msg = b'\\\\x01\\\\x00' + (\\n f'{f\\\"{pos2d[0] :.4f}\\\":.6s}'\\n f'{f\\\"{pos2d[1] :.4f}\\\":.6s}'\\n f'{f\\\"{radius :.4f}\\\":.6s}'\\n f'{f\\\"{thickness :.4f}\\\":.6s}').encode() + color\\n \\n Draw._send(msg, self._prefix + id.encode(), flush)\\n\\n\\n def line(self, p1, p2, thickness, color:bytes, id:str, flush=True):\\n ''' \\n Draw line\\n\\n Examples\\n ----------\\n Line in 3D: line((0,0,0), (0,0,2), 3, Draw.Color.red, \\\"my_line\\\") \\n Line in 2D (z=0): line((0,0), (0,1), 3, Draw.Color.red, \\\"my_line\\\") \\n '''\\n if not self.enabled: return\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n assert not np.isnan(p1).any(), \\\"Argument 'p1' contains 'nan' values\\\"\\n assert not np.isnan(p2).any(), \\\"Argument 'p2' contains 'nan' values\\\"\\n\\n z1 = p1[2] if len(p1)==3 else 0\\n z2 = p2[2] if len(p2)==3 else 0\\n\\n if self._is_team_right: \\n p1 = (-p1[0],-p1[1],p1[2]) if len(p1)==3 else (-p1[0],-p1[1])\\n p2 = (-p2[0],-p2[1],p2[2]) if len(p2)==3 else (-p2[0],-p2[1])\\n\\n msg = b'\\\\x01\\\\x01' + (\\n f'{f\\\"{p1[0] :.4f}\\\":.6s}'\\n f'{f\\\"{p1[1] :.4f}\\\":.6s}'\\n f'{f\\\"{z1 :.4f}\\\":.6s}'\\n f'{f\\\"{p2[0] :.4f}\\\":.6s}'\\n f'{f\\\"{p2[1] :.4f}\\\":.6s}'\\n f'{f\\\"{z2 :.4f}\\\":.6s}'\\n f'{f\\\"{thickness :.4f}\\\":.6s}').encode() + color\\n\\n Draw._send(msg, self._prefix + id.encode(), flush)\\n \\n\\n def point(self, pos, size, color:bytes, id:str, flush=True):\\n ''' \\n Draw point\\n\\n Examples\\n ----------\\n Point in 3D: point((1,1,1), 3, Draw.Color.red, \\\"my_point\\\")\\n Point in 2D (z=0): point((1,1), 3, Draw.Color.red, \\\"my_point\\\")\\n '''\\n if not self.enabled: return\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n assert not np.isnan(pos).any(), \\\"Argument 'pos' contains 'nan' values\\\"\\n\\n z = pos[2] if len(pos)==3 else 0\\n\\n if self._is_team_right: \\n pos = (-pos[0],-pos[1],pos[2]) if len(pos)==3 else (-pos[0],-pos[1])\\n\\n msg = b'\\\\x01\\\\x02' + (\\n f'{f\\\"{pos[0] :.4f}\\\":.6s}'\\n f'{f\\\"{pos[1] :.4f}\\\":.6s}'\\n f'{f\\\"{z :.4f}\\\":.6s}'\\n f'{f\\\"{size :.4f}\\\":.6s}').encode() + color\\n \\n Draw._send(msg, self._prefix + id.encode(), flush)\\n\\n\\n def sphere(self, pos, radius, color:bytes, id:str, flush=True):\\n ''' \\n Draw sphere\\n\\n Examples\\n ----------\\n Sphere in 3D: sphere((1,1,1), 3, Draw.Color.red, \\\"my_sphere\\\")\\n Sphere in 2D (z=0): sphere((1,1), 3, Draw.Color.red, \\\"my_sphere\\\")\\n '''\\n if not self.enabled: return\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n assert not np.isnan(pos).any(), \\\"Argument 'pos' contains 'nan' values\\\"\\n\\n z = pos[2] if len(pos)==3 else 0\\n\\n if self._is_team_right: \\n pos = (-pos[0],-pos[1],pos[2]) if len(pos)==3 else (-pos[0],-pos[1])\\n\\n msg = b'\\\\x01\\\\x03' + (\\n f'{f\\\"{pos[0] :.4f}\\\":.6s}'\\n f'{f\\\"{pos[1] :.4f}\\\":.6s}'\\n f'{f\\\"{z :.4f}\\\":.6s}'\\n f'{f\\\"{radius :.4f}\\\":.6s}').encode() + color\\n \\n Draw._send(msg, self._prefix + id.encode(), flush)\\n\\n\\n def polygon(self, vertices, color:bytes, alpha:int, id:str, flush=True):\\n ''' \\n Draw polygon\\n\\n Examples\\n ----------\\n Polygon in 3D: polygon(((0,0,0),(1,0,0),(0,1,0)), Draw.Color.red, 255, \\\"my_polygon\\\")\\n '''\\n if not self.enabled: return\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n assert 0<=alpha<=255, \\\"The alpha channel (degree of opacity) must be in range [0,255]\\\"\\n\\n if self._is_team_right: \\n vertices = [(-v[0],-v[1],v[2]) for v in vertices]\\n\\n msg = b'\\\\x01\\\\x04' + bytes([len(vertices)]) + color + alpha.to_bytes(1,'big')\\n\\n for v in vertices:\\n msg += (\\n f'{f\\\"{v[0] :.4f}\\\":.6s}'\\n f'{f\\\"{v[1] :.4f}\\\":.6s}'\\n f'{f\\\"{v[2] :.4f}\\\":.6s}').encode()\\n \\n Draw._send(msg, self._prefix + id.encode(), flush)\\n\\n\\n def annotation(self, pos, text, color:bytes, id:str, flush=True):\\n ''' \\n Draw annotation\\n\\n Examples\\n ----------\\n Annotation in 3D: annotation((1,1,1), \\\"SOMEtext!\\\", Draw.Color.red, \\\"my_annotation\\\")\\n Annotation in 2D (z=0): annotation((1,1), \\\"SOMEtext!\\\", Draw.Color.red, \\\"my_annotation\\\")\\n '''\\n if not self.enabled: return\\n if type(text) != bytes: text = str(text).encode()\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n z = pos[2] if len(pos)==3 else 0\\n\\n if self._is_team_right: \\n pos = (-pos[0],-pos[1],pos[2]) if len(pos)==3 else (-pos[0],-pos[1])\\n\\n msg = b'\\\\x02\\\\x00' + (\\n f'{f\\\"{pos[0] :.4f}\\\":.6s}'\\n f'{f\\\"{pos[1] :.4f}\\\":.6s}'\\n f'{f\\\"{z :.4f}\\\":.6s}').encode() + color + text + b'\\\\x00'\\n \\n Draw._send(msg, self._prefix + id.encode(), flush)\\n\\n \\n def arrow(self, p1, p2, arrowhead_size, thickness, color:bytes, id:str, flush=True):\\n ''' \\n Draw arrow\\n\\n Examples\\n ----------\\n Arrow in 3D: arrow((0,0,0), (0,0,2), 0.1, 3, Draw.Color.red, \\\"my_arrow\\\")\\n Arrow in 2D (z=0): arrow((0,0), (0,1), 0.1, 3, Draw.Color.red, \\\"my_arrow\\\")\\n '''\\n if not self.enabled: return\\n assert type(color)==bytes, \\\"The RGB color must be a bytes object, e.g. red: b'\\\\xFF\\\\x00\\\\x00'\\\"\\n\\n # No need to invert sides, the called shapes will handle that\\n if len(p1)==2: p1 = M.to_3d(p1) \\n else: p1 = np.asarray(p1)\\n if len(p2)==2: p2 = M.to_3d(p2) \\n else: p2 = np.asarray(p2)\\n\\n vec = p2-p1\\n vec_size = np.linalg.norm(vec)\\n if vec_size == 0: return #return without warning/error\\n if arrowhead_size > vec_size: arrowhead_size = vec_size\\n\\n ground_proj_perpendicular = np.array([ vec[1], -vec[0], 0 ])\\n\\n if np.all(ground_proj_perpendicular == 0): #vertical arrow\\n ground_proj_perpendicular = np.array([ arrowhead_size/2, 0, 0 ])\\n else:\\n ground_proj_perpendicular *= arrowhead_size/2 / np.linalg.norm(ground_proj_perpendicular)\\n\\n head_start = p2 - vec * (arrowhead_size/vec_size)\\n head_pt1 = head_start + ground_proj_perpendicular\\n head_pt2 = head_start - ground_proj_perpendicular\\n\\n self.line(p1,p2,thickness,color,id,False)\\n self.line(p2,head_pt1,thickness,color,id,False)\\n self.line(p2,head_pt2,thickness,color,id,flush)\\n\\n\\n def flush(self, id):\\n ''' Flush specific drawing by ID '''\\n if not self.enabled: return\\n\\n Draw._send(b'\\\\x00\\\\x00', self._prefix + id.encode(), False)\\n\\n def clear(self, id):\\n ''' Clear specific drawing by ID '''\\n if not self.enabled: return\\n\\n Draw._send(b'\\\\x00\\\\x00', self._prefix + id.encode(), True) #swap buffer twice\\n\\n\\n def clear_player(self):\\n ''' Clear all drawings made by this player '''\\n if not self.enabled: return\\n\\n Draw._send(b'\\\\x00\\\\x00', self._prefix, True) #swap buffer twice\\n\\n\\n @staticmethod\\n def clear_all():\\n ''' Clear all drawings of all players '''\\n if Draw._socket is not None:\\n Draw._send(b'\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00',b'',False) #swap buffer twice using no id\\n\\n\\n class Color():\\n '''\\n Based on X11 colors\\n The names are restructured to make better suggestions\\n '''\\n pink_violet = b'\\\\xC7\\\\x15\\\\x85'\\n pink_hot = b'\\\\xFF\\\\x14\\\\x93'\\n pink_violet_pale = b'\\\\xDB\\\\x70\\\\x93'\\n pink = b'\\\\xFF\\\\x69\\\\xB4'\\n pink_pale = b'\\\\xFF\\\\xB6\\\\xC1'\\n \\n red_dark = b'\\\\x8B\\\\x00\\\\x00'\\n red = b'\\\\xFF\\\\x00\\\\x00'\\n red_brick = b'\\\\xB2\\\\x22\\\\x22'\\n red_crimson = b'\\\\xDC\\\\x14\\\\x3C'\\n red_indian = b'\\\\xCD\\\\x5C\\\\x5C'\\n red_salmon = b'\\\\xFA\\\\x80\\\\x72'\\n\\n orange_red = b'\\\\xFF\\\\x45\\\\x00'\\n orange = b'\\\\xFF\\\\x8C\\\\x00'\\n orange_ligth = b'\\\\xFF\\\\xA5\\\\x00'\\n\\n yellow_gold = b'\\\\xFF\\\\xD7\\\\x00'\\n yellow = b'\\\\xFF\\\\xFF\\\\x00'\\n yellow_light = b'\\\\xBD\\\\xB7\\\\x6B'\\n\\n brown_maroon =b'\\\\x80\\\\x00\\\\x00'\\n brown_dark = b'\\\\x8B\\\\x45\\\\x13'\\n brown = b'\\\\xA0\\\\x52\\\\x2D'\\n brown_gold = b'\\\\xB8\\\\x86\\\\x0B'\\n brown_light = b'\\\\xCD\\\\x85\\\\x3F'\\n brown_pale = b'\\\\xDE\\\\xB8\\\\x87'\\n\\n green_dark = b'\\\\x00\\\\x64\\\\x00' \\n green = b'\\\\x00\\\\x80\\\\x00' \\n green_lime = b'\\\\x32\\\\xCD\\\\x32' \\n green_light = b'\\\\x00\\\\xFF\\\\x00' \\n green_lawn = b'\\\\x7C\\\\xFC\\\\x00' \\n green_pale = b'\\\\x90\\\\xEE\\\\x90' \\n\\n cyan_dark = b'\\\\x00\\\\x80\\\\x80' \\n cyan_medium = b'\\\\x00\\\\xCE\\\\xD1' \\n cyan = b'\\\\x00\\\\xFF\\\\xFF' \\n cyan_light = b'\\\\xAF\\\\xEE\\\\xEE'\\n\\n blue_dark = b'\\\\x00\\\\x00\\\\x8B' \\n blue = b'\\\\x00\\\\x00\\\\xFF' \\n blue_royal = b'\\\\x41\\\\x69\\\\xE1' \\n blue_medium = b'\\\\x1E\\\\x90\\\\xFF' \\n blue_light = b'\\\\x00\\\\xBF\\\\xFF'\\n blue_pale = b'\\\\x87\\\\xCE\\\\xEB'\\n\\n purple_violet = b'\\\\x94\\\\x00\\\\xD3' \\n purple_magenta = b'\\\\xFF\\\\x00\\\\xFF' \\n purple_light = b'\\\\xBA\\\\x55\\\\xD3' \\n purple_pale = b'\\\\xDD\\\\xA0\\\\xDD'\\n\\n white = b'\\\\xFF\\\\xFF\\\\xFF'\\n gray_10 = b'\\\\xE6\\\\xE6\\\\xE6'\\n gray_20 = b'\\\\xCC\\\\xCC\\\\xCC'\\n gray_30 = b'\\\\xB2\\\\xB2\\\\xB2' \\n gray_40 = b'\\\\x99\\\\x99\\\\x99'\\n gray_50 = b'\\\\x80\\\\x80\\\\x80'\\n gray_60 = b'\\\\x66\\\\x66\\\\x66'\\n gray_70 = b'\\\\x4C\\\\x4C\\\\x4C'\\n gray_80 = b'\\\\x33\\\\x33\\\\x33'\\n gray_90 = b'\\\\x1A\\\\x1A\\\\x1A'\\n black = b'\\\\x00\\\\x00\\\\x00' \\n\\n @staticmethod\\n def get(r,g,b):\\n ''' Get RGB color (0-255) '''\\n return bytes([int(r),int(g),int(b)])\"\n },\n {\n \"identifier\": \"Other_Robot\",\n \"path\": \"world/commons/Other_Robot.py\",\n \"snippet\": \"class Other_Robot():\\n def __init__(self, unum, is_teammate) -> None:\\n self.unum = unum # convenient variable to indicate uniform number (same as other robot's index + 1)\\n self.is_self = False # convenient flag to indicate if this robot is self\\n self.is_teammate = is_teammate # convenient variable to indicate if this robot is from our team\\n self.is_visible = False # True if this robot was seen in the last message from the server (it doesn't mean we know its absolute location)\\n self.body_parts_cart_rel_pos = dict() # cartesian relative position of the robot's visible body parts\\n self.body_parts_sph_rel_pos = dict() # spherical relative position of the robot's visible body parts\\n self.vel_filter = 0.3 # EMA filter coefficient applied to self.state_filtered_velocity\\n self.vel_decay = 0.95 # velocity decay at every vision cycle (neutralized if velocity is updated)\\n\\n\\n # State variables: these are computed when this robot is visible and when the original robot is able to self-locate\\n self.state_fallen = False # true if the robot is lying down (updated when head is visible)\\n self.state_last_update = 0 # World.time_local_ms when the state was last updated\\n self.state_horizontal_dist = 0 # horizontal head distance if head is visible, otherwise, average horizontal distance of visible body parts (the distance is updated by vision or radio when state_abs_pos gets a new value, but also when the other player is not visible, by assuming its last position)\\n self.state_abs_pos = None # 3D head position if head is visible, otherwise, 2D average position of visible body parts, or, 2D radio head position\\n self.state_orientation = 0 # orientation based on pair of lower arms or feet, or average of both (WARNING: may be older than state_last_update) \\n self.state_ground_area = None # (pt_2d,radius) projection of player area on ground (circle), not precise if farther than 3m (for performance), useful for obstacle avoidance when it falls\\n self.state_body_parts_abs_pos = dict() # 3D absolute position of each body part\\n self.state_filtered_velocity = np.zeros(3) # 3D filtered velocity (m/s) (if the head is not visible, the 2D part is updated and v.z decays)\"\n },\n {\n \"identifier\": \"Robot\",\n \"path\": \"world/Robot.py\",\n \"snippet\": \"class Robot():\\n STEPTIME = 0.02 # Fixed step time\\n VISUALSTEP = 0.04 # Fixed visual step time\\n SQ_STEPTIME = STEPTIME * STEPTIME\\n GRAVITY = np.array([0,0,-9.81])\\n IMU_DECAY = 0.996 #IMU's velocity decay\\n \\n #------------------ constants to force symmetry in joints/effectors\\n\\n MAP_PERCEPTOR_TO_INDEX = {\\\"hj1\\\":0, \\\"hj2\\\":1, \\\"llj1\\\":2, \\\"rlj1\\\":3,\\n \\\"llj2\\\":4, \\\"rlj2\\\":5, \\\"llj3\\\":6, \\\"rlj3\\\":7,\\n \\\"llj4\\\":8, \\\"rlj4\\\":9, \\\"llj5\\\":10,\\\"rlj5\\\":11,\\n \\\"llj6\\\":12,\\\"rlj6\\\":13,\\\"laj1\\\":14,\\\"raj1\\\":15,\\n \\\"laj2\\\":16,\\\"raj2\\\":17,\\\"laj3\\\":18,\\\"raj3\\\":19,\\n \\\"laj4\\\":20,\\\"raj4\\\":21,\\\"llj7\\\":22,\\\"rlj7\\\":23 }\\n\\n # Fix symmetry issues 1a/4 (identification) \\n FIX_PERCEPTOR_SET = {'rlj2','rlj6','raj2','laj3','laj4'}\\n FIX_INDICES_LIST = [5,13,17,18,20]\\n\\n # Recommended height for unofficial beam (near ground)\\n BEAM_HEIGHTS = [0.4, 0.43, 0.4, 0.46, 0.4]\\n\\n\\n def __init__(self, unum:int, robot_type:int) -> None:\\n robot_xml = \\\"nao\\\"+str(robot_type)+\\\".xml\\\" # Typical NAO file name\\n self.type = robot_type\\n self.beam_height = Robot.BEAM_HEIGHTS[robot_type]\\n self.no_of_joints = 24 if robot_type == 4 else 22 \\n\\n #Fix symmetry issues 1b/4 (identification) \\n self.FIX_EFFECTOR_MASK = np.ones(self.no_of_joints)\\n self.FIX_EFFECTOR_MASK[Robot.FIX_INDICES_LIST] = -1\\n\\n self.body_parts = dict() # keys='body part names' (given by the robot's XML), values='Body_Part objects'\\n self.unum = unum # Robot's uniform number\\n self.gyro = np.zeros(3) # Angular velocity along the three axes of freedom of the robot's torso (deg/s)\\n self.acc = np.zeros(3) # Proper acceleration along the three axes of freedom of the robot's torso (m/s2)\\n self.frp = dict() # foot \\\"lf\\\"/\\\"rf\\\", toe \\\"lf1\\\"/\\\"rf1\\\" resistance perceptor (relative [p]oint of origin + [f]orce vector) e.g. {\\\"lf\\\":(px,py,pz,fx,fy,fz)}\\n self.feet_toes_last_touch = {\\\"lf\\\":0,\\\"rf\\\":0,\\\"lf1\\\":0,\\\"rf1\\\":0} # foot \\\"lf\\\"/\\\"rf\\\", toe \\\"lf1\\\"/\\\"rf1\\\" World.time_local_ms when foot/toe last touched any surface\\n self.feet_toes_are_touching = {\\\"lf\\\":False,\\\"rf\\\":False,\\\"lf1\\\":False,\\\"rf1\\\":False} # foot \\\"lf\\\"/\\\"rf\\\", toe \\\"lf1\\\"/\\\"rf1\\\" True if touching in last received server message\\n self.fwd_kinematics_list = None # List of body parts, ordered according to dependencies\\n self.rel_cart_CoM_position = np.zeros(3) # Center of Mass position, relative to head, in cartesian coordinates (m)\\n\\n # Joint variables are optimized for performance / array operations\\n self.joints_position = np.zeros(self.no_of_joints) # Joints' angular position (deg)\\n self.joints_speed = np.zeros(self.no_of_joints) # Joints' angular speed (rad/s)\\n self.joints_target_speed = np.zeros(self.no_of_joints) # Joints' target speed (rad/s) (max: 6.1395 rad/s, see rcssserver3d/data/rsg/agent/nao/hingejoint.rsg)\\n self.joints_target_last_speed = np.zeros(self.no_of_joints) # Joints' last target speed (rad/s) (max: 6.1395 rad/s, see rcssserver3d/data/rsg/agent/nao/hingejoint.rsg)\\n self.joints_info = [None] * self.no_of_joints # Joints' constant information (see class Joint_Info)\\n self.joints_transform = [Matrix_4x4() for _ in range(self.no_of_joints)] # Joints' transformation matrix\\n\\n # Localization variables relative to head\\n self.loc_head_to_field_transform = Matrix_4x4() # Transformation matrix from head to field\\n self.loc_field_to_head_transform = Matrix_4x4() # Transformation matrix from field to head\\n self.loc_rotation_head_to_field = Matrix_3x3() # Rotation matrix from head to field\\n self.loc_rotation_field_to_head = Matrix_3x3() # Rotation matrix from field to head\\n self.loc_head_position = np.zeros(3) # Absolute head position (m)\\n self.loc_head_position_history = deque(maxlen=40)# Absolute head position history (queue with up to 40 old positions at intervals of 0.04s, where index 0 is the previous position)\\n self.loc_head_velocity = np.zeros(3) # Absolute head velocity (m/s) (Warning: possibly noisy)\\n self.loc_head_orientation = 0 # Head orientation (deg)\\n self.loc_is_up_to_date = False # False if this is not a visual step, or not enough elements are visible\\n self.loc_last_update = 0 # World.time_local_ms when the localization was last updated\\n self.loc_head_position_last_update = 0 # World.time_local_ms when loc_head_position was last updated by vision or radio\\n self.radio_fallen_state = False # True if (radio says we fell) and (radio is significantly more recent than loc)\\n self.radio_last_update = 0 # World.time_local_ms when radio_fallen_state was last updated (and possibly loc_head_position)\\n\\n # Localization variables relative to torso\\n self.loc_torso_to_field_rotation = Matrix_3x3() # Rotation matrix from torso to field \\n self.loc_torso_to_field_transform = Matrix_4x4() # Transformation matrix from torso to field\\n self.loc_torso_roll = 0 # Torso roll (deg)\\n self.loc_torso_pitch = 0 # Torso pitch (deg) \\n self.loc_torso_orientation = 0 # Torso orientation (deg)\\n self.loc_torso_inclination = 0 # Torso inclination (deg) (inclination of z-axis in relation to field z-axis)\\n self.loc_torso_position = np.zeros(3) # Absolute torso position (m)\\n self.loc_torso_velocity = np.zeros(3) # Absolute torso velocity (m/s)\\n self.loc_torso_acceleration = np.zeros(3) # Absolute Coordinate acceleration (m/s2)\\n\\n # Other localization variables\\n self.cheat_abs_pos = np.zeros(3) # Absolute head position provided by the server as cheat (m)\\n self.cheat_ori = 0.0 # Absolute head orientation provided by the server as cheat (deg)\\n self.loc_CoM_position = np.zeros(3) # Absolute CoM position (m)\\n self.loc_CoM_velocity = np.zeros(3) # Absolute CoM velocity (m/s)\\n\\n # Localization special variables\\n '''\\n self.loc_head_z is often equivalent to self.loc_head_position[2], but sometimes it differs.\\n There are situations in which the rotation and translation cannot be computed, \\n but the z-coordinate can still be found through vision, in which case:\\n self.loc_is_up_to_date is False\\n self.loc_head_z_is_up_to_date is True\\n It should be used in applications which rely on z as an independent coordinate, such\\n as detecting if the robot has fallen, or as an observation for machine learning.\\n It should NEVER be used for 3D transformations.\\n '''\\n self.loc_head_z = 0 # Absolute head position (z) - see above for explanation (m)\\n self.loc_head_z_is_up_to_date = False # False if this is not a visual step, or not enough elements are visible\\n self.loc_head_z_last_update = 0 # World.time_local_ms when loc_head_z was last computed\\n self.loc_head_z_vel = 0 # Absolute head velocity (z) (m/s)\\n\\n # Localization + Gyroscope\\n # These variables are reliable. The gyroscope is used to update the rotation when waiting for the next visual cycle\\n self.imu_torso_roll = 0 # Torso roll (deg) (src: Localization + Gyro)\\n self.imu_torso_pitch = 0 # Torso pitch (deg) (src: Localization + Gyro)\\n self.imu_torso_orientation = 0 # Torso orientation (deg) (src: Localization + Gyro)\\n self.imu_torso_inclination = 0 # Torso inclination (deg) (src: Localization + Gyro)\\n self.imu_torso_to_field_rotation = Matrix_3x3() # Rotation matrix from torso to field (src: Localization + Gyro)\\n self.imu_last_visual_update = 0 # World.time_local_ms when the IMU data was last updated with visual information \\n\\n # Localization + Gyroscope + Accelerometer\\n # Warning: these variables are unreliable, since small errors in the Localization Orientation lead to \\n # wrong acceleration -> wrong velocity -> wrong position\\n self.imu_weak_torso_to_field_transform = Matrix_4x4() # Transformation matrix from torso to field (src: Localization + Gyro + Acc)\\n self.imu_weak_head_to_field_transform = Matrix_4x4() # Transformation matrix from head to field (src: Localization + Gyro + Acc)\\n self.imu_weak_field_to_head_transform = Matrix_4x4() # Transformation matrix from field to head (src: Localization + Gyro + Acc)\\n self.imu_weak_torso_position = np.zeros(3) # Absolute torso position (m) (src: Localization + Gyro + Acc)\\n self.imu_weak_torso_velocity = np.zeros(3) # Absolute torso velocity (m/s) (src: Localization + Gyro + Acc)\\n self.imu_weak_torso_acceleration = np.zeros(3) # Absolute torso acceleration (m/s2) (src: Localization + Gyro + Acc)\\n self.imu_weak_torso_next_position = np.zeros(3) # Absolute position in next step estimate (m) (src: Localization + Gyro + Acc)\\n self.imu_weak_torso_next_velocity = np.zeros(3) # Absolute velocity in next step estimate (m/s) (src: Localization + Gyro + Acc)\\n self.imu_weak_CoM_position = np.zeros(3) # Absolute CoM position (m) (src: Localization + Gyro + Acc)\\n self.imu_weak_CoM_velocity = np.zeros(3) # Absolute CoM velocity (m/s) (src: Localization + Gyro + Acc)\\n\\n\\n #Using explicit variables to enable IDE suggestions\\n self.J_HEAD_YAW = 0\\n self.J_HEAD_PITCH = 1\\n self.J_LLEG_YAW_PITCH = 2\\n self.J_RLEG_YAW_PITCH = 3\\n self.J_LLEG_ROLL = 4\\n self.J_RLEG_ROLL = 5\\n self.J_LLEG_PITCH = 6\\n self.J_RLEG_PITCH = 7\\n self.J_LKNEE = 8\\n self.J_RKNEE = 9\\n self.J_LFOOT_PITCH = 10\\n self.J_RFOOT_PITCH = 11\\n self.J_LFOOT_ROLL = 12\\n self.J_RFOOT_ROLL = 13\\n self.J_LARM_PITCH = 14\\n self.J_RARM_PITCH = 15\\n self.J_LARM_ROLL = 16\\n self.J_RARM_ROLL = 17\\n self.J_LELBOW_YAW = 18\\n self.J_RELBOW_YAW = 19\\n self.J_LELBOW_ROLL = 20\\n self.J_RELBOW_ROLL = 21\\n self.J_LTOE_PITCH = 22\\n self.J_RTOE_PITCH = 23\\n\\n\\n #------------------ parse robot xml\\n\\n dir = M.get_active_directory(\\\"/world/commons/robots/\\\")\\n robot_xml_root = xmlp.parse(dir + robot_xml).getroot()\\n\\n joint_no = 0\\n for child in robot_xml_root:\\n if child.tag == \\\"bodypart\\\":\\n self.body_parts[child.attrib['name']] = Body_Part(child.attrib['mass'])\\n elif child.tag == \\\"joint\\\":\\n self.joints_info[joint_no] = Joint_Info(child)\\n self.joints_position[joint_no] = 0.0\\n ji = self.joints_info[joint_no]\\n\\n #save joint if body part is 1st anchor (to simplify model traversal in a single direction)\\n self.body_parts[ji.anchor0_part].joints.append(Robot.MAP_PERCEPTOR_TO_INDEX[ji.perceptor]) \\n\\n joint_no += 1\\n if joint_no == self.no_of_joints: break #ignore extra joints\\n\\n else:\\n raise NotImplementedError\\n\\n assert joint_no == self.no_of_joints, \\\"The Robot XML and the robot type don't match!\\\"\\n\\n\\n def get_head_abs_vel(self, history_steps:int):\\n '''\\n Get robot's head absolute velocity (m/s)\\n\\n Parameters\\n ----------\\n history_steps : int\\n number of history steps to consider [1,40]\\n\\n Examples\\n --------\\n get_head_abs_vel(1) is equivalent to (current abs pos - last abs pos) / 0.04\\n get_head_abs_vel(2) is equivalent to (current abs pos - abs pos 0.08s ago) / 0.08\\n get_head_abs_vel(3) is equivalent to (current abs pos - abs pos 0.12s ago) / 0.12\\n '''\\n assert 1 <= history_steps <= 40, \\\"Argument 'history_steps' must be in range [1,40]\\\"\\n\\n if len(self.loc_head_position_history) == 0:\\n return np.zeros(3)\\n\\n h_step = min(history_steps, len(self.loc_head_position_history))\\n t = h_step * Robot.VISUALSTEP\\n\\n return (self.loc_head_position - self.loc_head_position_history[h_step-1]) / t\\n \\n\\n def _initialize_kinematics(self):\\n\\n #starting with head\\n parts={\\\"head\\\"}\\n sequential_body_parts = [\\\"head\\\"]\\n\\n while len(parts) > 0:\\n part = parts.pop()\\n\\n for j in self.body_parts[part].joints:\\n\\n p = self.joints_info[j].anchor1_part\\n\\n if len(self.body_parts[p].joints) > 0: #add body part if it is the 1st anchor of some joint\\n parts.add(p)\\n sequential_body_parts.append(p)\\n\\n self.fwd_kinematics_list = [(self.body_parts[part],j, self.body_parts[self.joints_info[j].anchor1_part] ) \\n for part in sequential_body_parts for j in self.body_parts[part].joints]\\n\\n #Fix symmetry issues 4/4 (kinematics)\\n for i in Robot.FIX_INDICES_LIST:\\n self.joints_info[i].axes *= -1\\n aux = self.joints_info[i].min\\n self.joints_info[i].min = -self.joints_info[i].max\\n self.joints_info[i].max = -aux\\n\\n\\n def update_localization(self, localization_raw, time_local_ms): \\n\\n # parse raw data\\n loc = localization_raw.astype(float) #32bits to 64bits for consistency\\n self.loc_is_up_to_date = bool(loc[32])\\n self.loc_head_z_is_up_to_date = bool(loc[34])\\n\\n if self.loc_head_z_is_up_to_date:\\n time_diff = (time_local_ms - self.loc_head_z_last_update) / 1000 \\n self.loc_head_z_vel = (loc[33] - self.loc_head_z) / time_diff\\n self.loc_head_z = loc[33]\\n self.loc_head_z_last_update = time_local_ms\\n\\n # Save last position to history at every vision cycle (even if not up to date) (update_localization is only called at vision cycles)\\n self.loc_head_position_history.appendleft(np.copy(self.loc_head_position))\\n\\n if self.loc_is_up_to_date:\\n time_diff = (time_local_ms - self.loc_last_update) / 1000\\n self.loc_last_update = time_local_ms\\n self.loc_head_to_field_transform.m[:] = loc[0:16].reshape((4,4))\\n self.loc_field_to_head_transform.m[:] = loc[16:32].reshape((4,4))\\n \\n # extract data (related to the robot's head)\\n self.loc_rotation_head_to_field = self.loc_head_to_field_transform.get_rotation()\\n self.loc_rotation_field_to_head = self.loc_field_to_head_transform.get_rotation()\\n p = self.loc_head_to_field_transform.get_translation()\\n self.loc_head_velocity = (p - self.loc_head_position) / time_diff\\n self.loc_head_position = p\\n self.loc_head_position_last_update = time_local_ms\\n self.loc_head_orientation = self.loc_head_to_field_transform.get_yaw_deg()\\n self.radio_fallen_state = False\\n\\n # extract data (related to the center of mass)\\n p = self.loc_head_to_field_transform(self.rel_cart_CoM_position)\\n self.loc_CoM_velocity = (p - self.loc_CoM_position) / time_diff\\n self.loc_CoM_position = p\\n\\n # extract data (related to the robot's torso)\\n t = self.get_body_part_to_field_transform('torso')\\n self.loc_torso_to_field_transform = t\\n self.loc_torso_to_field_rotation = t.get_rotation()\\n self.loc_torso_orientation = t.get_yaw_deg()\\n self.loc_torso_pitch = t.get_pitch_deg()\\n self.loc_torso_roll = t.get_roll_deg()\\n self.loc_torso_inclination = t.get_inclination_deg()\\n p = t.get_translation()\\n self.loc_torso_velocity = (p - self.loc_torso_position) / time_diff\\n self.loc_torso_position = p\\n self.loc_torso_acceleration = self.loc_torso_to_field_rotation.multiply(self.acc) + Robot.GRAVITY\\n\\n\\n def head_to_body_part_transform(self, body_part_name, coords, is_batch=False):\\n '''\\n If coord is a vector or list of vectors:\\n Convert cartesian coordinates that are relative to head to coordinates that are relative to a body part \\n\\n If coord is a Matrix_4x4 or a list of Matrix_4x4:\\n Convert pose that is relative to head to a pose that is relative to a body part \\n \\n Parameters\\n ----------\\n body_part_name : `str`\\n name of body part (given by the robot's XML)\\n coords : array_like\\n One 3D position or list of 3D positions\\n is_batch : `bool`\\n Indicates if coords is a batch of 3D positions\\n\\n Returns\\n -------\\n coord : `list` or ndarray\\n A numpy array is returned if is_batch is False, otherwise, a list of arrays is returned\\n '''\\n head_to_bp_transform : Matrix_4x4 = self.body_parts[body_part_name].transform.invert()\\n \\n if is_batch:\\n return [head_to_bp_transform(c) for c in coords]\\n else:\\n return head_to_bp_transform(coords)\\n\\n\\n\\n def get_body_part_to_field_transform(self, body_part_name) -> Matrix_4x4:\\n '''\\n Computes the transformation matrix from body part to field, from which we can extract its absolute position and rotation.\\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\\n will not be synced with the localization data and strange results may occur.\\n '''\\n return self.loc_head_to_field_transform.multiply(self.body_parts[body_part_name].transform)\\n\\n def get_body_part_abs_position(self, body_part_name) -> np.ndarray:\\n '''\\n Computes the absolute position of a body part considering the localization data and forward kinematics.\\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\\n will not be synced with the localization data and strange results may occur.\\n '''\\n return self.get_body_part_to_field_transform(body_part_name).get_translation()\\n\\n def get_joint_to_field_transform(self, joint_index) -> Matrix_4x4:\\n '''\\n Computes the transformation matrix from joint to field, from which we can extract its absolute position and rotation.\\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\\n will not be synced with the localization data and strange results may occur.\\n '''\\n return self.loc_head_to_field_transform.multiply(self.joints_transform[joint_index])\\n\\n def get_joint_abs_position(self, joint_index) -> np.ndarray:\\n '''\\n Computes the absolute position of a joint considering the localization data and forward kinematics.\\n For best results, use this method when self.loc_is_up_to_date is True. Otherwise, the forward kinematics\\n will not be synced with the localization data and strange results may occur.\\n '''\\n return self.get_joint_to_field_transform(joint_index).get_translation()\\n\\n def update_pose(self):\\n\\n if self.fwd_kinematics_list is None:\\n self._initialize_kinematics()\\n\\n for body_part, j, child_body_part in self.fwd_kinematics_list:\\n ji = self.joints_info[j]\\n self.joints_transform[j].m[:] = body_part.transform.m\\n self.joints_transform[j].translate(ji.anchor0_axes, True)\\n child_body_part.transform.m[:] = self.joints_transform[j].m\\n child_body_part.transform.rotate_deg(ji.axes, self.joints_position[j], True)\\n child_body_part.transform.translate(ji.anchor1_axes_neg, True)\\n\\n self.rel_cart_CoM_position = np.average([b.transform.get_translation() for b in self.body_parts.values()], 0,\\n [b.mass for b in self.body_parts.values()])\\n\\n\\n def update_imu(self, time_local_ms):\\n\\n # update IMU\\n if self.loc_is_up_to_date:\\n self.imu_torso_roll = self.loc_torso_roll\\n self.imu_torso_pitch = self.loc_torso_pitch \\n self.imu_torso_orientation = self.loc_torso_orientation\\n self.imu_torso_inclination = self.loc_torso_inclination\\n self.imu_torso_to_field_rotation.m[:] = self.loc_torso_to_field_rotation.m\\n self.imu_weak_torso_to_field_transform.m[:] = self.loc_torso_to_field_transform.m\\n self.imu_weak_head_to_field_transform.m[:] = self.loc_head_to_field_transform.m\\n self.imu_weak_field_to_head_transform.m[:] = self.loc_field_to_head_transform.m\\n self.imu_weak_torso_position[:] = self.loc_torso_position\\n self.imu_weak_torso_velocity[:] = self.loc_torso_velocity\\n self.imu_weak_torso_acceleration[:] = self.loc_torso_acceleration\\n self.imu_weak_torso_next_position = self.loc_torso_position + self.loc_torso_velocity * Robot.STEPTIME + self.loc_torso_acceleration * (0.5 * Robot.SQ_STEPTIME)\\n self.imu_weak_torso_next_velocity = self.loc_torso_velocity + self.loc_torso_acceleration * Robot.STEPTIME\\n self.imu_weak_CoM_position[:] = self.loc_CoM_position\\n self.imu_weak_CoM_velocity[:] = self.loc_CoM_velocity\\n self.imu_last_visual_update = time_local_ms\\n else:\\n g = self.gyro / 50 # convert degrees per second to degrees per step\\n\\n self.imu_torso_to_field_rotation.multiply( Matrix_3x3.from_rotation_deg(g), in_place=True, reverse_order=True)\\n\\n self.imu_torso_orientation = self.imu_torso_to_field_rotation.get_yaw_deg()\\n self.imu_torso_pitch = self.imu_torso_to_field_rotation.get_pitch_deg()\\n self.imu_torso_roll = self.imu_torso_to_field_rotation.get_roll_deg()\\n\\n self.imu_torso_inclination = atan(sqrt(tan(self.imu_torso_roll/180*pi)**2+tan(self.imu_torso_pitch/180*pi)**2))*180/pi\\n\\n # Update position and velocity until 0.2 seconds has passed since last visual update\\n if time_local_ms < self.imu_last_visual_update + 200:\\n self.imu_weak_torso_position[:] = self.imu_weak_torso_next_position\\n if self.imu_weak_torso_position[2] < 0: self.imu_weak_torso_position[2] = 0 # limit z coordinate to positive values\\n self.imu_weak_torso_velocity[:] = self.imu_weak_torso_next_velocity * Robot.IMU_DECAY # stability tradeoff\\n else:\\n self.imu_weak_torso_velocity *= 0.97 # without visual updates for 0.2s, the position is locked, and the velocity decays to zero\\n\\n # convert proper acceleration to coordinate acceleration and fix rounding bias\\n self.imu_weak_torso_acceleration = self.imu_torso_to_field_rotation.multiply(self.acc) + Robot.GRAVITY\\n self.imu_weak_torso_to_field_transform = Matrix_4x4.from_3x3_and_translation(self.imu_torso_to_field_rotation,self.imu_weak_torso_position)\\n self.imu_weak_head_to_field_transform = self.imu_weak_torso_to_field_transform.multiply(self.body_parts[\\\"torso\\\"].transform.invert())\\n self.imu_weak_field_to_head_transform = self.imu_weak_head_to_field_transform.invert()\\n p = self.imu_weak_head_to_field_transform(self.rel_cart_CoM_position)\\n self.imu_weak_CoM_velocity = (p-self.imu_weak_CoM_position)/Robot.STEPTIME\\n self.imu_weak_CoM_position = p\\n\\n # Next Position = x0 + v0*t + 0.5*a*t^2, Next velocity = v0 + a*t\\n self.imu_weak_torso_next_position = self.imu_weak_torso_position + self.imu_weak_torso_velocity * Robot.STEPTIME + self.imu_weak_torso_acceleration * (0.5 * Robot.SQ_STEPTIME)\\n self.imu_weak_torso_next_velocity = self.imu_weak_torso_velocity + self.imu_weak_torso_acceleration * Robot.STEPTIME\\n\\n\\n\\n def set_joints_target_position_direct(self,indices,values:np.ndarray,harmonize=True,max_speed=7.03,tolerance=0.012,limit_joints=True) -> int:\\n '''\\n Computes the speed of a list of joints, taking as argument the target position\\n\\n Parameters\\n ----------\\n indices : `int`/`list`/`slice`/numpy array\\n joint indices\\n values : numpy array \\n target position for each listed joint index\\n harmonize : `bool`\\n if True, all joints reach target at same time\\n max_speed : `float`\\n max. speed for all joints in deg/step\\n Most joints have a maximum speed of 351.77 deg/s according to rcssserver3d/data/rsg/agent/nao/hingejoint.rsg\\n That translates as 7.0354 deg/step or 6.1395 rad/s\\n tolerance : `float`\\n angle error tolerance (in degrees) to return that target was reached (returns -1)\\n limit_joints : `bool`\\n limit values to the joints' range of motion\\n\\n Returns\\n -------\\n remaining_steps : `int`\\n predicted number of remaining steps or -1 if target was already reached\\n\\n Examples\\n -------\\n (let p[tx] be the joint position at t=x)\\n\\n Example for return value: moving joint[0] from 0deg to 10deg\\n pos[t0]: 0, speed[t0]: 7deg/step, ret=2 # target will predictedly be reached in 2 steps\\n pos[t1]: 7, speed[t1]: 3deg/step, ret=1 # target will predictedly be reached in 1 step (send final action)\\n pos[t2]: 10, speed[t2]: 0deg/step, ret=0 # target was predictedly already reached \\n pos[t3]: 10, speed[t3]: 0deg/step, ret=-1 # (best case scenario) server reported with delay, that target was reached (see tolerance)\\n pos[t?]: 10, speed[t?]: 0deg/step, ret=-1 # if there is friction, it may take some additional steps \\n\\n If everything worked as predicted we could stop calling this function when ret==1\\n If we need precision, it is recommended to wait for ret==-1\\n\\n Example 1:\\n set_joints_target_position_direct(range(2,4),np.array([10.0,5.0]),harmonize=True) \\n Joint[2] p[t0]: 0 target pos: 10 -> p[t1]=5, p[t2]=10\\n Joint[3] p[t0]: 0 target pos: 5 -> p[t1]=2.5, p[t2]=5\\n\\n Example 2:\\n set_joints_target_position_direct([2,3],np.array([10.0,5.0]),harmonize=False) \\n Joint[2] p[t0]: 0 target pos: 10 -> p[t1]=7, p[t2]=10\\n Joint[3] p[t0]: 0 target pos: 5 -> p[t1]=5, p[t2]=5 \\n '''\\n\\n assert type(values) == np.ndarray, \\\"'values' argument must be a numpy array\\\"\\n np.nan_to_num(values, copy=False) # Replace NaN with zero and infinity with large finite numbers\\n\\n # limit range of joints\\n if limit_joints: \\n if type(indices) == list or type(indices) == np.ndarray:\\n for i in range(len(indices)):\\n values[i] = np.clip(values[i], self.joints_info[indices[i]].min, self.joints_info[indices[i]].max)\\n elif type(indices) == slice:\\n info = self.joints_info[indices]\\n for i in range(len(info)):\\n values[i] = np.clip(values[i], info[i].min, info[i].max)\\n else: # int\\n values[0] = np.clip(values[0], self.joints_info[indices].min, self.joints_info[indices].max)\\n\\n #predicted_diff: predicted difference between reported position and actual position\\n\\n predicted_diff = self.joints_target_last_speed[indices] * 1.1459156 #rad/s to deg/step\\n predicted_diff = np.asarray(predicted_diff)\\n np.clip(predicted_diff,-7.03,7.03,out=predicted_diff) #saturate predicted movement in-place\\n\\n #reported_dist: difference between reported position and target position\\n\\n reported_dist = values - self.joints_position[indices]\\n if np.all((np.abs(reported_dist) < tolerance)) and np.all((np.abs(predicted_diff) < tolerance)):\\n self.joints_target_speed[indices] = 0\\n return -1\\n \\n deg_per_step = reported_dist - predicted_diff\\n\\n relative_max = np.max( np.abs(deg_per_step) ) / max_speed\\n remaining_steps = np.ceil( relative_max )\\n\\n if remaining_steps == 0:\\n self.joints_target_speed[indices] = 0\\n return 0\\n\\n if harmonize: \\n deg_per_step /= remaining_steps\\n else:\\n np.clip(deg_per_step,-max_speed,max_speed,out=deg_per_step) #limit maximum speed\\n\\n self.joints_target_speed[indices] = deg_per_step * 0.87266463 #convert to rad/s\\n\\n return remaining_steps\\n\\n\\n\\n def get_command(self) -> bytes:\\n '''\\n Builds commands string from self.joints_target_speed\\n '''\\n j_speed = self.joints_target_speed * self.FIX_EFFECTOR_MASK #Fix symmetry issues 3/4 (effectors)\\n cmd = \\\"\\\".join(f\\\"({self.joints_info[i].effector} {j_speed[i]:.5f})\\\" for i in range(self.no_of_joints)).encode('utf-8')\\n\\n self.joints_target_last_speed = self.joints_target_speed #1. both point to the same array\\n self.joints_target_speed = np.zeros_like(self.joints_target_speed) #2. create new array for joints_target_speed\\n return cmd\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from collections import deque\nfrom cpp.ball_predictor import ball_predictor\nfrom cpp.localization import localization\nfrom logs.Logger import Logger\nfrom math import atan2, pi\nfrom math_ops.Matrix_4x4 import Matrix_4x4\nfrom world.commons.Draw import Draw\nfrom world.commons.Other_Robot import Other_Robot\nfrom world.Robot import Robot\nimport numpy as np"},"token_num":{"kind":"number","value":19012,"string":"19,012"},"cropped_code":{"kind":"string","value":"\n\nclass World():\n STEPTIME = 0.02 # Fixed step time\n STEPTIME_MS = 20 # Fixed step time in milliseconds\n VISUALSTEP = 0.04 # Fixed visual step time\n VISUALSTEP_MS = 40 # Fixed visual step time in milliseconds\n\n # play modes in our favor\n M_OUR_KICKOFF = 0\n M_OUR_KICK_IN = 1\n M_OUR_CORNER_KICK = 2\n M_OUR_GOAL_KICK = 3\n M_OUR_FREE_KICK = 4\n M_OUR_PASS = 5\n M_OUR_DIR_FREE_KICK = 6\n M_OUR_GOAL = 7\n M_OUR_OFFSIDE = 8\n\n # play modes in their favor\n M_THEIR_KICKOFF = 9\n M_THEIR_KICK_IN = 10\n M_THEIR_CORNER_KICK = 11\n M_THEIR_GOAL_KICK = 12\n M_THEIR_FREE_KICK = 13\n M_THEIR_PASS = 14\n M_THEIR_DIR_FREE_KICK = 15\n M_THEIR_GOAL = 16\n M_THEIR_OFFSIDE = 17\n\n # neutral play modes\n M_BEFORE_KICKOFF = 18\n M_GAME_OVER = 19\n M_PLAY_ON = 20\n\n # play mode groups\n MG_OUR_KICK = 0\n MG_THEIR_KICK = 1\n MG_ACTIVE_BEAM = 2\n MG_PASSIVE_BEAM = 3\n MG_OTHER = 4 # play on, game over\n\n FLAGS_CORNERS_POS = ((-15,-10,0), (-15,+10,0), (+15,-10,0), (+15,+10,0))\n FLAGS_POSTS_POS = ((-15,-1.05,0.8),(-15,+1.05,0.8),(+15,-1.05,0.8),(+15,+1.05,0.8))\n\n def __init__(self,robot_type:int, team_name:str, unum:int, apply_play_mode_correction:bool, \n enable_draw:bool, logger:Logger, host:str) -> None:\n\n self.team_name = team_name # Name of our team\n self.team_name_opponent : str = None # Name of opponent team\n self.apply_play_mode_correction = apply_play_mode_correction # True to adjust ball position according to play mode\n self.step = 0 # Total number of received simulation steps (always in sync with self.time_local_ms)\n self.time_server = 0.0 # Time, in seconds, as indicated by the server (this time is NOT reliable, use only for synchronization between agents)\n self.time_local_ms = 0 # Reliable simulation time in milliseconds, use this when possible (it is incremented 20ms for every TCP message)\n self.time_game = 0.0 # Game time, in seconds, as indicated by the server\n self.goals_scored = 0 # Goals score by our team\n self.goals_conceded = 0 # Goals conceded by our team\n self.team_side_is_left : bool = None # True if our team plays on the left side (this value is later changed by the world parser)\n self.play_mode = None # Play mode of the soccer game, provided by the server \n self.play_mode_group = None # Certain play modes share characteristics, so it makes sense to group them\n self.flags_corners : dict = None # corner flags, key=(x,y,z), always assume we play on the left side\n self.flags_posts : dict = None # goal posts, key=(x,y,z), always assume we play on the left side\n self.ball_rel_head_sph_pos = np.zeros(3) # Ball position relative to head (spherical coordinates) (m, deg, deg)\n self.ball_rel_head_cart_pos = np.zeros(3) # Ball position relative to head (cartesian coordinates) (m)\n self.ball_rel_torso_cart_pos = np.zeros(3) # Ball position relative to torso (cartesian coordinates) (m)\n self.ball_rel_torso_cart_pos_history = deque(maxlen=20) # Ball position relative to torso history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)\n self.ball_abs_pos = np.zeros(3) # Ball absolute position (up to date if self.ball_is_visible and self.robot.loc_is_up_to_date) (m)\n self.ball_abs_pos_history = deque(maxlen=20) # Ball absolute position history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)\n self.ball_abs_pos_last_update = 0 # World.time_local_ms when self.ball_abs_pos was last updated by vision or radio\n self.ball_abs_vel = np.zeros(3) # Ball velocity vector based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead get_ball_abs_vel)\n self.ball_abs_speed = 0 # Ball scalar speed based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead ||get_ball_abs_vel||)\n self.ball_is_visible = False # True if the last server message contained vision information related to the ball\n self.is_ball_abs_pos_from_vision = False # True if ball_abs_pos originated from vision, False if it originated from radio\n self.ball_last_seen = 0 # World.time_local_ms when ball was last seen (note: may be different from self.ball_abs_pos_last_update)\n self.ball_cheat_abs_pos = np.zeros(3) # Absolute ball position provided by the server as cheat (m)\n self.ball_cheat_abs_vel = np.zeros(3) # Absolute velocity vector based on the last 2 values of self.ball_cheat_abs_pos (m/s)\n self.ball_2d_pred_pos = np.zeros((1,2)) # prediction of current and future 2D ball positions*\n self.ball_2d_pred_vel = np.zeros((1,2)) # prediction of current and future 2D ball velocities*\n self.ball_2d_pred_spd = np.zeros(1) # prediction of current and future 2D ball linear speeds*\n # *at intervals of 0.02 s until ball comes to a stop or gets out of bounds (according to prediction)\n self.lines = np.zeros((30,6)) # Position of visible lines, relative to head, start_pos+end_pos (spherical coordinates) (m, deg, deg, m, deg, deg)\n self.line_count = 0 # Number of visible lines\n self.vision_last_update = 0 # World.time_local_ms when last vision update was received\n self.vision_is_up_to_date = False # True if the last server message contained vision information\n self.teammates = [Other_Robot(i, True ) for i in range(1,12)] # List of teammates, ordered by unum\n self.opponents = [Other_Robot(i, False) for i in range(1,12)] # List of opponents, ordered by unum\n self.teammates[unum-1].is_self = True # This teammate is self\n"},"all_code":{"kind":"string","value":"\n\nclass World():\n STEPTIME = 0.02 # Fixed step time\n STEPTIME_MS = 20 # Fixed step time in milliseconds\n VISUALSTEP = 0.04 # Fixed visual step time\n VISUALSTEP_MS = 40 # Fixed visual step time in milliseconds\n\n # play modes in our favor\n M_OUR_KICKOFF = 0\n M_OUR_KICK_IN = 1\n M_OUR_CORNER_KICK = 2\n M_OUR_GOAL_KICK = 3\n M_OUR_FREE_KICK = 4\n M_OUR_PASS = 5\n M_OUR_DIR_FREE_KICK = 6\n M_OUR_GOAL = 7\n M_OUR_OFFSIDE = 8\n\n # play modes in their favor\n M_THEIR_KICKOFF = 9\n M_THEIR_KICK_IN = 10\n M_THEIR_CORNER_KICK = 11\n M_THEIR_GOAL_KICK = 12\n M_THEIR_FREE_KICK = 13\n M_THEIR_PASS = 14\n M_THEIR_DIR_FREE_KICK = 15\n M_THEIR_GOAL = 16\n M_THEIR_OFFSIDE = 17\n\n # neutral play modes\n M_BEFORE_KICKOFF = 18\n M_GAME_OVER = 19\n M_PLAY_ON = 20\n\n # play mode groups\n MG_OUR_KICK = 0\n MG_THEIR_KICK = 1\n MG_ACTIVE_BEAM = 2\n MG_PASSIVE_BEAM = 3\n MG_OTHER = 4 # play on, game over\n\n FLAGS_CORNERS_POS = ((-15,-10,0), (-15,+10,0), (+15,-10,0), (+15,+10,0))\n FLAGS_POSTS_POS = ((-15,-1.05,0.8),(-15,+1.05,0.8),(+15,-1.05,0.8),(+15,+1.05,0.8))\n\n def __init__(self,robot_type:int, team_name:str, unum:int, apply_play_mode_correction:bool, \n enable_draw:bool, logger:Logger, host:str) -> None:\n\n self.team_name = team_name # Name of our team\n self.team_name_opponent : str = None # Name of opponent team\n self.apply_play_mode_correction = apply_play_mode_correction # True to adjust ball position according to play mode\n self.step = 0 # Total number of received simulation steps (always in sync with self.time_local_ms)\n self.time_server = 0.0 # Time, in seconds, as indicated by the server (this time is NOT reliable, use only for synchronization between agents)\n self.time_local_ms = 0 # Reliable simulation time in milliseconds, use this when possible (it is incremented 20ms for every TCP message)\n self.time_game = 0.0 # Game time, in seconds, as indicated by the server\n self.goals_scored = 0 # Goals score by our team\n self.goals_conceded = 0 # Goals conceded by our team\n self.team_side_is_left : bool = None # True if our team plays on the left side (this value is later changed by the world parser)\n self.play_mode = None # Play mode of the soccer game, provided by the server \n self.play_mode_group = None # Certain play modes share characteristics, so it makes sense to group them\n self.flags_corners : dict = None # corner flags, key=(x,y,z), always assume we play on the left side\n self.flags_posts : dict = None # goal posts, key=(x,y,z), always assume we play on the left side\n self.ball_rel_head_sph_pos = np.zeros(3) # Ball position relative to head (spherical coordinates) (m, deg, deg)\n self.ball_rel_head_cart_pos = np.zeros(3) # Ball position relative to head (cartesian coordinates) (m)\n self.ball_rel_torso_cart_pos = np.zeros(3) # Ball position relative to torso (cartesian coordinates) (m)\n self.ball_rel_torso_cart_pos_history = deque(maxlen=20) # Ball position relative to torso history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)\n self.ball_abs_pos = np.zeros(3) # Ball absolute position (up to date if self.ball_is_visible and self.robot.loc_is_up_to_date) (m)\n self.ball_abs_pos_history = deque(maxlen=20) # Ball absolute position history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)\n self.ball_abs_pos_last_update = 0 # World.time_local_ms when self.ball_abs_pos was last updated by vision or radio\n self.ball_abs_vel = np.zeros(3) # Ball velocity vector based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead get_ball_abs_vel)\n self.ball_abs_speed = 0 # Ball scalar speed based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead ||get_ball_abs_vel||)\n self.ball_is_visible = False # True if the last server message contained vision information related to the ball\n self.is_ball_abs_pos_from_vision = False # True if ball_abs_pos originated from vision, False if it originated from radio\n self.ball_last_seen = 0 # World.time_local_ms when ball was last seen (note: may be different from self.ball_abs_pos_last_update)\n self.ball_cheat_abs_pos = np.zeros(3) # Absolute ball position provided by the server as cheat (m)\n self.ball_cheat_abs_vel = np.zeros(3) # Absolute velocity vector based on the last 2 values of self.ball_cheat_abs_pos (m/s)\n self.ball_2d_pred_pos = np.zeros((1,2)) # prediction of current and future 2D ball positions*\n self.ball_2d_pred_vel = np.zeros((1,2)) # prediction of current and future 2D ball velocities*\n self.ball_2d_pred_spd = np.zeros(1) # prediction of current and future 2D ball linear speeds*\n # *at intervals of 0.02 s until ball comes to a stop or gets out of bounds (according to prediction)\n self.lines = np.zeros((30,6)) # Position of visible lines, relative to head, start_pos+end_pos (spherical coordinates) (m, deg, deg, m, deg, deg)\n self.line_count = 0 # Number of visible lines\n self.vision_last_update = 0 # World.time_local_ms when last vision update was received\n self.vision_is_up_to_date = False # True if the last server message contained vision information\n self.teammates = [Other_Robot(i, True ) for i in range(1,12)] # List of teammates, ordered by unum\n self.opponents = [Other_Robot(i, False) for i in range(1,12)] # List of opponents, ordered by unum\n self.teammates[unum-1].is_self = True # This teammate is self"},"next_line":{"kind":"string","value":" self.draw = Draw(enable_draw, unum, host, 32769) # Draw object for current player"},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-12-16 23:40:23+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5677,"cells":{"repo_name":{"kind":"string","value":"Sam-Izdat/tinycio"},"file_path":{"kind":"string","value":"src/tinycio/lut.py"},"context":{"kind":"list like","value":[{"identifier":"ColorSpace","path":"src/tinycio/colorspace.py","snippet":"class ColorSpace:\n \"\"\"\n Color space conversion. Applies OETFs and EOTFs as needed but omits tonemapping. Cylindrical transformations are \n treated as distinct color spaces. Example:\n\n .. highlight:: python\n .. code-block:: python\n \n cs_in = ColorSpace.Variant.SRGB_LIN\n cs_out = ColorSpace.Variant.OKLAB\n oklab_image = ColorSpace.convert(srgb_image, source=cs_in, destination=cs_out)\n \"\"\"\n class Variant(IntEnum):\n \"\"\"\n Color space enum. For a list of available options, see :ref:`ref_color_spaces`.\n \"\"\"\n UNKNOWN = 1<<0 \n NONCOLOR = 1<<1 \n CIE_XYZ = 1<<2 \n CIE_XYY = 1<<3 \n SRGB = 1<<4 \n SRGB_LIN = 1<<5 \n REC709 = 1<<6 \n REC2020 = 1<<7 \n REC2020_LIN = 1<<8 \n DCI_P3 = 1<<9 \n DCI_P3_LIN = 1<<10 \n DISPLAY_P3 = 1<<11 \n ACESCG = 1<<12 \n ACESCC = 1<<13 \n ACESCCT = 1<<14 \n ACES2065_1 = 1<<15 \n LMS = 1<<16 \n OKLAB = 1<<17 \n CIELAB = 1<<18 \n CIELUV = 1<<19 \n HSV = 1<<20 \n HSL = 1<<21 \n OKHSV = 1<<22\n OKHSL = 1<<23\n\n SCENE_LINEAR = SRGB_LIN | REC2020_LIN | DCI_P3_LIN | ACESCG | ACES2065_1 | CIE_XYZ\n PERCEPTUAL = OKLAB | CIELAB | CIELUV | OKHSL | OKHSV\n CYLINDRICAL = HSL | HSV | OKHSL | OKHSV\n\n GAMUT_SRGB = SRGB | SRGB_LIN | REC709 | HSL | HSV\n GAMUT_AP0 = ACES2065_1\n GAMUT_AP1 = ACESCG | ACESCC | ACESCCT\n GAMUT_REC2020 = REC2020 | REC2020_LIN\n GAMUT_DCI_P3 = DCI_P3 | DCI_P3_LIN\n GAMUT_DISPLAY_P3= DISPLAY_P3\n GAMUT_OKLAB = OKLAB | OKHSL | OKHSV\n GAMUT_CIE_XYZ = CIE_XYZ | CIE_XYY\n GAMUT_CIELAB = CIELAB\n GAMUT_CIELUV = CIELUV\n GAMUT_OTHER = LMS | UNKNOWN | NONCOLOR\n\n WP_D65 = SRGB | SRGB_LIN | REC709 | DISPLAY_P3 | REC2020 | REC2020_LIN | CIE_XYZ | CIE_XYY\n WP_CCT_6300 = DCI_P3 | DCI_P3_LIN\n WP_CCT_6000 = ACESCG | ACESCC | ACESCCT | ACES2065_1\n\n MODEL_RGB = SRGB | SRGB_LIN | REC709 | REC2020 | REC2020_LIN | DCI_P3 | DCI_P3_LIN | DISPLAY_P3 | \\\n ACESCG | ACESCC | ACESCCT | ACES2065_1\n MODEL_CIE = CIE_XYZ | CIE_XYY | CIELAB | CIELUV\n MODEL_CAM = 0\n MODEL_YUV = 0\n MODEL_OTHER = LMS | HSL | HSV | OKLAB # is OKLAB CAM-based?\n \n NEGATIVE = OKLAB | CIELAB | CIELUV | GAMUT_AP0\n NON_NEGATIVE = ~NEGATIVE\n\n DISABLED = CIELUV\n UNSUPPORTED = OKHSV | OKHSL # disabled doesn't go here - CS must have alternate path\n SUPPORTED = ~UNSUPPORTED \n\n # FIXME: LUV doesn't quite match expected values, needs further testing\n\n mat_xyz_to_srgb = [\n [3.24096994190452134, -1.53738317757009346, -0.498610760293003284],\n [-0.969243636280879826, 1.87596750150772067, 0.0415550574071756125],\n [0.0556300796969936084, -0.203976958888976564, 1.05697151424287856]]\n\n mat_srgb_to_xyz = [\n [0.412390799265959481, 0.357584339383877964, 0.180480788401834288],\n [0.212639005871510358, 0.715168678767755927, 0.072192315360733715],\n [0.0193308187155918507, 0.119194779794625988, 0.950532152249660581]]\n\n mat_srgb_to_acescg = [\n [ 0.6130974024, 0.3395231462, 0.04737945141],\n [ 0.07019372247, 0.916353879, 0.01345239847],\n [ 0.02061559288, 0.1095697729, 0.8698146341]]\n\n # NOTE: Includes \"D60\"/D65 white point conversion\n mat_acescg_to_srgb = [\n [ 1.705050993, -0.6217921206,-0.083258872],\n [-0.1302564175, 1.140804737, -0.01054831907],\n [-0.02400335681,-0.1289689761, 1.152972333]]\n\n # NOTE: Includes \"D60\"/D65 white point conversion\n mat_srgb_to_aces2065_1 = [\n [ 0.439632982, 0.382988698, 0.17737832],\n [ 0.0897764431, 0.813439429, 0.0967841284],\n [ 0.0175411704, 0.111546553, 0.870912277]]\n\n mat_aces2065_1_to_srgb = [\n [ 2.52168619, -1.13413099, -0.387555198],\n [-0.276479914, 1.37271909, -0.0962391736],\n [-0.015378065, -0.152975336, 1.1683534]]\n\n mat_srgb_to_displayp3 = [\n [ 0.822461969, 0.177538031, 1.15772692e-10],\n [ 0.0331941989, 0.966805801, 1.95085037e-11],\n [ 0.0170826307, 0.0723974405, 0.910519929]]\n\n mat_displayp3_to_srgb = [\n [ 1.22494018, -0.224940176, -4.77534979e-11],\n [-0.0420569547, 1.04205695, 3.37864801e-11],\n [-0.0196375546,-0.0786360454, 1.0982736]] \n\n # NOTE: No chromatic adaptation\n mat_srgb_to_dcip3 = [\n [0.868579739716132409, 0.128919138460847047, 0.00250112182302054368],\n [0.0345404102543194426, 0.961811386361919975, 0.0036482033837605824],\n [0.0167714290414502718, 0.0710399977868858352, 0.912188573171663893]]\n\n # NOTE: No chromatic adaptation\n mat_dcip3_to_srgb = [\n [ 1.15751640619975871, -0.154962378073857756, -0.00255402812590095854],\n [-0.0415000715306859699, 1.04556792307969925, -0.00406785154901328463],\n [-0.0180500389562539583,-0.0785782726530290654, 1.09662831160928302]]\n\n # NOTE: No chromatic adaptation\n mat_dcip3_to_xyz = [\n [ 0.445169815564552417, 0.277134409206777664, 0.172282669815564564],\n [ 0.209491677912730539, 0.721595254161043636, 0.0689130679262258258],\n [-3.63410131696985616e-17, 0.0470605600539811521, 0.907355394361973415]]\n\n # NOTE: No chromatic adaptation\n mat_xyz_to_dcip3 = [\n [2.7253940304917328, -1.01800300622718496, -0.440163195190036463],\n [-0.795168025808764195, 1.689732054843624, 0.0226471906084774533],\n [0.0412418913957000325, -0.0876390192158623825, 1.10092937864632191]]\n\n mat_srgb_to_rec2020 = [\n [ 0.627403896, 0.329283039, 0.0433130657],\n [ 0.0690972894, 0.919540395, 0.0113623156],\n [ 0.0163914389, 0.0880133077, 0.895595253]]\n\n mat_rec2020_to_srgb = [\n [ 1.660491, -0.587641139,-0.0728498633],\n [-0.124550475, 1.1328999, -0.00834942258],\n [-0.0181507633,-0.100578898, 1.11872966]]\n\n mat_rec2020_to_xyz = [\n [0.636958048301291, 0.144616903586208, 0.168880975164172],\n [0.262700212011267, 0.677998071518871, 0.059301716469862],\n [4.99410657446607e-17, 0.0280726930490874, 1.06098505771079]]\n\n mat_xyz_to_rec2020 = [\n [1.71665118797127, -0.355670783776393, -0.25336628137366],\n [-0.666684351832489, 1.61648123663494, 0.0157685458139111],\n [0.0176398574453108, -0.0427706132578085, 0.942103121235474]]\n\n # NOTE: No chromatic adaptation\n mat_acescg_to_xyz = [\n [ 0.66245418, 0.13400421, 0.15618769],\n [ 0.27222872, 0.67408177, 0.05368952],\n [-0.00557465, 0.00406073, 1.0103391 ]]\n\n # NOTE: No chromatic adaptation\n mat_xyz_to_acescg = [\n [ 1.64102338, -0.32480329, -0.2364247 ],\n [-0.66366286, 1.61533159, 0.01675635],\n [ 0.01172189, -0.00828444, 0.98839486]]\n\n # NOTE: For CIE XYZ color\n mat_d60_to_d65 = [\n [ 0.98722400,-0.00611327, 0.01595330],\n [-0.00759836, 1.00186000, 0.00533002],\n [ 0.00307257,-0.00509595, 1.08168000]]\n\n # NOTE: For CIE XYZ color\n mat_d65_to_d60 = [\n [ 1.01303000, 0.00610531,-0.01497100],\n [ 0.00769823, 0.99816500,-0.00503203],\n [-0.00284131, 0.00468516, 0.92450700]]\n\n # NOTE: For CIE XYZ color\n mat_d65_to_dci = [\n [0.976578896646979768, -0.0154362646984919742, -0.016686021704209866],\n [-0.0256896658505145926, 1.02853916787996963, -0.00378517365630504153],\n [-0.00570574587417104179, 0.0110778657389971485, 0.871176159390377409]]\n \n # NOTE: For CIE XYZ color\n mat_dci_to_d65 = [\n [1.02449672775257752, 0.0151635410224165156, 0.0196885223342066827],\n [0.0256121933371584198, 0.97258630562441342, 0.00471635229242730096],\n [0.0063842306500876874, -0.012268082736730219, 1.14794244517367791]]\n\n mat_xyz_to_lms = [\n [ 0.8951, 0.2664,-0.1614],\n [-0.7502, 1.7135, 0.0367],\n [ 0.0389,-0.0685, 1.0296]]\n\n mat_lms_to_xyz = [\n [ 0.986993, -0.147054, 0.159963],\n [ 0.432305, 0.51836, 0.0492912],\n [ -0.00852866, 0.0400428, 0.968487]]\n\n # OKLAB's XYZ to LMS\n mat_oklab_m1 = [\n [ 0.8189330101, 0.3618667424, -0.1288597137],\n [ 0.0329845436, 0.9293118715, 0.0361456387],\n [ 0.0482003018, 0.2643662691, 0.6338517070]]\n\n # OKLAB's non-linear L'M'S' to OKLAB\n mat_oklab_m2 = [\n [ 0.2104542553, 0.7936177850, -0.0040720468],\n [ 1.9779984951, -2.4285922050, 0.4505937099],\n [ 0.0259040371, 0.7827717662, -0.8086757660]]\n\n # Inverse of OKLAB M1\n mat_oklab_m1_inv = [\n [ 1.22701385, -0.55779998, 0.28125615],\n [-0.04058018, 1.11225687, -0.07167668],\n [-0.07638128, -0.42148198, 1.58616322]]\n\n # Inverse of OKLAB M2\n mat_oklab_m2_inv = [\n [ 1. , 0.39633779, 0.21580376],\n [ 1.00000001, -0.10556134, -0.06385417],\n [ 1.00000005, -0.08948418, -1.29148554]]\n\n @classmethod\n def convert(cls, im:Union[torch.Tensor, ColorImage], source:Variant, destination:Variant) -> torch.Tensor:\n \"\"\"\n Change the color space of an image. Cylindrical transformations HSV/HSL are \n treated as their own color spaces and assumed to be relative to sRGB linear. \n Unless otherwise noted or required by specification (e.g. ACES), we assume D65 white point.\n\n .. warning::\n\n Tone mapping is not included, so converting the color space of HDR values to \n an LDR-designated color space will not automatically reduce dynamic range. For example, \n taking an HDR image from :code:`ACESCG` (AP1) to :code:`SRGB` will yield the sRGB \n gamma curve, but values outside the required range must still be tone mapped or clamped beforehand.\n\n .. warning::\n\n Cylindrical transformations (HSL, HSV) should be given input in [0, 1] linear sRGB range \n (or equivalent). This is not strictly enforced but input outside this range may yield \n unpredictable results or *NaN* values.\n\n :param im: [C=3, H, W] image tensor \n :type im: torch.Tensor | ColorImage\n :param source: color space to convert from\n :param destination: color space to convert to\n :return: image tensor in designated color space\n \"\"\"\n ip, op = source, destination\n cs = cls.Variant\n tf = TransferFunction\n if ip == op: return im\n\n assert im.dim() == 3 and im.size(0) == 3, f\"expected [C=3, H, W] image tensor, got {im.size()}\"\n assert source != 0, f\"Unknown source color space\"\n assert ip & cs.SUPPORTED, f\"Source color space not supported: {source.name}\"\n assert op & cs.SUPPORTED, f\"Destination color space not supported: {destination.name}\"\n assert ip & ~cs.DISABLED, f\"Source color space disabled: {ColorSpace.Variant(ip).name}\"\n assert op & ~cs.DISABLED, f\"Destination color space disabled: {ColorSpace.Variant(op).name}\"\n\n err_not_implemented = f\"Color space conversion not implemented: {ColorSpace.Variant(ip).name} to {ColorSpace.Variant(op).name}\" \n\n # Direct path where it matters, loop-de-loop elsewhere\n if ip == cs.SRGB_LIN:\n if op == cs.SRGB: im = tf.srgb_oetf(im)\n elif op == cs.REC709: im = tf.rec709_oetf(im)\n elif op == cs.REC2020: im = tf.rec2020_oetf(mm(im, cls.mat_srgb_to_rec2020))\n elif op == cs.REC2020_LIN: im = mm(im, cls.mat_srgb_to_rec2020)\n elif op == cs.DCI_P3: im = tf.dcip3_oetf(mm(mm(mm(im, cls.mat_srgb_to_xyz), cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3))\n elif op == cs.DCI_P3_LIN: im = mm(mm(mm(im, cls.mat_srgb_to_xyz), cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3)\n elif op == cs.DISPLAY_P3: im = tf.srgb_oetf(mm(im, cls.mat_srgb_to_displayp3))\n elif op == cs.CIE_XYZ: im = mm(im, cls.mat_srgb_to_xyz)\n elif op == cs.CIE_XYY: im = cls._xyz_to_xyy(mm(im, cls.mat_srgb_to_xyz))\n elif op == cs.LMS: im = cls._xyz_to_lms(mm(im, cls.mat_srgb_to_xyz))\n elif op == cs.ACESCG: im = mm(im, cls.mat_srgb_to_acescg)\n elif op == cs.ACESCC: im = cls._acescg_to_acescc(mm(im, cls.mat_srgb_to_acescg))\n elif op == cs.ACES2065_1: im = mm(im, cls.mat_srgb_to_aces2065_1)\n elif op == cs.CIELAB: im = cls._xyz_to_cielab(mm(im, cls.mat_srgb_to_xyz))\n elif op == cs.CIELUV: im = cls._xyz_to_cieluv(mm(im, cls.mat_srgb_to_xyz))\n elif op == cs.OKLAB: im = cls._rgb_to_oklab(im)\n elif op == cs.HSL: im = cls._rgb_to_hsl(tf.srgb_oetf(im))\n elif op == cs.HSV: im = cls._rgb_to_hsv(tf.srgb_oetf(im))\n else: raise Exception(err_not_implemented)\n elif ip == cs.SRGB:\n if op == cs.HSL: im = cls._rgb_to_hsl(im)\n elif op == cs.HSV: im = cls._rgb_to_hsv(im)\n else: im = cls.convert(tf.srgb_eotf(im), cs.SRGB_LIN, op)\n elif ip == cs.REC709: im = cls.convert(tf.rec709_eotf(im), cs.SRGB_LIN, op)\n elif ip == cs.REC2020: \n if op == cs.REC2020_LIN: im = tf.rec2020_eotf(im)\n elif op == cs.CIE_XYZ: im = mm(tf.rec2020_eotf(im), cls.mat_rec2020_to_xyz)\n elif op == cs.SRGB_LIN: im = mm(tf.rec2020_eotf(im), cls.mat_rec2020_to_srgb)\n else: im = cls.convert(mm(tf.rec2020_eotf(im), cls.mat_rec2020_to_srgb), cs.SRGB_LIN, op)\n elif ip == cs.REC2020_LIN: \n if op == cs.REC2020: im = tf.rec2020_oetf(im)\n elif op == cs.CIE_XYZ: im = mm(im, cls.mat_rec2020_to_xyz)\n elif op == cs.SRGB_LIN: im = mm(im, cls.mat_rec2020_to_srgb)\n else: im = cls.convert(mm(im, cls.mat_rec2020_to_srgb), cs.SRGB_LIN, op)\n elif ip == cs.DCI_P3: \n if op == cs.DCI_P3_LIN: im = tf.dcip3_eotf(im)\n elif op == cs.CIE_XYZ: im = mm(mm(tf.dcip3_eotf(im), cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65)\n else: im = cls.convert(mm(mm(tf.dcip3_eotf(im), cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65), cs.CIE_XYZ, op)\n elif ip == cs.DCI_P3_LIN: \n if op == cs.DCI_P3: im = tf.dcip3_oetf(im)\n elif op == cs.CIE_XYZ: im = mm(mm(im, cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65)\n else: im = cls.convert(mm(mm(im, cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65), cs.CIE_XYZ, op)\n elif ip == cs.DISPLAY_P3: im = cls.convert(mm(tf.srgb_eotf(im), cls.mat_displayp3_to_srgb), cs.SRGB_LIN, op)\n elif ip == cs.CIE_XYZ:\n if op == cs.CIE_XYY: im = cls._xyz_to_xyy(im)\n elif op == cs.REC2020_LIN: im = mm(im, cls.mat_xyz_to_rec2020)\n elif op == cs.REC2020: im = tf.rec2020_oetf(mm(im, cls.mat_xyz_to_rec2020))\n elif op == cs.DCI_P3_LIN: im = mm(mm(im, cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3)\n elif op == cs.DCI_P3: im = tf.dcip3_oetf(mm(mm(im, cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3))\n elif op == cs.LMS: im = cls._xyz_to_lms(im)\n elif op == cs.ACESCG: im = mm(cls._d65_to_d60(im), cls.mat_xyz_to_acescg)\n elif op == cs.CIELAB: im = cls._xyz_to_cielab(im)\n elif op == cs.CIELUV: im = cls._xyz_to_cieluv(im)\n elif op == cs.OKLAB: im = cls._xyz_to_oklab(im)\n else: im = cls.convert(mm(im, cls.mat_xyz_to_srgb), cs.SRGB_LIN, op)\n elif ip == cs.CIE_XYY: \n if op == cs.CIE_XYZ: im = cls._xyy_to_xyz(im)\n else: im = cls.convert(cls._xyy_to_xyz(im), cs.CIE_XYZ, op)\n elif ip == cs.LMS: \n if op == cs.CIE_XYZ: im = cls._lms_to_xyz(im)\n else: im = cls.convert(cls._lms_to_xyz(im), cs.CIE_XYZ, op)\n elif ip == cs.ACESCG:\n # if op == cs.CIE_XYZ: im = cls._d60_to_d65(mm(im, cls.mat_acescg_to_xyz)) # FIXME: fails unit test (?)\n if op == cs.ACESCC: im = cls._acescg_to_acescc(im)\n else: im = cls.convert(mm(im, cls.mat_acescg_to_srgb), cs.SRGB_LIN, op)\n elif ip == cs.ACESCC:\n if op == cs.ACESCG: im = cls._acescc_to_acescg(im)\n else: im = cls.convert(cls._acescc_to_acescg(im), cs.ACESCG, op)\n elif ip == cs.ACES2065_1: im = cls.convert(mm(im, cls.mat_aces2065_1_to_srgb), cs.SRGB_LIN, op)\n elif ip == cs.HSL:\n if op == cs.SRGB: im = cls._hsl_to_rgb(im)\n else: im = cls.convert(tf.srgb_eotf(cls._hsl_to_rgb(im)), cs.SRGB_LIN, op)\n elif ip == cs.HSV:\n if op == cs.SRGB: im = cls._hsv_to_rgb(im)\n else: im = cls.convert(tf.srgb_eotf(cls._hsv_to_rgb(im)), cs.SRGB_LIN, op)\n elif ip == cs.CIELAB: im = cls.convert(cls._cielab_to_xyz(im), cs.CIE_XYZ, op)\n elif ip == cs.CIELUV: im = cls.convert(cls._cieluv_to_xyz(im), cs.CIE_XYZ, op)\n elif ip == cs.OKLAB:\n if op == cs.CIE_XYZ: im = cls._oklab_to_xyz(im)\n else: im = cls.convert(cls._oklab_to_rgb(im), cs.SRGB_LIN, op)\n else: raise Exception(err_not_implemented)\n\n return im\n\n @classmethod\n def _xyz_to_xyy(cls, xyz:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert CIE XYZ color space to CIE xyY color space.\n\n :param xyz: Input CIE XYZ color space tensor\n :return: CIE xyY color space tensor\n \"\"\"\n X = xyz[0:1]\n Y = xyz[1:2]\n Z = xyz[2:3]\n x = X / (X + Y + Z)\n y = Y / (X + Y + Z)\n return torch.cat([x, y, Y], dim=0)\n\n @classmethod\n def _xyy_to_xyz(cls, xyy:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert CIE xyY color space to CIE XYZ color space.\n\n :param xyy: Input CIE xyY color space tensor\n :return: CIE XYZ color space tensor\n \"\"\"\n x = xyy[0:1]\n y = xyy[1:2]\n Y = xyy[2:3]\n X = (Y / y) * x\n Z = (Y / y) * (1. - x - y)\n return torch.cat([X, Y, Z], dim=0)\n\n @classmethod\n def _xyz_to_lms(cls, xyz:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert CIE XYZ color space to LMS color space.\n\n :param xyz: Input CIE XYZ color space tensor\n :return: LMS color space tensor\n \"\"\"\n return mm(xyz, cls.mat_xyz_to_lms)\n\n @classmethod\n def _lms_to_xyz(cls, lms:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert LMS color space to CIE XYZ color space.\n\n :param lms: Input LMS color space tensor\n :return: CIE XYZ color space tensor\n \"\"\"\n return mm(lms, cls.mat_lms_to_xyz)\n\n @classmethod\n def _acescg_to_acescc(cls, cg:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert scene-linear ACEScg to log ACEScc.\n\n :param lms: Input ACEScg color space tensor\n :return: ACEScc color space tensor\n \"\"\"\n res = torch.where(cg < 0.00003051757, \n (torch.log2(0.00001525878 + cg * 0.5) + 9.72) / 17.52, \n (torch.log2(cg) + 9.72) / 17.52)\n return res\n\n @classmethod\n def _acescc_to_acescg(cls, cc:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert log ACEScc to scene-linear ACEScg.\n\n :param lms: Input ACEScc color space tensor\n :return: ACEScg color space tensor\n \"\"\"\n res = torch.where(cc < -0.3013698630, \n (torch.exp2(cc * 17.52 - 9.72) - 0.00001525878) * 2,\n torch.exp2(cc * 17.52 - 9.72))\n return res\n\n @classmethod\n def _xyz_to_oklab(cls, xyz:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert CIE XYZ color space to OKLAB color space.\n\n :param xyz: Input CIE XYZ color space tensor\n :return: OKLAB color space tensor\n \"\"\" \n lms = mm(xyz, cls.mat_oklab_m1)\n lms_p = torch.pow(torch.abs(lms), 0.3333333333) * torch.sign(lms).float()\n lab = mm(lms_p, cls.mat_oklab_m2)\n return lab\n\n @classmethod\n def _oklab_to_xyz(cls, lab:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert OKLAB color space to CIE XYZ color space.\n\n :param lab: Input OKLAB color space tensor\n :return: CIE XYZ color space tensor\n \"\"\"\n lms_p = mm(lab, cls.mat_oklab_m2_inv)\n lms = torch.pow(lms_p, 3.)\n xyz = mm(lms, cls.mat_oklab_m1_inv)\n return xyz\n\n\n @classmethod\n def __pivot_xyz_to_lab(cls, val): \n return torch.where(val > 0.008856, torch.pow(val, 0.3333333333), ((val * 903.3) + 16.0) / 116.0)\n\n @classmethod\n def _xyz_to_cielab(cls, xyz:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert color space from CIE XYZ to CIELAB.\n\n :param xyz: Input CIE XYZ color space tensor\n :return: CIELAB color space tensor\n \"\"\"\n # https://github.com/CairX/convert-colors-py/blob/master/convcolors/__init__.py\n # MIT License\n\n # Copyright (c) 2022 Thomas Cairns\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE. \n x = xyz[0:1] / 0.95047 \n y = xyz[1:2] / 1.00000 \n z = xyz[2:3] / 1.08883 \n\n x = cls.__pivot_xyz_to_lab(x)\n y = cls.__pivot_xyz_to_lab(y)\n z = cls.__pivot_xyz_to_lab(z)\n\n l = torch.maximum(torch.zeros_like(y).to(y.device), (116.0 * y) - 16.0)\n a = (x - y) * 500.0\n b = (y - z) * 200.0\n return torch.cat([l, a, b], dim=0)\n\n @classmethod\n def _cielab_to_xyz(cls, lab:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert color space from CIELAB to CIE XYZ.\n \n .. note::\n\n Assumes D65 standard illuminant.\n\n :param lab: Input CIELAB color space tensor\n :return: CIE XYZ color space tensor\n \"\"\"\n # https://github.com/CairX/convert-colors-py/blob/master/convcolors/__init__.py\n # MIT License\n\n # Copyright (c) 2022 Thomas Cairns\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n l = lab[0:1]\n a = lab[1:2]\n b = lab[2:3]\n\n # Reminder: The y values is calculated first as it can be reused\n # for the calculation of x and z.\n y = (l + 16.0) / 116.0\n x = y + (a / 500.0)\n z = y - (b / 200.0)\n\n x3 = x * x * x\n z3 = z * z * z\n y3 = y * y * y\n\n x = torch.where(x3 > 0.008856, x3, ((x * 116.0) - 16.0) / 903.3)\n y = torch.where(l > 7.9996248, y3, l / 903.3)\n z = torch.where(z3 > 0.008856, z3, ((z * 116.0) - 16.0) / 903.3)\n\n x = x * 0.95047 \n y = y * 1.00000 \n z = z * 1.08883\n\n return torch.cat([x, y, z], dim=0)\n\n def _xyz_to_cieluv(image:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Converts CIE XYZ to CIELUV. \n \n .. note::\n\n Assumes D65 standard illuminant.\n\n :param image: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are X, Y, Z\n :return: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are L, U, V\n \"\"\"\n # https://github.com/stefanLeong/S2CRNet/blob/main/scripts/utils/color.py\n # MIT License\n\n # Copyright (c) 2021 StefanLeong\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n if len(image.size()) == 3:\n small_L = (29. / 3) ** 3 * image[1]\n large_L = 116 * torch.pow(image[1], 1 / 3.) - 16\n L = torch.where(image[1] <= (6. / 29) ** 3, small_L, large_L)\n\n denom = (image[0] + 15 * image[1] + 3 * image[2])\n u_prime = torch.where(denom != 0., 4 * image[0] / denom, 0.)\n v_prime = torch.where(denom != 0., 9 * image[1] / denom, 0.)\n d = 0\n elif len(image.size()) == 4:\n small_L = (29. / 3) ** 3 * image[:, 1]\n large_L = 116 * torch.pow(image[:, 1], 1 / 3.) - 16\n L = torch.where(image[:, 1] <= (6. / 29) ** 3, small_L, large_L)\n\n denom = (image[:, 0] + 15 * image[:, 1] + 3 * image[:, 2])\n u_prime = torch.where(denom > 0., 4 * image[:, 0] / denom, 0.)\n v_prime = torch.where(denom > 0., 9 * image[:, 1] / denom, 0.)\n d = 1\n\n u = 13 * L * (u_prime - .2009)\n v = 13 * L * (v_prime - .4610)\n\n luv_image = torch.stack((L, u, v), dim=d)\n\n return luv_image\n\n def _cieluv_to_xyz(image:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Converts CIELUV to CIE XYZ. \n \n .. note::\n\n Assumes D65 standard illuminant.\n\n :param image: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are L, U, V\n :return: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are X, Y, Z\n \"\"\"\n # https://github.com/stefanLeong/S2CRNet/blob/main/scripts/utils/color.py\n # MIT License\n\n # Copyright (c) 2021 StefanLeong\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n if len(image.size()) == 3:\n denom = (13 * image[0])\n u_prime = torch.where(denom != 0., image[1] / denom, 0.) + .2009\n v_prime = torch.where(denom != 0., image[2] / denom, 0.) + .4610\n\n small_Y = image[0] * (3. / 29) ** 3\n large_Y = ((image[0] + 16.) / 116.) ** 3\n\n Y = torch.where(image[0] <= 8, small_Y, large_Y)\n d = 0\n # batch of images\n elif len(image.size()) == 4:\n denom = (13 * image[:, 0])\n u_prime = torch.where(denom != 0., image[:, 1] / denom, 0.) + .2009\n v_prime = torch.where(denom != 0., image[:, 2] / denom, 0.) + .4610\n\n small_Y = image[:, 0] * (3. / 29) ** 3\n large_Y = ((image[:, 0] + 16.) / 116.) ** 3\n\n Y = torch.where(image[:, 0] <= 8, small_Y, large_Y)\n d = 1\n\n X = torch.where(v_prime != 0., Y * 9 * u_prime / (4 * v_prime), 0.)\n Z = torch.where(v_prime != 0., Y * (12 - 3 * u_prime - 20 * v_prime) / (4 * v_prime), 0.)\n\n xyz_image = torch.stack((X, Y, Z), dim=d)\n\n return xyz_image\n\n @classmethod\n def _rgb_to_oklab(cls, rgb:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert color space from linear sRGB to OKLAB.\n\n :param rgb: Input linear sRGB color space tensor\n :return: OKLAB color space tensor\n \"\"\"\n cr = rgb[0:1]\n cg = rgb[1:2]\n cb = rgb[2:3]\n\n l = 0.4122214708 * cr + 0.5363325363 * cg + 0.0514459929 * cb;\n m = 0.2119034982 * cr + 0.6806995451 * cg + 0.1073969566 * cb;\n s = 0.0883024619 * cr + 0.2817188376 * cg + 0.6299787005 * cb;\n\n l_ = torch.pow(torch.abs(l), 0.3333333333) * torch.sign(l).float()\n m_ = torch.pow(torch.abs(m), 0.3333333333) * torch.sign(m).float()\n s_ = torch.pow(torch.abs(s), 0.3333333333) * torch.sign(s).float()\n\n return torch.cat([\n 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_,\n 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_,\n 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_], dim=0)\n\n @classmethod\n def _oklab_to_rgb(cls, lab:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert color space from OKLAB to linear sRGB.\n\n :param lab: Input OKLAB color space tensor\n :return: Linear sRGB color space tensor\n \"\"\"\n cl = lab[0:1]\n ca = lab[1:2]\n cb = lab[2:3]\n\n l_ = cl + 0.3963377774 * ca + 0.2158037573 * cb\n m_ = cl - 0.1055613458 * ca - 0.0638541728 * cb\n s_ = cl - 0.0894841775 * ca - 1.2914855480 * cb\n\n l = l_*l_*l_\n m = m_*m_*m_\n s = s_*s_*s_\n\n return torch.cat([\n +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,\n -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,\n -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s], dim=0)\n\n @classmethod\n def _rgb_to_hsl(cls, rgb: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Transform sRGB image tensor to sRGB-relative HSL. \n \n .. note::\n\n expects non-linear sRGB w/ gamma curve as input\n\n :param rgb: Input sRGB image tensor\n :return: HSL image tensor\n \"\"\"\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\n # MIT License\n\n # Copyright (c) 2022 hawkey\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n rgb = rgb.unsqueeze(0)\n cmax, cmax_idx = torch.max(rgb, dim=1, keepdim=True)\n cmin = torch.min(rgb, dim=1, keepdim=True)[0]\n delta = cmax - cmin\n hsl_h = torch.empty_like(rgb[:, 0:1, :, :])\n cmax_idx[delta == 0] = 3\n hsl_h[cmax_idx == 0] = (((rgb[:, 1:2] - rgb[:, 2:3]) / delta) % 6)[cmax_idx == 0]\n hsl_h[cmax_idx == 1] = (((rgb[:, 2:3] - rgb[:, 0:1]) / delta) + 2)[cmax_idx == 1]\n hsl_h[cmax_idx == 2] = (((rgb[:, 0:1] - rgb[:, 1:2]) / delta) + 4)[cmax_idx == 2]\n hsl_h[cmax_idx == 3] = 0.\n hsl_h /= 6.\n\n hsl_l = (cmax + cmin) / 2.\n hsl_s = torch.empty_like(hsl_h)\n hsl_s[hsl_l == 0] = 0\n hsl_s[hsl_l == 1] = 0\n hsl_l_ma = torch.bitwise_and(hsl_l > 0, hsl_l < 1)\n hsl_l_s0_5 = torch.bitwise_and(hsl_l_ma, hsl_l <= 0.5)\n hsl_l_l0_5 = torch.bitwise_and(hsl_l_ma, hsl_l > 0.5)\n hsl_s[hsl_l_s0_5] = ((cmax - cmin) / (hsl_l * 2.))[hsl_l_s0_5]\n hsl_s[hsl_l_l0_5] = ((cmax - cmin) / (- hsl_l * 2. + 2.))[hsl_l_l0_5]\n return torch.cat([hsl_h, hsl_s, hsl_l], dim=1).squeeze(0)\n\n @classmethod\n def _hsl_to_rgb(cls, hsl: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Transform sRGB-relative HSL image tensor to sRGB. \n \n .. note::\n\n returns non-linear sRGB w/ gamma curve as output\n\n :param hsl: Input HSL image tensor\n :return: sRGB image tensor\n \"\"\"\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\n # MIT License\n\n # Copyright (c) 2022 hawkey\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n hsl = hsl.unsqueeze(0)\n hsl_h, hsl_s, hsl_l = hsl[:, 0:1], hsl[:, 1:2], hsl[:, 2:3]\n _c = (-torch.abs(hsl_l * 2. - 1.) + 1) * hsl_s\n _x = _c * (-torch.abs(hsl_h * 6. % 2. - 1) + 1.)\n _m = hsl_l - _c / 2.\n idx = (hsl_h * 6.).type(torch.uint8)\n idx = (idx % 6).expand(-1, 3, -1, -1)\n rgb = torch.empty_like(hsl).to(hsl.device)\n _o = torch.zeros_like(_c).to(hsl.device)\n rgb[idx == 0] = torch.cat([_c, _x, _o], dim=1)[idx == 0]\n rgb[idx == 1] = torch.cat([_x, _c, _o], dim=1)[idx == 1]\n rgb[idx == 2] = torch.cat([_o, _c, _x], dim=1)[idx == 2]\n rgb[idx == 3] = torch.cat([_o, _x, _c], dim=1)[idx == 3]\n rgb[idx == 4] = torch.cat([_x, _o, _c], dim=1)[idx == 4]\n rgb[idx == 5] = torch.cat([_c, _o, _x], dim=1)[idx == 5]\n rgb += _m\n return rgb.squeeze(0)\n\n @classmethod\n def _rgb_to_hsv(cls, rgb: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Transform sRGB image tensor to sRGB-relative HSV. \n \n .. note::\n\n expects non-linear sRGB w/ gamma curve as input\n\n .. warning::\n\n input tensor will be clamped to [0, 1] range\n\n :param rgb: Input sRGB image tensor\n :return: HSV image tensor\n \"\"\"\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\n # MIT License\n\n # Copyright (c) 2022 hawkey\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n rgb = rgb.clamp(0.,1.).unsqueeze(0)\n cmax, cmax_idx = torch.max(rgb, dim=1, keepdim=True)\n cmin = torch.min(rgb, dim=1, keepdim=True)[0]\n delta = cmax - cmin\n hsv_h = torch.empty_like(rgb[:, 0:1, :, :])\n cmax_idx[delta == 0] = 3\n hsv_h[cmax_idx == 0] = (((rgb[:, 1:2] - rgb[:, 2:3]) / delta) % 6)[cmax_idx == 0]\n hsv_h[cmax_idx == 1] = (((rgb[:, 2:3] - rgb[:, 0:1]) / delta) + 2)[cmax_idx == 1]\n hsv_h[cmax_idx == 2] = (((rgb[:, 0:1] - rgb[:, 1:2]) / delta) + 4)[cmax_idx == 2]\n hsv_h[cmax_idx == 3] = 0.\n hsv_h /= 6.\n hsv_s = torch.where(cmax == 0, torch.tensor(0.).type_as(rgb), delta / cmax)\n hsv_v = cmax\n return torch.cat([hsv_h, hsv_s, hsv_v], dim=1).squeeze(0)\n\n @classmethod\n def _hsv_to_rgb(cls, hsv: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Transform sRGB-relative HSV image tensor to sRGB. \n \n .. note::\n \n returns non-linear sRGB w/ gamma curve as output\n\n :param hsv: Input HSV image tensor\n :return: sRGB image tensor\n \"\"\"\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\n # MIT License\n\n # Copyright (c) 2022 hawkey\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in all\n # copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n # SOFTWARE.\n hsv = hsv.unsqueeze(0)\n hsv_h, hsv_s, hsv_l = hsv[:, 0:1], hsv[:, 1:2], hsv[:, 2:3]\n _c = hsv_l * hsv_s\n _x = _c * (- torch.abs(hsv_h * 6. % 2. - 1) + 1.)\n _m = hsv_l - _c\n _o = torch.zeros_like(_c).to(hsv.device)\n idx = (hsv_h * 6.).type(torch.uint8)\n idx = (idx % 6).expand(-1, 3, -1, -1)\n rgb = torch.empty_like(hsv).to(hsv.device)\n rgb[idx == 0] = torch.cat([_c, _x, _o], dim=1)[idx == 0]\n rgb[idx == 1] = torch.cat([_x, _c, _o], dim=1)[idx == 1]\n rgb[idx == 2] = torch.cat([_o, _c, _x], dim=1)[idx == 2]\n rgb[idx == 3] = torch.cat([_o, _x, _c], dim=1)[idx == 3]\n rgb[idx == 4] = torch.cat([_x, _o, _c], dim=1)[idx == 4]\n rgb[idx == 5] = torch.cat([_c, _o, _x], dim=1)[idx == 5]\n rgb += _m\n return rgb.squeeze(0)\n\n @classmethod\n def _d60_to_d65(cls, im:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert CIE XYZ image from \"D60\" to D65 white point.\n\n :param im: Input image tensor\n :return: Converted image tensor\n \"\"\"\n # There is not really a CIE D60 white point, but that's what everyone calls what ACES uses.\n return mm(im, cls.mat_d60_to_d65)\n\n @classmethod\n def _d65_to_d60(cls, im:torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert CIE XYZ image from D65 to \"D60\" white point.\n\n :param torch.Tensor im: Input image tensor\n :return: Converted image tensor\n \"\"\"\n return mm(im, cls.mat_d65_to_d60)"},{"identifier":"load_lut","path":"src/tinycio/fsio/lutfile.py","snippet":"def load_lut(fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN) -> torch.Tensor:\n \"\"\"\n Load LUT from file.\n\n :param fp: File path to load from.\n :param lut_format: Format of the LUT.\n :return: lattice as PyTorch tensor\n \"\"\"\n fp = os.path.realpath(fp)\n fn, fnext = os.path.splitext(fp)\n if lut_format == LUTFormat.UNKNOWN: lut_format = _infer_lut_file_format(fnext)\n assert lut_format > LUTFormat.UNKNOWN, \"Unrecognized LUT format\"\n lattice = None\n if lut_format == LUTFormat.CUBE_3D:\n with open(fp, 'r') as file:\n # Read lines and filter out comments\n lines = [line.strip() for line in file.readlines() if len(line) > 0 and \"#\" not in line]\n\n # Find the line indicating the start of the LUT data\n lut_start_index = next((i for i, line in enumerate(lines) if line.startswith('LUT_3D_SIZE')), None)\n\n if lut_start_index is None: raise ValueError(\"LUT_3D_SIZE indicator not found in the .cube file.\")\n\n # Extract LUT data\n lut_data = [list(map(float, line.split())) for line in lines[lut_start_index + 1:] \\\n if len(line) > 0 and len(line.split()) == 3 and \"#\" not in line] \n\n # Convert the LUT data to a PyTorch tensor\n lut_size = int(lines[lut_start_index].split()[1])\n\n lattice = torch.tensor(lut_data).view(lut_size, lut_size, lut_size, 3).permute(2,1,0,3)\n else:\n raise Exception(\"Unsupported LUT format\")\n return lattice"},{"identifier":"save_lut","path":"src/tinycio/fsio/lutfile.py","snippet":"def save_lut(lattice:torch.Tensor, fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN) -> bool:\n \"\"\"\n Save LUT to a file.\n\n .. warning:: \n \n This will overwrite existing files.\n\n :param lattice: PyTorch tensor representing the LUT.\n :param fp: File path for saving the LUT.\n :param lut_format: Format of the LUT.\n :return: True if successful\n \"\"\"\n fp = os.path.realpath(fp)\n fn, fnext = os.path.splitext(fp)\n\n if lut_format == LUTFormat.UNKNOWN: lut_format = _infer_lut_file_format(fnext)\n\n if lut_format == LUTFormat.CUBE_3D:\n # Convert the torch tensor to a list of lists\n lut_data_list = lattice.permute(2,1,0,3).reshape(-1, 3).tolist()\n\n # Write the LUT data to the file\n with open(fp, 'w') as file:\n file.write(f\"LUT_3D_SIZE {lattice.size(0)}\\n\")\n for entry in lut_data_list:\n file.write(\" \".join(map(str, entry)) + \"\\n\")\n\n else:\n raise Exception(\"Unsupported LUT format\")\n\n return True"},{"identifier":"_infer_lut_file_format","path":"src/tinycio/fsio/lutfile.py","snippet":"def _infer_lut_file_format(ext:str) -> LUTFormat:\n ext = ext.strip().lower()\n if ext == '.cube': return LUTFormat.CUBE_3D\n else: return LUTFormat.UNKNOWN"},{"identifier":"_generate_linear_cube_lut","path":"src/tinycio/fsio/lutfile.py","snippet":"def _generate_linear_cube_lut(size: int):\n \"\"\"\n Generate a baseline linear cube LUT.\n\n :param size: Size of the cube LUT (e.g., 33 for a 33x33x33 cube).\n :return: Torch tensor representing the linear cube LUT.\n \"\"\"\n linear_values = torch.linspace(0.0, 1.0, size)\n grid = torch.meshgrid(linear_values, linear_values, linear_values, indexing=\"xy\")\n lut_data = torch.stack(grid, dim=-1).permute(1,0,2,3) # TODO: WTF is even going on here?\n return lut_data"},{"identifier":"LUTFormat","path":"src/tinycio/fsio/format.py","snippet":"class LUTFormat(IntEnum):\n \"\"\"\n Lookup table format. Available options are:\n\n .. highlight:: text\n .. code-block:: text\n \n - UNKNOWN\n - CUBE_3D\n \"\"\"\n UNKNOWN = 1<<0 # no color space specified - flag for guessing\n CUBE_3D = 1<<1 # 3D CUBE LUT https://resolve.cafe/developers/luts/\n\n LUT_3D = CUBE_3D # | etc for later"},{"identifier":"srgb_luminance","path":"src/tinycio/util/colorutil.py","snippet":"def srgb_luminance(im_srgb:Union[torch.Tensor, ColorImage]) -> torch.Tensor:\n \"\"\"\n Return relative luminance of linear sRGB image.\n\n :param im_srgb: [C=3, H, W] color image tensor in sRGB color space\n :type im_srgb: torch.Tensor | ColorImage\n :return: [C=1, H, W] image tensor\n \"\"\"\n lum_r, lum_g, lum_b = 0.2126, 0.7152, 0.0722\n return lum_r * im_srgb[0:1,...] + lum_g * im_srgb[1:2,...] + lum_b * im_srgb[2:3,...]"},{"identifier":"trilinear_interpolation","path":"src/tinycio/util/miscutil.py","snippet":"def trilinear_interpolation(im_3d:torch.Tensor, indices:Union[ColorImage, torch.Tensor]) -> torch.Tensor:\n \"\"\"\n Interpolate 3D image tensor.\n\n :param im_3d: Input 3D image tensor of shape (C, D, H, W).\n :param indices: Indices into the tensor.\n :return: Interpolated color values.\n \"\"\"\n # NOTE: Internal - leaving this clutter undocumented intentionally\n indices_floor = indices.floor().to(torch.long)\n indices_ceil = indices.ceil().clamp(0, im_3d.size(0) - 1).to(torch.long)\n\n weights = (indices - indices_floor).float()\n\n c000 = im_3d[indices_floor[0], indices_floor[1], indices_floor[2]]\n c001 = im_3d[indices_floor[0], indices_floor[1], indices_ceil[2]]\n c010 = im_3d[indices_floor[0], indices_ceil[1], indices_floor[2]]\n c011 = im_3d[indices_floor[0], indices_ceil[1], indices_ceil[2]]\n c100 = im_3d[indices_ceil[0], indices_floor[1], indices_floor[2]]\n c101 = im_3d[indices_ceil[0], indices_floor[1], indices_ceil[2]]\n c110 = im_3d[indices_ceil[0], indices_ceil[1], indices_floor[2]]\n c111 = im_3d[indices_ceil[0], indices_ceil[1], indices_ceil[2]]\n\n interpolated_values = torch.zeros_like(c000).requires_grad_()\n interpolated_values = (\n (1 - weights[0]) * (1 - weights[1]) * (1 - weights[2]) * c000.permute(2,0,1) +\n (1 - weights[0]) * (1 - weights[1]) * weights[2] * c001.permute(2,0,1) +\n (1 - weights[0]) * weights[1] * (1 - weights[2]) * c010.permute(2,0,1) +\n (1 - weights[0]) * weights[1] * weights[2] * c011.permute(2,0,1) +\n weights[0] * (1 - weights[1]) * (1 - weights[2]) * c100.permute(2,0,1) +\n weights[0] * (1 - weights[1]) * weights[2] * c101.permute(2,0,1) +\n weights[0] * weights[1] * (1 - weights[2]) * c110.permute(2,0,1) +\n weights[0] * weights[1] * weights[2] * c111.permute(2,0,1)\n )\n\n return interpolated_values"},{"identifier":"feature_moments_calculation","path":"src/tinycio/loss.py","snippet":"def feature_moments_calculation(feat, eps=1e-5):\n # https://github.com/semchan/NLUT/blob/main/LICENSE\n # MIT License\n # <!-- Copyright (c) 2010, 2011 the Friendika Project -->\n # All rights reserved.\n\n # Permission is hereby granted, free of charge, to any person obtaining a copy\n # of this software and associated documentation files (the \"Software\"), to deal\n # in the Software without restriction, including without limitation the rights\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n # copies of the Software, and to permit persons to whom the Software is\n # furnished to do so, subject to the following conditions:\n\n # The above copyright notice and this permission notice shall be included in\n # all copies or substantial portions of the Software.\n\n # THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n # THE SOFTWARE\n size = feat.size()\n assert (len(size) == 3)\n N, C = size[:2]\n feat_var = feat.view(N, C, -1).var(dim=2) + eps\n # feat_std = feat_var.sqrt().view(N, C, 1, 1)\n # the first order\n feat_mean = feat.view(N, C, -1).mean(dim=2).view(N, C, 1)\n\n # the second order\n feat_size = 2\n # N, C = size[:2]\n feat_p2 = torch.abs(feat-feat_mean).pow(feat_size).view(N, C, -1)\n N, C,L = feat_p2.shape\n feat_p2 = feat_p2.sum(dim=2)/L\n feat_p2 = feat_p2.pow(1/feat_size).view(N, C, 1)\n # the third order\n feat_size = 3\n # N, C = size[:2]\n feat_p3 = torch.abs(feat-feat_mean).pow(feat_size).view(N, C, -1)\n # N, C,L = feat_p3.shape\n feat_p3 = feat_p3.sum(dim=2)/L\n feat_p3 = feat_p3.pow(1/feat_size).view(N, C, 1)\n\n return feat_mean.view(N, C) , feat_p2.view(N, C), feat_p3.view(N, C)"}],"string":"[\n {\n \"identifier\": \"ColorSpace\",\n \"path\": \"src/tinycio/colorspace.py\",\n \"snippet\": \"class ColorSpace:\\n \\\"\\\"\\\"\\n Color space conversion. Applies OETFs and EOTFs as needed but omits tonemapping. Cylindrical transformations are \\n treated as distinct color spaces. Example:\\n\\n .. highlight:: python\\n .. code-block:: python\\n \\n cs_in = ColorSpace.Variant.SRGB_LIN\\n cs_out = ColorSpace.Variant.OKLAB\\n oklab_image = ColorSpace.convert(srgb_image, source=cs_in, destination=cs_out)\\n \\\"\\\"\\\"\\n class Variant(IntEnum):\\n \\\"\\\"\\\"\\n Color space enum. For a list of available options, see :ref:`ref_color_spaces`.\\n \\\"\\\"\\\"\\n UNKNOWN = 1<<0 \\n NONCOLOR = 1<<1 \\n CIE_XYZ = 1<<2 \\n CIE_XYY = 1<<3 \\n SRGB = 1<<4 \\n SRGB_LIN = 1<<5 \\n REC709 = 1<<6 \\n REC2020 = 1<<7 \\n REC2020_LIN = 1<<8 \\n DCI_P3 = 1<<9 \\n DCI_P3_LIN = 1<<10 \\n DISPLAY_P3 = 1<<11 \\n ACESCG = 1<<12 \\n ACESCC = 1<<13 \\n ACESCCT = 1<<14 \\n ACES2065_1 = 1<<15 \\n LMS = 1<<16 \\n OKLAB = 1<<17 \\n CIELAB = 1<<18 \\n CIELUV = 1<<19 \\n HSV = 1<<20 \\n HSL = 1<<21 \\n OKHSV = 1<<22\\n OKHSL = 1<<23\\n\\n SCENE_LINEAR = SRGB_LIN | REC2020_LIN | DCI_P3_LIN | ACESCG | ACES2065_1 | CIE_XYZ\\n PERCEPTUAL = OKLAB | CIELAB | CIELUV | OKHSL | OKHSV\\n CYLINDRICAL = HSL | HSV | OKHSL | OKHSV\\n\\n GAMUT_SRGB = SRGB | SRGB_LIN | REC709 | HSL | HSV\\n GAMUT_AP0 = ACES2065_1\\n GAMUT_AP1 = ACESCG | ACESCC | ACESCCT\\n GAMUT_REC2020 = REC2020 | REC2020_LIN\\n GAMUT_DCI_P3 = DCI_P3 | DCI_P3_LIN\\n GAMUT_DISPLAY_P3= DISPLAY_P3\\n GAMUT_OKLAB = OKLAB | OKHSL | OKHSV\\n GAMUT_CIE_XYZ = CIE_XYZ | CIE_XYY\\n GAMUT_CIELAB = CIELAB\\n GAMUT_CIELUV = CIELUV\\n GAMUT_OTHER = LMS | UNKNOWN | NONCOLOR\\n\\n WP_D65 = SRGB | SRGB_LIN | REC709 | DISPLAY_P3 | REC2020 | REC2020_LIN | CIE_XYZ | CIE_XYY\\n WP_CCT_6300 = DCI_P3 | DCI_P3_LIN\\n WP_CCT_6000 = ACESCG | ACESCC | ACESCCT | ACES2065_1\\n\\n MODEL_RGB = SRGB | SRGB_LIN | REC709 | REC2020 | REC2020_LIN | DCI_P3 | DCI_P3_LIN | DISPLAY_P3 | \\\\\\n ACESCG | ACESCC | ACESCCT | ACES2065_1\\n MODEL_CIE = CIE_XYZ | CIE_XYY | CIELAB | CIELUV\\n MODEL_CAM = 0\\n MODEL_YUV = 0\\n MODEL_OTHER = LMS | HSL | HSV | OKLAB # is OKLAB CAM-based?\\n \\n NEGATIVE = OKLAB | CIELAB | CIELUV | GAMUT_AP0\\n NON_NEGATIVE = ~NEGATIVE\\n\\n DISABLED = CIELUV\\n UNSUPPORTED = OKHSV | OKHSL # disabled doesn't go here - CS must have alternate path\\n SUPPORTED = ~UNSUPPORTED \\n\\n # FIXME: LUV doesn't quite match expected values, needs further testing\\n\\n mat_xyz_to_srgb = [\\n [3.24096994190452134, -1.53738317757009346, -0.498610760293003284],\\n [-0.969243636280879826, 1.87596750150772067, 0.0415550574071756125],\\n [0.0556300796969936084, -0.203976958888976564, 1.05697151424287856]]\\n\\n mat_srgb_to_xyz = [\\n [0.412390799265959481, 0.357584339383877964, 0.180480788401834288],\\n [0.212639005871510358, 0.715168678767755927, 0.072192315360733715],\\n [0.0193308187155918507, 0.119194779794625988, 0.950532152249660581]]\\n\\n mat_srgb_to_acescg = [\\n [ 0.6130974024, 0.3395231462, 0.04737945141],\\n [ 0.07019372247, 0.916353879, 0.01345239847],\\n [ 0.02061559288, 0.1095697729, 0.8698146341]]\\n\\n # NOTE: Includes \\\"D60\\\"/D65 white point conversion\\n mat_acescg_to_srgb = [\\n [ 1.705050993, -0.6217921206,-0.083258872],\\n [-0.1302564175, 1.140804737, -0.01054831907],\\n [-0.02400335681,-0.1289689761, 1.152972333]]\\n\\n # NOTE: Includes \\\"D60\\\"/D65 white point conversion\\n mat_srgb_to_aces2065_1 = [\\n [ 0.439632982, 0.382988698, 0.17737832],\\n [ 0.0897764431, 0.813439429, 0.0967841284],\\n [ 0.0175411704, 0.111546553, 0.870912277]]\\n\\n mat_aces2065_1_to_srgb = [\\n [ 2.52168619, -1.13413099, -0.387555198],\\n [-0.276479914, 1.37271909, -0.0962391736],\\n [-0.015378065, -0.152975336, 1.1683534]]\\n\\n mat_srgb_to_displayp3 = [\\n [ 0.822461969, 0.177538031, 1.15772692e-10],\\n [ 0.0331941989, 0.966805801, 1.95085037e-11],\\n [ 0.0170826307, 0.0723974405, 0.910519929]]\\n\\n mat_displayp3_to_srgb = [\\n [ 1.22494018, -0.224940176, -4.77534979e-11],\\n [-0.0420569547, 1.04205695, 3.37864801e-11],\\n [-0.0196375546,-0.0786360454, 1.0982736]] \\n\\n # NOTE: No chromatic adaptation\\n mat_srgb_to_dcip3 = [\\n [0.868579739716132409, 0.128919138460847047, 0.00250112182302054368],\\n [0.0345404102543194426, 0.961811386361919975, 0.0036482033837605824],\\n [0.0167714290414502718, 0.0710399977868858352, 0.912188573171663893]]\\n\\n # NOTE: No chromatic adaptation\\n mat_dcip3_to_srgb = [\\n [ 1.15751640619975871, -0.154962378073857756, -0.00255402812590095854],\\n [-0.0415000715306859699, 1.04556792307969925, -0.00406785154901328463],\\n [-0.0180500389562539583,-0.0785782726530290654, 1.09662831160928302]]\\n\\n # NOTE: No chromatic adaptation\\n mat_dcip3_to_xyz = [\\n [ 0.445169815564552417, 0.277134409206777664, 0.172282669815564564],\\n [ 0.209491677912730539, 0.721595254161043636, 0.0689130679262258258],\\n [-3.63410131696985616e-17, 0.0470605600539811521, 0.907355394361973415]]\\n\\n # NOTE: No chromatic adaptation\\n mat_xyz_to_dcip3 = [\\n [2.7253940304917328, -1.01800300622718496, -0.440163195190036463],\\n [-0.795168025808764195, 1.689732054843624, 0.0226471906084774533],\\n [0.0412418913957000325, -0.0876390192158623825, 1.10092937864632191]]\\n\\n mat_srgb_to_rec2020 = [\\n [ 0.627403896, 0.329283039, 0.0433130657],\\n [ 0.0690972894, 0.919540395, 0.0113623156],\\n [ 0.0163914389, 0.0880133077, 0.895595253]]\\n\\n mat_rec2020_to_srgb = [\\n [ 1.660491, -0.587641139,-0.0728498633],\\n [-0.124550475, 1.1328999, -0.00834942258],\\n [-0.0181507633,-0.100578898, 1.11872966]]\\n\\n mat_rec2020_to_xyz = [\\n [0.636958048301291, 0.144616903586208, 0.168880975164172],\\n [0.262700212011267, 0.677998071518871, 0.059301716469862],\\n [4.99410657446607e-17, 0.0280726930490874, 1.06098505771079]]\\n\\n mat_xyz_to_rec2020 = [\\n [1.71665118797127, -0.355670783776393, -0.25336628137366],\\n [-0.666684351832489, 1.61648123663494, 0.0157685458139111],\\n [0.0176398574453108, -0.0427706132578085, 0.942103121235474]]\\n\\n # NOTE: No chromatic adaptation\\n mat_acescg_to_xyz = [\\n [ 0.66245418, 0.13400421, 0.15618769],\\n [ 0.27222872, 0.67408177, 0.05368952],\\n [-0.00557465, 0.00406073, 1.0103391 ]]\\n\\n # NOTE: No chromatic adaptation\\n mat_xyz_to_acescg = [\\n [ 1.64102338, -0.32480329, -0.2364247 ],\\n [-0.66366286, 1.61533159, 0.01675635],\\n [ 0.01172189, -0.00828444, 0.98839486]]\\n\\n # NOTE: For CIE XYZ color\\n mat_d60_to_d65 = [\\n [ 0.98722400,-0.00611327, 0.01595330],\\n [-0.00759836, 1.00186000, 0.00533002],\\n [ 0.00307257,-0.00509595, 1.08168000]]\\n\\n # NOTE: For CIE XYZ color\\n mat_d65_to_d60 = [\\n [ 1.01303000, 0.00610531,-0.01497100],\\n [ 0.00769823, 0.99816500,-0.00503203],\\n [-0.00284131, 0.00468516, 0.92450700]]\\n\\n # NOTE: For CIE XYZ color\\n mat_d65_to_dci = [\\n [0.976578896646979768, -0.0154362646984919742, -0.016686021704209866],\\n [-0.0256896658505145926, 1.02853916787996963, -0.00378517365630504153],\\n [-0.00570574587417104179, 0.0110778657389971485, 0.871176159390377409]]\\n \\n # NOTE: For CIE XYZ color\\n mat_dci_to_d65 = [\\n [1.02449672775257752, 0.0151635410224165156, 0.0196885223342066827],\\n [0.0256121933371584198, 0.97258630562441342, 0.00471635229242730096],\\n [0.0063842306500876874, -0.012268082736730219, 1.14794244517367791]]\\n\\n mat_xyz_to_lms = [\\n [ 0.8951, 0.2664,-0.1614],\\n [-0.7502, 1.7135, 0.0367],\\n [ 0.0389,-0.0685, 1.0296]]\\n\\n mat_lms_to_xyz = [\\n [ 0.986993, -0.147054, 0.159963],\\n [ 0.432305, 0.51836, 0.0492912],\\n [ -0.00852866, 0.0400428, 0.968487]]\\n\\n # OKLAB's XYZ to LMS\\n mat_oklab_m1 = [\\n [ 0.8189330101, 0.3618667424, -0.1288597137],\\n [ 0.0329845436, 0.9293118715, 0.0361456387],\\n [ 0.0482003018, 0.2643662691, 0.6338517070]]\\n\\n # OKLAB's non-linear L'M'S' to OKLAB\\n mat_oklab_m2 = [\\n [ 0.2104542553, 0.7936177850, -0.0040720468],\\n [ 1.9779984951, -2.4285922050, 0.4505937099],\\n [ 0.0259040371, 0.7827717662, -0.8086757660]]\\n\\n # Inverse of OKLAB M1\\n mat_oklab_m1_inv = [\\n [ 1.22701385, -0.55779998, 0.28125615],\\n [-0.04058018, 1.11225687, -0.07167668],\\n [-0.07638128, -0.42148198, 1.58616322]]\\n\\n # Inverse of OKLAB M2\\n mat_oklab_m2_inv = [\\n [ 1. , 0.39633779, 0.21580376],\\n [ 1.00000001, -0.10556134, -0.06385417],\\n [ 1.00000005, -0.08948418, -1.29148554]]\\n\\n @classmethod\\n def convert(cls, im:Union[torch.Tensor, ColorImage], source:Variant, destination:Variant) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Change the color space of an image. Cylindrical transformations HSV/HSL are \\n treated as their own color spaces and assumed to be relative to sRGB linear. \\n Unless otherwise noted or required by specification (e.g. ACES), we assume D65 white point.\\n\\n .. warning::\\n\\n Tone mapping is not included, so converting the color space of HDR values to \\n an LDR-designated color space will not automatically reduce dynamic range. For example, \\n taking an HDR image from :code:`ACESCG` (AP1) to :code:`SRGB` will yield the sRGB \\n gamma curve, but values outside the required range must still be tone mapped or clamped beforehand.\\n\\n .. warning::\\n\\n Cylindrical transformations (HSL, HSV) should be given input in [0, 1] linear sRGB range \\n (or equivalent). This is not strictly enforced but input outside this range may yield \\n unpredictable results or *NaN* values.\\n\\n :param im: [C=3, H, W] image tensor \\n :type im: torch.Tensor | ColorImage\\n :param source: color space to convert from\\n :param destination: color space to convert to\\n :return: image tensor in designated color space\\n \\\"\\\"\\\"\\n ip, op = source, destination\\n cs = cls.Variant\\n tf = TransferFunction\\n if ip == op: return im\\n\\n assert im.dim() == 3 and im.size(0) == 3, f\\\"expected [C=3, H, W] image tensor, got {im.size()}\\\"\\n assert source != 0, f\\\"Unknown source color space\\\"\\n assert ip & cs.SUPPORTED, f\\\"Source color space not supported: {source.name}\\\"\\n assert op & cs.SUPPORTED, f\\\"Destination color space not supported: {destination.name}\\\"\\n assert ip & ~cs.DISABLED, f\\\"Source color space disabled: {ColorSpace.Variant(ip).name}\\\"\\n assert op & ~cs.DISABLED, f\\\"Destination color space disabled: {ColorSpace.Variant(op).name}\\\"\\n\\n err_not_implemented = f\\\"Color space conversion not implemented: {ColorSpace.Variant(ip).name} to {ColorSpace.Variant(op).name}\\\" \\n\\n # Direct path where it matters, loop-de-loop elsewhere\\n if ip == cs.SRGB_LIN:\\n if op == cs.SRGB: im = tf.srgb_oetf(im)\\n elif op == cs.REC709: im = tf.rec709_oetf(im)\\n elif op == cs.REC2020: im = tf.rec2020_oetf(mm(im, cls.mat_srgb_to_rec2020))\\n elif op == cs.REC2020_LIN: im = mm(im, cls.mat_srgb_to_rec2020)\\n elif op == cs.DCI_P3: im = tf.dcip3_oetf(mm(mm(mm(im, cls.mat_srgb_to_xyz), cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3))\\n elif op == cs.DCI_P3_LIN: im = mm(mm(mm(im, cls.mat_srgb_to_xyz), cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3)\\n elif op == cs.DISPLAY_P3: im = tf.srgb_oetf(mm(im, cls.mat_srgb_to_displayp3))\\n elif op == cs.CIE_XYZ: im = mm(im, cls.mat_srgb_to_xyz)\\n elif op == cs.CIE_XYY: im = cls._xyz_to_xyy(mm(im, cls.mat_srgb_to_xyz))\\n elif op == cs.LMS: im = cls._xyz_to_lms(mm(im, cls.mat_srgb_to_xyz))\\n elif op == cs.ACESCG: im = mm(im, cls.mat_srgb_to_acescg)\\n elif op == cs.ACESCC: im = cls._acescg_to_acescc(mm(im, cls.mat_srgb_to_acescg))\\n elif op == cs.ACES2065_1: im = mm(im, cls.mat_srgb_to_aces2065_1)\\n elif op == cs.CIELAB: im = cls._xyz_to_cielab(mm(im, cls.mat_srgb_to_xyz))\\n elif op == cs.CIELUV: im = cls._xyz_to_cieluv(mm(im, cls.mat_srgb_to_xyz))\\n elif op == cs.OKLAB: im = cls._rgb_to_oklab(im)\\n elif op == cs.HSL: im = cls._rgb_to_hsl(tf.srgb_oetf(im))\\n elif op == cs.HSV: im = cls._rgb_to_hsv(tf.srgb_oetf(im))\\n else: raise Exception(err_not_implemented)\\n elif ip == cs.SRGB:\\n if op == cs.HSL: im = cls._rgb_to_hsl(im)\\n elif op == cs.HSV: im = cls._rgb_to_hsv(im)\\n else: im = cls.convert(tf.srgb_eotf(im), cs.SRGB_LIN, op)\\n elif ip == cs.REC709: im = cls.convert(tf.rec709_eotf(im), cs.SRGB_LIN, op)\\n elif ip == cs.REC2020: \\n if op == cs.REC2020_LIN: im = tf.rec2020_eotf(im)\\n elif op == cs.CIE_XYZ: im = mm(tf.rec2020_eotf(im), cls.mat_rec2020_to_xyz)\\n elif op == cs.SRGB_LIN: im = mm(tf.rec2020_eotf(im), cls.mat_rec2020_to_srgb)\\n else: im = cls.convert(mm(tf.rec2020_eotf(im), cls.mat_rec2020_to_srgb), cs.SRGB_LIN, op)\\n elif ip == cs.REC2020_LIN: \\n if op == cs.REC2020: im = tf.rec2020_oetf(im)\\n elif op == cs.CIE_XYZ: im = mm(im, cls.mat_rec2020_to_xyz)\\n elif op == cs.SRGB_LIN: im = mm(im, cls.mat_rec2020_to_srgb)\\n else: im = cls.convert(mm(im, cls.mat_rec2020_to_srgb), cs.SRGB_LIN, op)\\n elif ip == cs.DCI_P3: \\n if op == cs.DCI_P3_LIN: im = tf.dcip3_eotf(im)\\n elif op == cs.CIE_XYZ: im = mm(mm(tf.dcip3_eotf(im), cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65)\\n else: im = cls.convert(mm(mm(tf.dcip3_eotf(im), cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65), cs.CIE_XYZ, op)\\n elif ip == cs.DCI_P3_LIN: \\n if op == cs.DCI_P3: im = tf.dcip3_oetf(im)\\n elif op == cs.CIE_XYZ: im = mm(mm(im, cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65)\\n else: im = cls.convert(mm(mm(im, cls.mat_dcip3_to_xyz), cls.mat_dci_to_d65), cs.CIE_XYZ, op)\\n elif ip == cs.DISPLAY_P3: im = cls.convert(mm(tf.srgb_eotf(im), cls.mat_displayp3_to_srgb), cs.SRGB_LIN, op)\\n elif ip == cs.CIE_XYZ:\\n if op == cs.CIE_XYY: im = cls._xyz_to_xyy(im)\\n elif op == cs.REC2020_LIN: im = mm(im, cls.mat_xyz_to_rec2020)\\n elif op == cs.REC2020: im = tf.rec2020_oetf(mm(im, cls.mat_xyz_to_rec2020))\\n elif op == cs.DCI_P3_LIN: im = mm(mm(im, cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3)\\n elif op == cs.DCI_P3: im = tf.dcip3_oetf(mm(mm(im, cls.mat_d65_to_dci), cls.mat_xyz_to_dcip3))\\n elif op == cs.LMS: im = cls._xyz_to_lms(im)\\n elif op == cs.ACESCG: im = mm(cls._d65_to_d60(im), cls.mat_xyz_to_acescg)\\n elif op == cs.CIELAB: im = cls._xyz_to_cielab(im)\\n elif op == cs.CIELUV: im = cls._xyz_to_cieluv(im)\\n elif op == cs.OKLAB: im = cls._xyz_to_oklab(im)\\n else: im = cls.convert(mm(im, cls.mat_xyz_to_srgb), cs.SRGB_LIN, op)\\n elif ip == cs.CIE_XYY: \\n if op == cs.CIE_XYZ: im = cls._xyy_to_xyz(im)\\n else: im = cls.convert(cls._xyy_to_xyz(im), cs.CIE_XYZ, op)\\n elif ip == cs.LMS: \\n if op == cs.CIE_XYZ: im = cls._lms_to_xyz(im)\\n else: im = cls.convert(cls._lms_to_xyz(im), cs.CIE_XYZ, op)\\n elif ip == cs.ACESCG:\\n # if op == cs.CIE_XYZ: im = cls._d60_to_d65(mm(im, cls.mat_acescg_to_xyz)) # FIXME: fails unit test (?)\\n if op == cs.ACESCC: im = cls._acescg_to_acescc(im)\\n else: im = cls.convert(mm(im, cls.mat_acescg_to_srgb), cs.SRGB_LIN, op)\\n elif ip == cs.ACESCC:\\n if op == cs.ACESCG: im = cls._acescc_to_acescg(im)\\n else: im = cls.convert(cls._acescc_to_acescg(im), cs.ACESCG, op)\\n elif ip == cs.ACES2065_1: im = cls.convert(mm(im, cls.mat_aces2065_1_to_srgb), cs.SRGB_LIN, op)\\n elif ip == cs.HSL:\\n if op == cs.SRGB: im = cls._hsl_to_rgb(im)\\n else: im = cls.convert(tf.srgb_eotf(cls._hsl_to_rgb(im)), cs.SRGB_LIN, op)\\n elif ip == cs.HSV:\\n if op == cs.SRGB: im = cls._hsv_to_rgb(im)\\n else: im = cls.convert(tf.srgb_eotf(cls._hsv_to_rgb(im)), cs.SRGB_LIN, op)\\n elif ip == cs.CIELAB: im = cls.convert(cls._cielab_to_xyz(im), cs.CIE_XYZ, op)\\n elif ip == cs.CIELUV: im = cls.convert(cls._cieluv_to_xyz(im), cs.CIE_XYZ, op)\\n elif ip == cs.OKLAB:\\n if op == cs.CIE_XYZ: im = cls._oklab_to_xyz(im)\\n else: im = cls.convert(cls._oklab_to_rgb(im), cs.SRGB_LIN, op)\\n else: raise Exception(err_not_implemented)\\n\\n return im\\n\\n @classmethod\\n def _xyz_to_xyy(cls, xyz:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert CIE XYZ color space to CIE xyY color space.\\n\\n :param xyz: Input CIE XYZ color space tensor\\n :return: CIE xyY color space tensor\\n \\\"\\\"\\\"\\n X = xyz[0:1]\\n Y = xyz[1:2]\\n Z = xyz[2:3]\\n x = X / (X + Y + Z)\\n y = Y / (X + Y + Z)\\n return torch.cat([x, y, Y], dim=0)\\n\\n @classmethod\\n def _xyy_to_xyz(cls, xyy:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert CIE xyY color space to CIE XYZ color space.\\n\\n :param xyy: Input CIE xyY color space tensor\\n :return: CIE XYZ color space tensor\\n \\\"\\\"\\\"\\n x = xyy[0:1]\\n y = xyy[1:2]\\n Y = xyy[2:3]\\n X = (Y / y) * x\\n Z = (Y / y) * (1. - x - y)\\n return torch.cat([X, Y, Z], dim=0)\\n\\n @classmethod\\n def _xyz_to_lms(cls, xyz:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert CIE XYZ color space to LMS color space.\\n\\n :param xyz: Input CIE XYZ color space tensor\\n :return: LMS color space tensor\\n \\\"\\\"\\\"\\n return mm(xyz, cls.mat_xyz_to_lms)\\n\\n @classmethod\\n def _lms_to_xyz(cls, lms:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert LMS color space to CIE XYZ color space.\\n\\n :param lms: Input LMS color space tensor\\n :return: CIE XYZ color space tensor\\n \\\"\\\"\\\"\\n return mm(lms, cls.mat_lms_to_xyz)\\n\\n @classmethod\\n def _acescg_to_acescc(cls, cg:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert scene-linear ACEScg to log ACEScc.\\n\\n :param lms: Input ACEScg color space tensor\\n :return: ACEScc color space tensor\\n \\\"\\\"\\\"\\n res = torch.where(cg < 0.00003051757, \\n (torch.log2(0.00001525878 + cg * 0.5) + 9.72) / 17.52, \\n (torch.log2(cg) + 9.72) / 17.52)\\n return res\\n\\n @classmethod\\n def _acescc_to_acescg(cls, cc:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert log ACEScc to scene-linear ACEScg.\\n\\n :param lms: Input ACEScc color space tensor\\n :return: ACEScg color space tensor\\n \\\"\\\"\\\"\\n res = torch.where(cc < -0.3013698630, \\n (torch.exp2(cc * 17.52 - 9.72) - 0.00001525878) * 2,\\n torch.exp2(cc * 17.52 - 9.72))\\n return res\\n\\n @classmethod\\n def _xyz_to_oklab(cls, xyz:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert CIE XYZ color space to OKLAB color space.\\n\\n :param xyz: Input CIE XYZ color space tensor\\n :return: OKLAB color space tensor\\n \\\"\\\"\\\" \\n lms = mm(xyz, cls.mat_oklab_m1)\\n lms_p = torch.pow(torch.abs(lms), 0.3333333333) * torch.sign(lms).float()\\n lab = mm(lms_p, cls.mat_oklab_m2)\\n return lab\\n\\n @classmethod\\n def _oklab_to_xyz(cls, lab:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert OKLAB color space to CIE XYZ color space.\\n\\n :param lab: Input OKLAB color space tensor\\n :return: CIE XYZ color space tensor\\n \\\"\\\"\\\"\\n lms_p = mm(lab, cls.mat_oklab_m2_inv)\\n lms = torch.pow(lms_p, 3.)\\n xyz = mm(lms, cls.mat_oklab_m1_inv)\\n return xyz\\n\\n\\n @classmethod\\n def __pivot_xyz_to_lab(cls, val): \\n return torch.where(val > 0.008856, torch.pow(val, 0.3333333333), ((val * 903.3) + 16.0) / 116.0)\\n\\n @classmethod\\n def _xyz_to_cielab(cls, xyz:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert color space from CIE XYZ to CIELAB.\\n\\n :param xyz: Input CIE XYZ color space tensor\\n :return: CIELAB color space tensor\\n \\\"\\\"\\\"\\n # https://github.com/CairX/convert-colors-py/blob/master/convcolors/__init__.py\\n # MIT License\\n\\n # Copyright (c) 2022 Thomas Cairns\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE. \\n x = xyz[0:1] / 0.95047 \\n y = xyz[1:2] / 1.00000 \\n z = xyz[2:3] / 1.08883 \\n\\n x = cls.__pivot_xyz_to_lab(x)\\n y = cls.__pivot_xyz_to_lab(y)\\n z = cls.__pivot_xyz_to_lab(z)\\n\\n l = torch.maximum(torch.zeros_like(y).to(y.device), (116.0 * y) - 16.0)\\n a = (x - y) * 500.0\\n b = (y - z) * 200.0\\n return torch.cat([l, a, b], dim=0)\\n\\n @classmethod\\n def _cielab_to_xyz(cls, lab:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert color space from CIELAB to CIE XYZ.\\n \\n .. note::\\n\\n Assumes D65 standard illuminant.\\n\\n :param lab: Input CIELAB color space tensor\\n :return: CIE XYZ color space tensor\\n \\\"\\\"\\\"\\n # https://github.com/CairX/convert-colors-py/blob/master/convcolors/__init__.py\\n # MIT License\\n\\n # Copyright (c) 2022 Thomas Cairns\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n l = lab[0:1]\\n a = lab[1:2]\\n b = lab[2:3]\\n\\n # Reminder: The y values is calculated first as it can be reused\\n # for the calculation of x and z.\\n y = (l + 16.0) / 116.0\\n x = y + (a / 500.0)\\n z = y - (b / 200.0)\\n\\n x3 = x * x * x\\n z3 = z * z * z\\n y3 = y * y * y\\n\\n x = torch.where(x3 > 0.008856, x3, ((x * 116.0) - 16.0) / 903.3)\\n y = torch.where(l > 7.9996248, y3, l / 903.3)\\n z = torch.where(z3 > 0.008856, z3, ((z * 116.0) - 16.0) / 903.3)\\n\\n x = x * 0.95047 \\n y = y * 1.00000 \\n z = z * 1.08883\\n\\n return torch.cat([x, y, z], dim=0)\\n\\n def _xyz_to_cieluv(image:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Converts CIE XYZ to CIELUV. \\n \\n .. note::\\n\\n Assumes D65 standard illuminant.\\n\\n :param image: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are X, Y, Z\\n :return: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are L, U, V\\n \\\"\\\"\\\"\\n # https://github.com/stefanLeong/S2CRNet/blob/main/scripts/utils/color.py\\n # MIT License\\n\\n # Copyright (c) 2021 StefanLeong\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n if len(image.size()) == 3:\\n small_L = (29. / 3) ** 3 * image[1]\\n large_L = 116 * torch.pow(image[1], 1 / 3.) - 16\\n L = torch.where(image[1] <= (6. / 29) ** 3, small_L, large_L)\\n\\n denom = (image[0] + 15 * image[1] + 3 * image[2])\\n u_prime = torch.where(denom != 0., 4 * image[0] / denom, 0.)\\n v_prime = torch.where(denom != 0., 9 * image[1] / denom, 0.)\\n d = 0\\n elif len(image.size()) == 4:\\n small_L = (29. / 3) ** 3 * image[:, 1]\\n large_L = 116 * torch.pow(image[:, 1], 1 / 3.) - 16\\n L = torch.where(image[:, 1] <= (6. / 29) ** 3, small_L, large_L)\\n\\n denom = (image[:, 0] + 15 * image[:, 1] + 3 * image[:, 2])\\n u_prime = torch.where(denom > 0., 4 * image[:, 0] / denom, 0.)\\n v_prime = torch.where(denom > 0., 9 * image[:, 1] / denom, 0.)\\n d = 1\\n\\n u = 13 * L * (u_prime - .2009)\\n v = 13 * L * (v_prime - .4610)\\n\\n luv_image = torch.stack((L, u, v), dim=d)\\n\\n return luv_image\\n\\n def _cieluv_to_xyz(image:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Converts CIELUV to CIE XYZ. \\n \\n .. note::\\n\\n Assumes D65 standard illuminant.\\n\\n :param image: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are L, U, V\\n :return: A pytorch tensor of shape (3, n_pixels_x, n_pixels_y) in which the channels are X, Y, Z\\n \\\"\\\"\\\"\\n # https://github.com/stefanLeong/S2CRNet/blob/main/scripts/utils/color.py\\n # MIT License\\n\\n # Copyright (c) 2021 StefanLeong\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n if len(image.size()) == 3:\\n denom = (13 * image[0])\\n u_prime = torch.where(denom != 0., image[1] / denom, 0.) + .2009\\n v_prime = torch.where(denom != 0., image[2] / denom, 0.) + .4610\\n\\n small_Y = image[0] * (3. / 29) ** 3\\n large_Y = ((image[0] + 16.) / 116.) ** 3\\n\\n Y = torch.where(image[0] <= 8, small_Y, large_Y)\\n d = 0\\n # batch of images\\n elif len(image.size()) == 4:\\n denom = (13 * image[:, 0])\\n u_prime = torch.where(denom != 0., image[:, 1] / denom, 0.) + .2009\\n v_prime = torch.where(denom != 0., image[:, 2] / denom, 0.) + .4610\\n\\n small_Y = image[:, 0] * (3. / 29) ** 3\\n large_Y = ((image[:, 0] + 16.) / 116.) ** 3\\n\\n Y = torch.where(image[:, 0] <= 8, small_Y, large_Y)\\n d = 1\\n\\n X = torch.where(v_prime != 0., Y * 9 * u_prime / (4 * v_prime), 0.)\\n Z = torch.where(v_prime != 0., Y * (12 - 3 * u_prime - 20 * v_prime) / (4 * v_prime), 0.)\\n\\n xyz_image = torch.stack((X, Y, Z), dim=d)\\n\\n return xyz_image\\n\\n @classmethod\\n def _rgb_to_oklab(cls, rgb:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert color space from linear sRGB to OKLAB.\\n\\n :param rgb: Input linear sRGB color space tensor\\n :return: OKLAB color space tensor\\n \\\"\\\"\\\"\\n cr = rgb[0:1]\\n cg = rgb[1:2]\\n cb = rgb[2:3]\\n\\n l = 0.4122214708 * cr + 0.5363325363 * cg + 0.0514459929 * cb;\\n m = 0.2119034982 * cr + 0.6806995451 * cg + 0.1073969566 * cb;\\n s = 0.0883024619 * cr + 0.2817188376 * cg + 0.6299787005 * cb;\\n\\n l_ = torch.pow(torch.abs(l), 0.3333333333) * torch.sign(l).float()\\n m_ = torch.pow(torch.abs(m), 0.3333333333) * torch.sign(m).float()\\n s_ = torch.pow(torch.abs(s), 0.3333333333) * torch.sign(s).float()\\n\\n return torch.cat([\\n 0.2104542553 * l_ + 0.7936177850 * m_ - 0.0040720468 * s_,\\n 1.9779984951 * l_ - 2.4285922050 * m_ + 0.4505937099 * s_,\\n 0.0259040371 * l_ + 0.7827717662 * m_ - 0.8086757660 * s_], dim=0)\\n\\n @classmethod\\n def _oklab_to_rgb(cls, lab:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert color space from OKLAB to linear sRGB.\\n\\n :param lab: Input OKLAB color space tensor\\n :return: Linear sRGB color space tensor\\n \\\"\\\"\\\"\\n cl = lab[0:1]\\n ca = lab[1:2]\\n cb = lab[2:3]\\n\\n l_ = cl + 0.3963377774 * ca + 0.2158037573 * cb\\n m_ = cl - 0.1055613458 * ca - 0.0638541728 * cb\\n s_ = cl - 0.0894841775 * ca - 1.2914855480 * cb\\n\\n l = l_*l_*l_\\n m = m_*m_*m_\\n s = s_*s_*s_\\n\\n return torch.cat([\\n +4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s,\\n -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s,\\n -0.0041960863 * l - 0.7034186147 * m + 1.7076147010 * s], dim=0)\\n\\n @classmethod\\n def _rgb_to_hsl(cls, rgb: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Transform sRGB image tensor to sRGB-relative HSL. \\n \\n .. note::\\n\\n expects non-linear sRGB w/ gamma curve as input\\n\\n :param rgb: Input sRGB image tensor\\n :return: HSL image tensor\\n \\\"\\\"\\\"\\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\\n # MIT License\\n\\n # Copyright (c) 2022 hawkey\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n rgb = rgb.unsqueeze(0)\\n cmax, cmax_idx = torch.max(rgb, dim=1, keepdim=True)\\n cmin = torch.min(rgb, dim=1, keepdim=True)[0]\\n delta = cmax - cmin\\n hsl_h = torch.empty_like(rgb[:, 0:1, :, :])\\n cmax_idx[delta == 0] = 3\\n hsl_h[cmax_idx == 0] = (((rgb[:, 1:2] - rgb[:, 2:3]) / delta) % 6)[cmax_idx == 0]\\n hsl_h[cmax_idx == 1] = (((rgb[:, 2:3] - rgb[:, 0:1]) / delta) + 2)[cmax_idx == 1]\\n hsl_h[cmax_idx == 2] = (((rgb[:, 0:1] - rgb[:, 1:2]) / delta) + 4)[cmax_idx == 2]\\n hsl_h[cmax_idx == 3] = 0.\\n hsl_h /= 6.\\n\\n hsl_l = (cmax + cmin) / 2.\\n hsl_s = torch.empty_like(hsl_h)\\n hsl_s[hsl_l == 0] = 0\\n hsl_s[hsl_l == 1] = 0\\n hsl_l_ma = torch.bitwise_and(hsl_l > 0, hsl_l < 1)\\n hsl_l_s0_5 = torch.bitwise_and(hsl_l_ma, hsl_l <= 0.5)\\n hsl_l_l0_5 = torch.bitwise_and(hsl_l_ma, hsl_l > 0.5)\\n hsl_s[hsl_l_s0_5] = ((cmax - cmin) / (hsl_l * 2.))[hsl_l_s0_5]\\n hsl_s[hsl_l_l0_5] = ((cmax - cmin) / (- hsl_l * 2. + 2.))[hsl_l_l0_5]\\n return torch.cat([hsl_h, hsl_s, hsl_l], dim=1).squeeze(0)\\n\\n @classmethod\\n def _hsl_to_rgb(cls, hsl: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Transform sRGB-relative HSL image tensor to sRGB. \\n \\n .. note::\\n\\n returns non-linear sRGB w/ gamma curve as output\\n\\n :param hsl: Input HSL image tensor\\n :return: sRGB image tensor\\n \\\"\\\"\\\"\\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\\n # MIT License\\n\\n # Copyright (c) 2022 hawkey\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n hsl = hsl.unsqueeze(0)\\n hsl_h, hsl_s, hsl_l = hsl[:, 0:1], hsl[:, 1:2], hsl[:, 2:3]\\n _c = (-torch.abs(hsl_l * 2. - 1.) + 1) * hsl_s\\n _x = _c * (-torch.abs(hsl_h * 6. % 2. - 1) + 1.)\\n _m = hsl_l - _c / 2.\\n idx = (hsl_h * 6.).type(torch.uint8)\\n idx = (idx % 6).expand(-1, 3, -1, -1)\\n rgb = torch.empty_like(hsl).to(hsl.device)\\n _o = torch.zeros_like(_c).to(hsl.device)\\n rgb[idx == 0] = torch.cat([_c, _x, _o], dim=1)[idx == 0]\\n rgb[idx == 1] = torch.cat([_x, _c, _o], dim=1)[idx == 1]\\n rgb[idx == 2] = torch.cat([_o, _c, _x], dim=1)[idx == 2]\\n rgb[idx == 3] = torch.cat([_o, _x, _c], dim=1)[idx == 3]\\n rgb[idx == 4] = torch.cat([_x, _o, _c], dim=1)[idx == 4]\\n rgb[idx == 5] = torch.cat([_c, _o, _x], dim=1)[idx == 5]\\n rgb += _m\\n return rgb.squeeze(0)\\n\\n @classmethod\\n def _rgb_to_hsv(cls, rgb: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Transform sRGB image tensor to sRGB-relative HSV. \\n \\n .. note::\\n\\n expects non-linear sRGB w/ gamma curve as input\\n\\n .. warning::\\n\\n input tensor will be clamped to [0, 1] range\\n\\n :param rgb: Input sRGB image tensor\\n :return: HSV image tensor\\n \\\"\\\"\\\"\\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\\n # MIT License\\n\\n # Copyright (c) 2022 hawkey\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n rgb = rgb.clamp(0.,1.).unsqueeze(0)\\n cmax, cmax_idx = torch.max(rgb, dim=1, keepdim=True)\\n cmin = torch.min(rgb, dim=1, keepdim=True)[0]\\n delta = cmax - cmin\\n hsv_h = torch.empty_like(rgb[:, 0:1, :, :])\\n cmax_idx[delta == 0] = 3\\n hsv_h[cmax_idx == 0] = (((rgb[:, 1:2] - rgb[:, 2:3]) / delta) % 6)[cmax_idx == 0]\\n hsv_h[cmax_idx == 1] = (((rgb[:, 2:3] - rgb[:, 0:1]) / delta) + 2)[cmax_idx == 1]\\n hsv_h[cmax_idx == 2] = (((rgb[:, 0:1] - rgb[:, 1:2]) / delta) + 4)[cmax_idx == 2]\\n hsv_h[cmax_idx == 3] = 0.\\n hsv_h /= 6.\\n hsv_s = torch.where(cmax == 0, torch.tensor(0.).type_as(rgb), delta / cmax)\\n hsv_v = cmax\\n return torch.cat([hsv_h, hsv_s, hsv_v], dim=1).squeeze(0)\\n\\n @classmethod\\n def _hsv_to_rgb(cls, hsv: torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Transform sRGB-relative HSV image tensor to sRGB. \\n \\n .. note::\\n \\n returns non-linear sRGB w/ gamma curve as output\\n\\n :param hsv: Input HSV image tensor\\n :return: sRGB image tensor\\n \\\"\\\"\\\"\\n # https://github.com/windingwind/seal-3d/blob/main/SealNeRF/color_utils.py\\n # MIT License\\n\\n # Copyright (c) 2022 hawkey\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in all\\n # copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\\n # SOFTWARE.\\n hsv = hsv.unsqueeze(0)\\n hsv_h, hsv_s, hsv_l = hsv[:, 0:1], hsv[:, 1:2], hsv[:, 2:3]\\n _c = hsv_l * hsv_s\\n _x = _c * (- torch.abs(hsv_h * 6. % 2. - 1) + 1.)\\n _m = hsv_l - _c\\n _o = torch.zeros_like(_c).to(hsv.device)\\n idx = (hsv_h * 6.).type(torch.uint8)\\n idx = (idx % 6).expand(-1, 3, -1, -1)\\n rgb = torch.empty_like(hsv).to(hsv.device)\\n rgb[idx == 0] = torch.cat([_c, _x, _o], dim=1)[idx == 0]\\n rgb[idx == 1] = torch.cat([_x, _c, _o], dim=1)[idx == 1]\\n rgb[idx == 2] = torch.cat([_o, _c, _x], dim=1)[idx == 2]\\n rgb[idx == 3] = torch.cat([_o, _x, _c], dim=1)[idx == 3]\\n rgb[idx == 4] = torch.cat([_x, _o, _c], dim=1)[idx == 4]\\n rgb[idx == 5] = torch.cat([_c, _o, _x], dim=1)[idx == 5]\\n rgb += _m\\n return rgb.squeeze(0)\\n\\n @classmethod\\n def _d60_to_d65(cls, im:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert CIE XYZ image from \\\"D60\\\" to D65 white point.\\n\\n :param im: Input image tensor\\n :return: Converted image tensor\\n \\\"\\\"\\\"\\n # There is not really a CIE D60 white point, but that's what everyone calls what ACES uses.\\n return mm(im, cls.mat_d60_to_d65)\\n\\n @classmethod\\n def _d65_to_d60(cls, im:torch.Tensor) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Convert CIE XYZ image from D65 to \\\"D60\\\" white point.\\n\\n :param torch.Tensor im: Input image tensor\\n :return: Converted image tensor\\n \\\"\\\"\\\"\\n return mm(im, cls.mat_d65_to_d60)\"\n },\n {\n \"identifier\": \"load_lut\",\n \"path\": \"src/tinycio/fsio/lutfile.py\",\n \"snippet\": \"def load_lut(fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Load LUT from file.\\n\\n :param fp: File path to load from.\\n :param lut_format: Format of the LUT.\\n :return: lattice as PyTorch tensor\\n \\\"\\\"\\\"\\n fp = os.path.realpath(fp)\\n fn, fnext = os.path.splitext(fp)\\n if lut_format == LUTFormat.UNKNOWN: lut_format = _infer_lut_file_format(fnext)\\n assert lut_format > LUTFormat.UNKNOWN, \\\"Unrecognized LUT format\\\"\\n lattice = None\\n if lut_format == LUTFormat.CUBE_3D:\\n with open(fp, 'r') as file:\\n # Read lines and filter out comments\\n lines = [line.strip() for line in file.readlines() if len(line) > 0 and \\\"#\\\" not in line]\\n\\n # Find the line indicating the start of the LUT data\\n lut_start_index = next((i for i, line in enumerate(lines) if line.startswith('LUT_3D_SIZE')), None)\\n\\n if lut_start_index is None: raise ValueError(\\\"LUT_3D_SIZE indicator not found in the .cube file.\\\")\\n\\n # Extract LUT data\\n lut_data = [list(map(float, line.split())) for line in lines[lut_start_index + 1:] \\\\\\n if len(line) > 0 and len(line.split()) == 3 and \\\"#\\\" not in line] \\n\\n # Convert the LUT data to a PyTorch tensor\\n lut_size = int(lines[lut_start_index].split()[1])\\n\\n lattice = torch.tensor(lut_data).view(lut_size, lut_size, lut_size, 3).permute(2,1,0,3)\\n else:\\n raise Exception(\\\"Unsupported LUT format\\\")\\n return lattice\"\n },\n {\n \"identifier\": \"save_lut\",\n \"path\": \"src/tinycio/fsio/lutfile.py\",\n \"snippet\": \"def save_lut(lattice:torch.Tensor, fp:str, lut_format:LUTFormat=LUTFormat.UNKNOWN) -> bool:\\n \\\"\\\"\\\"\\n Save LUT to a file.\\n\\n .. warning:: \\n \\n This will overwrite existing files.\\n\\n :param lattice: PyTorch tensor representing the LUT.\\n :param fp: File path for saving the LUT.\\n :param lut_format: Format of the LUT.\\n :return: True if successful\\n \\\"\\\"\\\"\\n fp = os.path.realpath(fp)\\n fn, fnext = os.path.splitext(fp)\\n\\n if lut_format == LUTFormat.UNKNOWN: lut_format = _infer_lut_file_format(fnext)\\n\\n if lut_format == LUTFormat.CUBE_3D:\\n # Convert the torch tensor to a list of lists\\n lut_data_list = lattice.permute(2,1,0,3).reshape(-1, 3).tolist()\\n\\n # Write the LUT data to the file\\n with open(fp, 'w') as file:\\n file.write(f\\\"LUT_3D_SIZE {lattice.size(0)}\\\\n\\\")\\n for entry in lut_data_list:\\n file.write(\\\" \\\".join(map(str, entry)) + \\\"\\\\n\\\")\\n\\n else:\\n raise Exception(\\\"Unsupported LUT format\\\")\\n\\n return True\"\n },\n {\n \"identifier\": \"_infer_lut_file_format\",\n \"path\": \"src/tinycio/fsio/lutfile.py\",\n \"snippet\": \"def _infer_lut_file_format(ext:str) -> LUTFormat:\\n ext = ext.strip().lower()\\n if ext == '.cube': return LUTFormat.CUBE_3D\\n else: return LUTFormat.UNKNOWN\"\n },\n {\n \"identifier\": \"_generate_linear_cube_lut\",\n \"path\": \"src/tinycio/fsio/lutfile.py\",\n \"snippet\": \"def _generate_linear_cube_lut(size: int):\\n \\\"\\\"\\\"\\n Generate a baseline linear cube LUT.\\n\\n :param size: Size of the cube LUT (e.g., 33 for a 33x33x33 cube).\\n :return: Torch tensor representing the linear cube LUT.\\n \\\"\\\"\\\"\\n linear_values = torch.linspace(0.0, 1.0, size)\\n grid = torch.meshgrid(linear_values, linear_values, linear_values, indexing=\\\"xy\\\")\\n lut_data = torch.stack(grid, dim=-1).permute(1,0,2,3) # TODO: WTF is even going on here?\\n return lut_data\"\n },\n {\n \"identifier\": \"LUTFormat\",\n \"path\": \"src/tinycio/fsio/format.py\",\n \"snippet\": \"class LUTFormat(IntEnum):\\n \\\"\\\"\\\"\\n Lookup table format. Available options are:\\n\\n .. highlight:: text\\n .. code-block:: text\\n \\n - UNKNOWN\\n - CUBE_3D\\n \\\"\\\"\\\"\\n UNKNOWN = 1<<0 # no color space specified - flag for guessing\\n CUBE_3D = 1<<1 # 3D CUBE LUT https://resolve.cafe/developers/luts/\\n\\n LUT_3D = CUBE_3D # | etc for later\"\n },\n {\n \"identifier\": \"srgb_luminance\",\n \"path\": \"src/tinycio/util/colorutil.py\",\n \"snippet\": \"def srgb_luminance(im_srgb:Union[torch.Tensor, ColorImage]) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Return relative luminance of linear sRGB image.\\n\\n :param im_srgb: [C=3, H, W] color image tensor in sRGB color space\\n :type im_srgb: torch.Tensor | ColorImage\\n :return: [C=1, H, W] image tensor\\n \\\"\\\"\\\"\\n lum_r, lum_g, lum_b = 0.2126, 0.7152, 0.0722\\n return lum_r * im_srgb[0:1,...] + lum_g * im_srgb[1:2,...] + lum_b * im_srgb[2:3,...]\"\n },\n {\n \"identifier\": \"trilinear_interpolation\",\n \"path\": \"src/tinycio/util/miscutil.py\",\n \"snippet\": \"def trilinear_interpolation(im_3d:torch.Tensor, indices:Union[ColorImage, torch.Tensor]) -> torch.Tensor:\\n \\\"\\\"\\\"\\n Interpolate 3D image tensor.\\n\\n :param im_3d: Input 3D image tensor of shape (C, D, H, W).\\n :param indices: Indices into the tensor.\\n :return: Interpolated color values.\\n \\\"\\\"\\\"\\n # NOTE: Internal - leaving this clutter undocumented intentionally\\n indices_floor = indices.floor().to(torch.long)\\n indices_ceil = indices.ceil().clamp(0, im_3d.size(0) - 1).to(torch.long)\\n\\n weights = (indices - indices_floor).float()\\n\\n c000 = im_3d[indices_floor[0], indices_floor[1], indices_floor[2]]\\n c001 = im_3d[indices_floor[0], indices_floor[1], indices_ceil[2]]\\n c010 = im_3d[indices_floor[0], indices_ceil[1], indices_floor[2]]\\n c011 = im_3d[indices_floor[0], indices_ceil[1], indices_ceil[2]]\\n c100 = im_3d[indices_ceil[0], indices_floor[1], indices_floor[2]]\\n c101 = im_3d[indices_ceil[0], indices_floor[1], indices_ceil[2]]\\n c110 = im_3d[indices_ceil[0], indices_ceil[1], indices_floor[2]]\\n c111 = im_3d[indices_ceil[0], indices_ceil[1], indices_ceil[2]]\\n\\n interpolated_values = torch.zeros_like(c000).requires_grad_()\\n interpolated_values = (\\n (1 - weights[0]) * (1 - weights[1]) * (1 - weights[2]) * c000.permute(2,0,1) +\\n (1 - weights[0]) * (1 - weights[1]) * weights[2] * c001.permute(2,0,1) +\\n (1 - weights[0]) * weights[1] * (1 - weights[2]) * c010.permute(2,0,1) +\\n (1 - weights[0]) * weights[1] * weights[2] * c011.permute(2,0,1) +\\n weights[0] * (1 - weights[1]) * (1 - weights[2]) * c100.permute(2,0,1) +\\n weights[0] * (1 - weights[1]) * weights[2] * c101.permute(2,0,1) +\\n weights[0] * weights[1] * (1 - weights[2]) * c110.permute(2,0,1) +\\n weights[0] * weights[1] * weights[2] * c111.permute(2,0,1)\\n )\\n\\n return interpolated_values\"\n },\n {\n \"identifier\": \"feature_moments_calculation\",\n \"path\": \"src/tinycio/loss.py\",\n \"snippet\": \"def feature_moments_calculation(feat, eps=1e-5):\\n # https://github.com/semchan/NLUT/blob/main/LICENSE\\n # MIT License\\n # <!-- Copyright (c) 2010, 2011 the Friendika Project -->\\n # All rights reserved.\\n\\n # Permission is hereby granted, free of charge, to any person obtaining a copy\\n # of this software and associated documentation files (the \\\"Software\\\"), to deal\\n # in the Software without restriction, including without limitation the rights\\n # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\\n # copies of the Software, and to permit persons to whom the Software is\\n # furnished to do so, subject to the following conditions:\\n\\n # The above copyright notice and this permission notice shall be included in\\n # all copies or substantial portions of the Software.\\n\\n # THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\\n # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\\n # THE SOFTWARE\\n size = feat.size()\\n assert (len(size) == 3)\\n N, C = size[:2]\\n feat_var = feat.view(N, C, -1).var(dim=2) + eps\\n # feat_std = feat_var.sqrt().view(N, C, 1, 1)\\n # the first order\\n feat_mean = feat.view(N, C, -1).mean(dim=2).view(N, C, 1)\\n\\n # the second order\\n feat_size = 2\\n # N, C = size[:2]\\n feat_p2 = torch.abs(feat-feat_mean).pow(feat_size).view(N, C, -1)\\n N, C,L = feat_p2.shape\\n feat_p2 = feat_p2.sum(dim=2)/L\\n feat_p2 = feat_p2.pow(1/feat_size).view(N, C, 1)\\n # the third order\\n feat_size = 3\\n # N, C = size[:2]\\n feat_p3 = torch.abs(feat-feat_mean).pow(feat_size).view(N, C, -1)\\n # N, C,L = feat_p3.shape\\n feat_p3 = feat_p3.sum(dim=2)/L\\n feat_p3 = feat_p3.pow(1/feat_size).view(N, C, 1)\\n\\n return feat_mean.view(N, C) , feat_p2.view(N, C), feat_p3.view(N, C)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import typing\nimport os \nimport torch\nimport torch.optim as optim\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom typing import Union\nfrom enum import IntEnum\nfrom contextlib import nullcontext\nfrom .colorspace import ColorSpace\nfrom .fsio.lutfile import load_lut, save_lut, _infer_lut_file_format, _generate_linear_cube_lut\nfrom .fsio.format import LUTFormat\nfrom .util.colorutil import srgb_luminance\nfrom .util.miscutil import trilinear_interpolation\nfrom .loss import feature_moments_calculation"},"token_num":{"kind":"number","value":17698,"string":"17,698"},"cropped_code":{"kind":"string","value":"from __future__ import annotations\n\n\n\nclass LookupTable:\n \"\"\"\n Color lookup table. Example:\n\n .. highlight:: python\n .. code-block:: python\n\n lut = LookupTable.get_negative()\n im_negative = lut.apply(im)\n\n :param size: Size of the LUT.\n :param lattice: Lattice as tensor (defaults to linear).\n :param lut_format: Format of the LUT.\n \"\"\"\n size = 32\n lattice = None\n"},"all_code":{"kind":"string","value":"from __future__ import annotations\n\n\n\nclass LookupTable:\n \"\"\"\n Color lookup table. Example:\n\n .. highlight:: python\n .. code-block:: python\n\n lut = LookupTable.get_negative()\n im_negative = lut.apply(im)\n\n :param size: Size of the LUT.\n :param lattice: Lattice as tensor (defaults to linear).\n :param lut_format: Format of the LUT.\n \"\"\"\n size = 32\n lattice = None"},"next_line":{"kind":"string","value":" lut_format= LUTFormat.UNKNOWN"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-12-15 15:39:08+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5678,"cells":{"repo_name":{"kind":"string","value":"quocanh34/magic-animate-modified"},"file_path":{"kind":"string","value":"magicanimate/pipelines/pipeline_animation.py"},"context":{"kind":"list like","value":[{"identifier":"UNet3DConditionModel","path":"magicanimate/models/unet_controlnet.py","snippet":"class UNet3DConditionModel(ModelMixin, ConfigMixin):\n _supports_gradient_checkpointing = True\n\n @register_to_config\n def __init__(\n self,\n sample_size: Optional[int] = None,\n in_channels: int = 4,\n out_channels: int = 4,\n center_input_sample: bool = False,\n flip_sin_to_cos: bool = True,\n freq_shift: int = 0, \n down_block_types: Tuple[str] = (\n \"CrossAttnDownBlock3D\",\n \"CrossAttnDownBlock3D\",\n \"CrossAttnDownBlock3D\",\n \"DownBlock3D\",\n ),\n mid_block_type: str = \"UNetMidBlock3DCrossAttn\",\n up_block_types: Tuple[str] = (\n \"UpBlock3D\",\n \"CrossAttnUpBlock3D\",\n \"CrossAttnUpBlock3D\",\n \"CrossAttnUpBlock3D\"\n ),\n only_cross_attention: Union[bool, Tuple[bool]] = False,\n block_out_channels: Tuple[int] = (320, 640, 1280, 1280),\n layers_per_block: int = 2,\n downsample_padding: int = 1,\n mid_block_scale_factor: float = 1,\n act_fn: str = \"silu\",\n norm_num_groups: int = 32,\n norm_eps: float = 1e-5,\n cross_attention_dim: int = 1280,\n attention_head_dim: Union[int, Tuple[int]] = 8,\n dual_cross_attention: bool = False,\n use_linear_projection: bool = False,\n class_embed_type: Optional[str] = None,\n num_class_embeds: Optional[int] = None,\n upcast_attention: bool = False,\n resnet_time_scale_shift: str = \"default\",\n \n # Additional\n use_motion_module = False,\n motion_module_resolutions = ( 1,2,4,8 ),\n motion_module_mid_block = False,\n motion_module_decoder_only = False,\n motion_module_type = None,\n motion_module_kwargs = {},\n unet_use_cross_frame_attention = None,\n unet_use_temporal_attention = None,\n ):\n super().__init__()\n\n self.sample_size = sample_size\n time_embed_dim = block_out_channels[0] * 4\n\n # input\n self.conv_in = InflatedConv3d(in_channels, block_out_channels[0], kernel_size=3, padding=(1, 1))\n\n # time\n self.time_proj = Timesteps(block_out_channels[0], flip_sin_to_cos, freq_shift)\n timestep_input_dim = block_out_channels[0]\n\n self.time_embedding = TimestepEmbedding(timestep_input_dim, time_embed_dim)\n\n # class embedding\n if class_embed_type is None and num_class_embeds is not None:\n self.class_embedding = nn.Embedding(num_class_embeds, time_embed_dim)\n elif class_embed_type == \"timestep\":\n self.class_embedding = TimestepEmbedding(timestep_input_dim, time_embed_dim)\n elif class_embed_type == \"identity\":\n self.class_embedding = nn.Identity(time_embed_dim, time_embed_dim)\n else:\n self.class_embedding = None\n\n self.down_blocks = nn.ModuleList([])\n self.mid_block = None\n self.up_blocks = nn.ModuleList([])\n\n if isinstance(only_cross_attention, bool):\n only_cross_attention = [only_cross_attention] * len(down_block_types)\n\n if isinstance(attention_head_dim, int):\n attention_head_dim = (attention_head_dim,) * len(down_block_types)\n\n # down\n output_channel = block_out_channels[0]\n for i, down_block_type in enumerate(down_block_types):\n res = 2 ** i\n input_channel = output_channel\n output_channel = block_out_channels[i]\n is_final_block = i == len(block_out_channels) - 1\n\n down_block = get_down_block(\n down_block_type,\n num_layers=layers_per_block,\n in_channels=input_channel,\n out_channels=output_channel,\n temb_channels=time_embed_dim,\n add_downsample=not is_final_block,\n resnet_eps=norm_eps,\n resnet_act_fn=act_fn,\n resnet_groups=norm_num_groups,\n cross_attention_dim=cross_attention_dim,\n attn_num_head_channels=attention_head_dim[i],\n downsample_padding=downsample_padding,\n dual_cross_attention=dual_cross_attention,\n use_linear_projection=use_linear_projection,\n only_cross_attention=only_cross_attention[i],\n upcast_attention=upcast_attention,\n resnet_time_scale_shift=resnet_time_scale_shift,\n\n unet_use_cross_frame_attention=unet_use_cross_frame_attention,\n unet_use_temporal_attention=unet_use_temporal_attention,\n \n use_motion_module=use_motion_module and (res in motion_module_resolutions) and (not motion_module_decoder_only),\n motion_module_type=motion_module_type,\n motion_module_kwargs=motion_module_kwargs,\n )\n self.down_blocks.append(down_block)\n\n # mid\n if mid_block_type == \"UNetMidBlock3DCrossAttn\":\n self.mid_block = UNetMidBlock3DCrossAttn(\n in_channels=block_out_channels[-1],\n temb_channels=time_embed_dim,\n resnet_eps=norm_eps,\n resnet_act_fn=act_fn,\n output_scale_factor=mid_block_scale_factor,\n resnet_time_scale_shift=resnet_time_scale_shift,\n cross_attention_dim=cross_attention_dim,\n attn_num_head_channels=attention_head_dim[-1],\n resnet_groups=norm_num_groups,\n dual_cross_attention=dual_cross_attention,\n use_linear_projection=use_linear_projection,\n upcast_attention=upcast_attention,\n\n unet_use_cross_frame_attention=unet_use_cross_frame_attention,\n unet_use_temporal_attention=unet_use_temporal_attention,\n \n use_motion_module=use_motion_module and motion_module_mid_block,\n motion_module_type=motion_module_type,\n motion_module_kwargs=motion_module_kwargs,\n )\n else:\n raise ValueError(f\"unknown mid_block_type : {mid_block_type}\")\n \n # count how many layers upsample the videos\n self.num_upsamplers = 0\n\n # up\n reversed_block_out_channels = list(reversed(block_out_channels))\n reversed_attention_head_dim = list(reversed(attention_head_dim))\n only_cross_attention = list(reversed(only_cross_attention))\n output_channel = reversed_block_out_channels[0]\n for i, up_block_type in enumerate(up_block_types):\n res = 2 ** (3 - i)\n is_final_block = i == len(block_out_channels) - 1\n\n prev_output_channel = output_channel\n output_channel = reversed_block_out_channels[i]\n input_channel = reversed_block_out_channels[min(i + 1, len(block_out_channels) - 1)]\n\n # add upsample block for all BUT final layer\n if not is_final_block:\n add_upsample = True\n self.num_upsamplers += 1\n else:\n add_upsample = False\n\n up_block = get_up_block(\n up_block_type,\n num_layers=layers_per_block + 1,\n in_channels=input_channel,\n out_channels=output_channel,\n prev_output_channel=prev_output_channel,\n temb_channels=time_embed_dim,\n add_upsample=add_upsample,\n resnet_eps=norm_eps,\n resnet_act_fn=act_fn,\n resnet_groups=norm_num_groups,\n cross_attention_dim=cross_attention_dim,\n attn_num_head_channels=reversed_attention_head_dim[i],\n dual_cross_attention=dual_cross_attention,\n use_linear_projection=use_linear_projection,\n only_cross_attention=only_cross_attention[i],\n upcast_attention=upcast_attention,\n resnet_time_scale_shift=resnet_time_scale_shift,\n\n unet_use_cross_frame_attention=unet_use_cross_frame_attention,\n unet_use_temporal_attention=unet_use_temporal_attention,\n\n use_motion_module=use_motion_module and (res in motion_module_resolutions),\n motion_module_type=motion_module_type,\n motion_module_kwargs=motion_module_kwargs,\n )\n self.up_blocks.append(up_block)\n prev_output_channel = output_channel\n\n # out\n self.conv_norm_out = nn.GroupNorm(num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=norm_eps)\n self.conv_act = nn.SiLU()\n self.conv_out = InflatedConv3d(block_out_channels[0], out_channels, kernel_size=3, padding=1)\n\n def set_attention_slice(self, slice_size):\n r\"\"\"\n Enable sliced attention computation.\n\n When this option is enabled, the attention module will split the input tensor in slices, to compute attention\n in several steps. This is useful to save some memory in exchange for a small speed decrease.\n\n Args:\n slice_size (`str` or `int` or `list(int)`, *optional*, defaults to `\"auto\"`):\n When `\"auto\"`, halves the input to the attention heads, so attention will be computed in two steps. If\n `\"max\"`, maxium amount of memory will be saved by running only one slice at a time. If a number is\n provided, uses as many slices as `attention_head_dim // slice_size`. In this case, `attention_head_dim`\n must be a multiple of `slice_size`.\n \"\"\"\n sliceable_head_dims = []\n\n def fn_recursive_retrieve_slicable_dims(module: torch.nn.Module):\n if hasattr(module, \"set_attention_slice\"):\n sliceable_head_dims.append(module.sliceable_head_dim)\n\n for child in module.children():\n fn_recursive_retrieve_slicable_dims(child)\n\n # retrieve number of attention layers\n for module in self.children():\n fn_recursive_retrieve_slicable_dims(module)\n\n num_slicable_layers = len(sliceable_head_dims)\n\n if slice_size == \"auto\":\n # half the attention head size is usually a good trade-off between\n # speed and memory\n slice_size = [dim // 2 for dim in sliceable_head_dims]\n elif slice_size == \"max\":\n # make smallest slice possible\n slice_size = num_slicable_layers * [1]\n\n slice_size = num_slicable_layers * [slice_size] if not isinstance(slice_size, list) else slice_size\n\n if len(slice_size) != len(sliceable_head_dims):\n raise ValueError(\n f\"You have provided {len(slice_size)}, but {self.config} has {len(sliceable_head_dims)} different\"\n f\" attention layers. Make sure to match `len(slice_size)` to be {len(sliceable_head_dims)}.\"\n )\n\n for i in range(len(slice_size)):\n size = slice_size[i]\n dim = sliceable_head_dims[i]\n if size is not None and size > dim:\n raise ValueError(f\"size {size} has to be smaller or equal to {dim}.\")\n\n # Recursively walk through all the children.\n # Any children which exposes the set_attention_slice method\n # gets the message\n def fn_recursive_set_attention_slice(module: torch.nn.Module, slice_size: List[int]):\n if hasattr(module, \"set_attention_slice\"):\n module.set_attention_slice(slice_size.pop())\n\n for child in module.children():\n fn_recursive_set_attention_slice(child, slice_size)\n\n reversed_slice_size = list(reversed(slice_size))\n for module in self.children():\n fn_recursive_set_attention_slice(module, reversed_slice_size)\n\n def _set_gradient_checkpointing(self, module, value=False):\n if isinstance(module, (CrossAttnDownBlock3D, DownBlock3D, CrossAttnUpBlock3D, UpBlock3D)):\n module.gradient_checkpointing = value\n\n def forward(\n self,\n sample: torch.FloatTensor,\n timestep: Union[torch.Tensor, float, int],\n encoder_hidden_states: torch.Tensor,\n class_labels: Optional[torch.Tensor] = None,\n attention_mask: Optional[torch.Tensor] = None,\n # for controlnet\n down_block_additional_residuals: Optional[Tuple[torch.Tensor]] = None,\n mid_block_additional_residual: Optional[torch.Tensor] = None,\n return_dict: bool = True,\n ) -> Union[UNet3DConditionOutput, Tuple]:\n r\"\"\"\n Args:\n sample (`torch.FloatTensor`): (batch, channel, height, width) noisy inputs tensor\n timestep (`torch.FloatTensor` or `float` or `int`): (batch) timesteps\n encoder_hidden_states (`torch.FloatTensor`): (batch, sequence_length, feature_dim) encoder hidden states\n return_dict (`bool`, *optional*, defaults to `True`):\n Whether or not to return a [`models.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple.\n\n Returns:\n [`~models.unet_2d_condition.UNet2DConditionOutput`] or `tuple`:\n [`~models.unet_2d_condition.UNet2DConditionOutput`] if `return_dict` is True, otherwise a `tuple`. When\n returning a tuple, the first element is the sample tensor.\n \"\"\"\n # By default samples have to be AT least a multiple of the overall upsampling factor.\n # The overall upsampling factor is equal to 2 ** (# num of upsampling layears).\n # However, the upsampling interpolation output size can be forced to fit any upsampling size\n # on the fly if necessary.\n default_overall_up_factor = 2**self.num_upsamplers\n\n # upsample size should be forwarded when sample is not a multiple of `default_overall_up_factor`\n forward_upsample_size = False\n upsample_size = None\n\n if any(s % default_overall_up_factor != 0 for s in sample.shape[-2:]):\n logger.info(\"Forward upsample size to force interpolation output size.\")\n forward_upsample_size = True\n\n # prepare attention_mask\n if attention_mask is not None:\n attention_mask = (1 - attention_mask.to(sample.dtype)) * -10000.0\n attention_mask = attention_mask.unsqueeze(1)\n\n # center input if necessary\n if self.config.center_input_sample:\n sample = 2 * sample - 1.0\n\n # time\n timesteps = timestep\n if not torch.is_tensor(timesteps):\n # This would be a good case for the `match` statement (Python 3.10+)\n is_mps = sample.device.type == \"mps\"\n if isinstance(timestep, float):\n dtype = torch.float32 if is_mps else torch.float64\n else:\n dtype = torch.int32 if is_mps else torch.int64\n timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device)\n elif len(timesteps.shape) == 0:\n timesteps = timesteps[None].to(sample.device)\n\n # broadcast to batch dimension in a way that's compatible with ONNX/Core ML\n timesteps = timesteps.expand(sample.shape[0])\n\n t_emb = self.time_proj(timesteps)\n\n # timesteps does not contain any weights and will always return f32 tensors\n # but time_embedding might actually be running in fp16. so we need to cast here.\n # there might be better ways to encapsulate this.\n t_emb = t_emb.to(dtype=self.dtype)\n emb = self.time_embedding(t_emb)\n\n if self.class_embedding is not None:\n if class_labels is None:\n raise ValueError(\"class_labels should be provided when num_class_embeds > 0\")\n\n if self.config.class_embed_type == \"timestep\":\n class_labels = self.time_proj(class_labels)\n\n class_emb = self.class_embedding(class_labels).to(dtype=self.dtype)\n emb = emb + class_emb\n\n # pre-process\n sample = self.conv_in(sample)\n\n # down\n is_controlnet = mid_block_additional_residual is not None and down_block_additional_residuals is not None\n\n down_block_res_samples = (sample,)\n for downsample_block in self.down_blocks:\n if hasattr(downsample_block, \"has_cross_attention\") and downsample_block.has_cross_attention:\n sample, res_samples = downsample_block(\n hidden_states=sample,\n temb=emb,\n encoder_hidden_states=encoder_hidden_states,\n attention_mask=attention_mask,\n )\n else:\n sample, res_samples = downsample_block(hidden_states=sample, temb=emb, encoder_hidden_states=encoder_hidden_states)\n\n down_block_res_samples += res_samples\n\n if is_controlnet:\n new_down_block_res_samples = ()\n\n for down_block_res_sample, down_block_additional_residual in zip(\n down_block_res_samples, down_block_additional_residuals\n ):\n down_block_res_sample = down_block_res_sample + down_block_additional_residual\n new_down_block_res_samples = new_down_block_res_samples + (down_block_res_sample,)\n\n down_block_res_samples = new_down_block_res_samples\n\n # mid\n sample = self.mid_block(\n sample, emb, encoder_hidden_states=encoder_hidden_states, attention_mask=attention_mask\n )\n\n if is_controlnet:\n sample = sample + mid_block_additional_residual\n\n # up\n for i, upsample_block in enumerate(self.up_blocks):\n is_final_block = i == len(self.up_blocks) - 1\n\n res_samples = down_block_res_samples[-len(upsample_block.resnets) :]\n down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]\n\n # if we have not reached the final block and need to forward the\n # upsample size, we do it here\n if not is_final_block and forward_upsample_size:\n upsample_size = down_block_res_samples[-1].shape[2:]\n\n if hasattr(upsample_block, \"has_cross_attention\") and upsample_block.has_cross_attention:\n sample = upsample_block(\n hidden_states=sample,\n temb=emb,\n res_hidden_states_tuple=res_samples,\n encoder_hidden_states=encoder_hidden_states,\n upsample_size=upsample_size,\n attention_mask=attention_mask,\n )\n else:\n sample = upsample_block(\n hidden_states=sample, temb=emb, res_hidden_states_tuple=res_samples, upsample_size=upsample_size, encoder_hidden_states=encoder_hidden_states,\n )\n\n # post-process\n sample = self.conv_norm_out(sample)\n sample = self.conv_act(sample)\n sample = self.conv_out(sample)\n\n if not return_dict:\n return (sample,)\n\n return UNet3DConditionOutput(sample=sample)\n\n @classmethod\n def from_pretrained_2d(cls, pretrained_model_path, subfolder=None, unet_additional_kwargs=None):\n if subfolder is not None:\n pretrained_model_path = os.path.join(pretrained_model_path, subfolder)\n print(f\"loaded temporal unet's pretrained weights from {pretrained_model_path} ...\")\n\n config_file = os.path.join(pretrained_model_path, 'config.json')\n if not os.path.isfile(config_file):\n raise RuntimeError(f\"{config_file} does not exist\")\n with open(config_file, \"r\") as f:\n config = json.load(f)\n config[\"_class_name\"] = cls.__name__\n config[\"down_block_types\"] = [\n \"CrossAttnDownBlock3D\",\n \"CrossAttnDownBlock3D\",\n \"CrossAttnDownBlock3D\",\n \"DownBlock3D\"\n ]\n config[\"up_block_types\"] = [\n \"UpBlock3D\",\n \"CrossAttnUpBlock3D\",\n \"CrossAttnUpBlock3D\",\n \"CrossAttnUpBlock3D\"\n ]\n # config[\"mid_block_type\"] = \"UNetMidBlock3DCrossAttn\"\n\n from diffusers.utils import WEIGHTS_NAME\n model = cls.from_config(config, **unet_additional_kwargs)\n model_file = os.path.join(pretrained_model_path, WEIGHTS_NAME)\n if not os.path.isfile(model_file):\n raise RuntimeError(f\"{model_file} does not exist\")\n state_dict = torch.load(model_file, map_location=\"cpu\")\n\n m, u = model.load_state_dict(state_dict, strict=False)\n print(f\"### missing keys: {len(m)}; \\n### unexpected keys: {len(u)};\")\n # print(f\"### missing keys:\\n{m}\\n### unexpected keys:\\n{u}\\n\")\n \n params = [p.numel() if \"temporal\" in n else 0 for n, p in model.named_parameters()]\n print(f\"### Temporal Module Parameters: {sum(params) / 1e6} M\")\n \n return model"},{"identifier":"ControlNetProcessor","path":"magicanimate/models/multicontrolnet.py","snippet":"class ControlNetProcessor(object):\n def __init__(\n self,\n controlnet: ControlNetModel,\n # image: Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]],\n # controlnet_cond = torch.FloatTensor, #fix\n # conditioning_scale: float = 1.0,\n ):\n self.controlnet = controlnet\n # self.image = image\n # self.controlnet_cond = controlnet_cond #fix\n # self.conditioning_scale = conditioning_scale\n\n # def _default_height_width(self, height, width, image):\n # if isinstance(image, list):\n # image = image[0]\n\n # if height is None:\n # if isinstance(image, PIL.Image.Image):\n # height = image.height\n # elif isinstance(image, torch.Tensor):\n # height = image.shape[3]\n\n # height = (height // 8) * 8 # round down to nearest multiple of 8\n\n # if width is None:\n # if isinstance(image, PIL.Image.Image):\n # width = image.width\n # elif isinstance(image, torch.Tensor):\n # width = image.shape[2]\n\n # width = (width // 8) * 8 # round down to nearest multiple of 8\n\n # return height, width\n\n # def default_height_width(self, height, width):\n # return self._default_height_width(height, width, self.image)\n\n # def _prepare_image(self, image, width, height, batch_size, num_images_per_prompt, device, dtype):\n # if not isinstance(image, torch.Tensor):\n # if isinstance(image, PIL.Image.Image):\n # image = [image]\n\n # if isinstance(image[0], PIL.Image.Image):\n # image = [\n # np.array(i.resize((width, height), resample=PIL_INTERPOLATION[\"lanczos\"]))[None, :] for i in image\n # ]\n # image = np.concatenate(image, axis=0)\n # image = np.array(image).astype(np.float32) / 255.0\n # image = image.transpose(0, 3, 1, 2)\n # image = torch.from_numpy(image)\n # elif isinstance(image[0], torch.Tensor):\n # image = torch.cat(image, dim=0)\n\n # image_batch_size = image.shape[0]\n\n # if image_batch_size == 1:\n # repeat_by = batch_size\n # else:\n # # image batch size is the same as prompt batch size\n # repeat_by = num_images_per_prompt\n\n # image = image.repeat_interleave(repeat_by, dim=0)\n\n # image = image.to(device=device, dtype=dtype)\n\n # return image\n\n # def _check_inputs(self, image, prompt, prompt_embeds):\n # image_is_pil = isinstance(image, PIL.Image.Image)\n # image_is_tensor = isinstance(image, torch.Tensor)\n # image_is_pil_list = isinstance(image, list) and isinstance(image[0], PIL.Image.Image)\n # image_is_tensor_list = isinstance(image, list) and isinstance(image[0], torch.Tensor)\n\n # if not image_is_pil and not image_is_tensor and not image_is_pil_list and not image_is_tensor_list:\n # raise TypeError(\n # \"image must be passed and be one of PIL image, torch tensor, list of PIL images, or list of torch tensors\"\n # )\n\n # if image_is_pil:\n # image_batch_size = 1\n # elif image_is_tensor:\n # image_batch_size = image.shape[0]\n # elif image_is_pil_list:\n # image_batch_size = len(image)\n # elif image_is_tensor_list:\n # image_batch_size = len(image)\n\n # if prompt is not None and isinstance(prompt, str):\n # prompt_batch_size = 1\n # elif prompt is not None and isinstance(prompt, list):\n # prompt_batch_size = len(prompt)\n # elif prompt_embeds is not None:\n # prompt_batch_size = prompt_embeds.shape[0]\n\n # if image_batch_size != 1 and image_batch_size != prompt_batch_size:\n # raise ValueError(\n # f\"If image batch size is not 1, image batch size must be same as prompt batch size. image batch size: {image_batch_size}, prompt batch size: {prompt_batch_size}\"\n # )\n\n # def check_inputs(self, prompt, prompt_embeds):\n # self._check_inputs(self.image, prompt, prompt_embeds)\n\n # def prepare_image(self, width, height, batch_size, num_images_per_prompt, device, do_classifier_free_guidance):\n # self.image = self._prepare_image(\n # self.image, width, height, batch_size, num_images_per_prompt, device, self.controlnet.dtype\n # )\n # if do_classifier_free_guidance:\n # self.image = torch.cat([self.image] * 2)\n\n def __call__(\n self,\n controlnet_latent_input,\n t,\n encoder_hidden_states,\n controlnet_cond, #fix\n conditioning_scale,\n return_dict,\n ) -> Tuple:\n down_block_res_samples, mid_block_res_sample = self.controlnet(\n controlnet_latent_input,\n t,\n encoder_hidden_states,\n controlnet_cond,\n conditioning_scale, \n return_dict=False,\n )\n down_block_res_samples = [\n down_block_res_sample * conditioning_scale for down_block_res_sample in down_block_res_samples\n ]\n mid_block_res_sample *= conditioning_scale\n return (down_block_res_samples, mid_block_res_sample)"},{"identifier":"ReferenceAttentionControl","path":"magicanimate/models/mutual_self_attention.py","snippet":"class ReferenceAttentionControl():\n \n def __init__(self, \n unet,\n mode=\"write\",\n do_classifier_free_guidance=False,\n attention_auto_machine_weight = float('inf'),\n gn_auto_machine_weight = 1.0,\n style_fidelity = 1.0,\n reference_attn=True,\n reference_adain=False,\n fusion_blocks=\"midup\",\n batch_size=1, \n ) -> None:\n # 10. Modify self attention and group norm\n self.unet = unet\n assert mode in [\"read\", \"write\"]\n assert fusion_blocks in [\"midup\", \"full\"]\n self.reference_attn = reference_attn\n self.reference_adain = reference_adain\n self.fusion_blocks = fusion_blocks\n self.register_reference_hooks(\n mode, \n do_classifier_free_guidance,\n attention_auto_machine_weight,\n gn_auto_machine_weight,\n style_fidelity,\n reference_attn,\n reference_adain,\n fusion_blocks,\n batch_size=batch_size, \n )\n\n def register_reference_hooks(\n self, \n mode, \n do_classifier_free_guidance,\n attention_auto_machine_weight,\n gn_auto_machine_weight,\n style_fidelity,\n reference_attn,\n reference_adain,\n dtype=torch.float16,\n batch_size=1, \n num_images_per_prompt=1, \n device=torch.device(\"cpu\"), \n fusion_blocks='midup',\n ):\n MODE = mode\n do_classifier_free_guidance = do_classifier_free_guidance\n attention_auto_machine_weight = attention_auto_machine_weight\n gn_auto_machine_weight = gn_auto_machine_weight\n style_fidelity = style_fidelity\n reference_attn = reference_attn\n reference_adain = reference_adain\n fusion_blocks = fusion_blocks\n num_images_per_prompt = num_images_per_prompt\n dtype=dtype\n if do_classifier_free_guidance:\n uc_mask = (\n torch.Tensor([1] * batch_size * num_images_per_prompt * 16 + [0] * batch_size * num_images_per_prompt * 16)\n .to(device)\n .bool()\n )\n else:\n uc_mask = (\n torch.Tensor([0] * batch_size * num_images_per_prompt * 2)\n .to(device)\n .bool()\n )\n \n def hacked_basic_transformer_inner_forward(\n self,\n hidden_states: torch.FloatTensor,\n attention_mask: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.FloatTensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n timestep: Optional[torch.LongTensor] = None,\n cross_attention_kwargs: Dict[str, Any] = None,\n class_labels: Optional[torch.LongTensor] = None,\n video_length=None,\n ):\n if self.use_ada_layer_norm:\n norm_hidden_states = self.norm1(hidden_states, timestep)\n elif self.use_ada_layer_norm_zero:\n norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1(\n hidden_states, timestep, class_labels, hidden_dtype=hidden_states.dtype\n )\n else:\n norm_hidden_states = self.norm1(hidden_states)\n\n # 1. Self-Attention\n cross_attention_kwargs = cross_attention_kwargs if cross_attention_kwargs is not None else {}\n if self.only_cross_attention:\n attn_output = self.attn1(\n norm_hidden_states,\n encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None,\n attention_mask=attention_mask,\n **cross_attention_kwargs,\n )\n else:\n if MODE == \"write\":\n self.bank.append(norm_hidden_states.clone())\n attn_output = self.attn1(\n norm_hidden_states,\n encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None,\n attention_mask=attention_mask,\n **cross_attention_kwargs,\n )\n if MODE == \"read\":\n self.bank = [rearrange(d.unsqueeze(1).repeat(1, video_length, 1, 1), \"b t l c -> (b t) l c\")[:hidden_states.shape[0]] for d in self.bank]\n hidden_states_uc = self.attn1(norm_hidden_states, \n encoder_hidden_states=torch.cat([norm_hidden_states] + self.bank, dim=1),\n attention_mask=attention_mask) + hidden_states\n hidden_states_c = hidden_states_uc.clone()\n _uc_mask = uc_mask.clone()\n if do_classifier_free_guidance:\n if hidden_states.shape[0] != _uc_mask.shape[0]:\n _uc_mask = (\n torch.Tensor([1] * (hidden_states.shape[0]//2) + [0] * (hidden_states.shape[0]//2))\n .to(device)\n .bool()\n )\n hidden_states_c[_uc_mask] = self.attn1(\n norm_hidden_states[_uc_mask],\n encoder_hidden_states=norm_hidden_states[_uc_mask],\n attention_mask=attention_mask,\n ) + hidden_states[_uc_mask]\n hidden_states = hidden_states_c.clone()\n \n self.bank.clear()\n if self.attn2 is not None:\n # Cross-Attention\n norm_hidden_states = (\n self.norm2(hidden_states, timestep) if self.use_ada_layer_norm else self.norm2(hidden_states)\n )\n hidden_states = (\n self.attn2(\n norm_hidden_states, encoder_hidden_states=encoder_hidden_states, attention_mask=attention_mask\n )\n + hidden_states\n )\n\n # Feed-forward\n hidden_states = self.ff(self.norm3(hidden_states)) + hidden_states\n\n # Temporal-Attention\n if self.unet_use_temporal_attention:\n d = hidden_states.shape[1]\n hidden_states = rearrange(hidden_states, \"(b f) d c -> (b d) f c\", f=video_length)\n norm_hidden_states = (\n self.norm_temp(hidden_states, timestep) if self.use_ada_layer_norm else self.norm_temp(hidden_states)\n )\n hidden_states = self.attn_temp(norm_hidden_states) + hidden_states\n hidden_states = rearrange(hidden_states, \"(b d) f c -> (b f) d c\", d=d)\n\n return hidden_states\n \n if self.use_ada_layer_norm_zero:\n attn_output = gate_msa.unsqueeze(1) * attn_output\n hidden_states = attn_output + hidden_states\n\n if self.attn2 is not None:\n norm_hidden_states = (\n self.norm2(hidden_states, timestep) if self.use_ada_layer_norm else self.norm2(hidden_states)\n )\n\n # 2. Cross-Attention\n attn_output = self.attn2(\n norm_hidden_states,\n encoder_hidden_states=encoder_hidden_states,\n attention_mask=encoder_attention_mask,\n **cross_attention_kwargs,\n )\n hidden_states = attn_output + hidden_states\n\n # 3. Feed-forward\n norm_hidden_states = self.norm3(hidden_states)\n\n if self.use_ada_layer_norm_zero:\n norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]\n\n ff_output = self.ff(norm_hidden_states)\n\n if self.use_ada_layer_norm_zero:\n ff_output = gate_mlp.unsqueeze(1) * ff_output\n\n hidden_states = ff_output + hidden_states\n\n return hidden_states\n\n def hacked_mid_forward(self, *args, **kwargs):\n eps = 1e-6\n x = self.original_forward(*args, **kwargs)\n if MODE == \"write\":\n if gn_auto_machine_weight >= self.gn_weight:\n var, mean = torch.var_mean(x, dim=(2, 3), keepdim=True, correction=0)\n self.mean_bank.append(mean)\n self.var_bank.append(var)\n if MODE == \"read\":\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\n var, mean = torch.var_mean(x, dim=(2, 3), keepdim=True, correction=0)\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\n mean_acc = sum(self.mean_bank) / float(len(self.mean_bank))\n var_acc = sum(self.var_bank) / float(len(self.var_bank))\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\n x_uc = (((x - mean) / std) * std_acc) + mean_acc\n x_c = x_uc.clone()\n if do_classifier_free_guidance and style_fidelity > 0:\n x_c[uc_mask] = x[uc_mask]\n x = style_fidelity * x_c + (1.0 - style_fidelity) * x_uc\n self.mean_bank = []\n self.var_bank = []\n return x\n\n def hack_CrossAttnDownBlock2D_forward(\n self,\n hidden_states: torch.FloatTensor,\n temb: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.FloatTensor] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n ):\n eps = 1e-6\n\n # TODO(Patrick, William) - attention mask is not used\n output_states = ()\n\n for i, (resnet, attn) in enumerate(zip(self.resnets, self.attentions)):\n hidden_states = resnet(hidden_states, temb)\n hidden_states = attn(\n hidden_states,\n encoder_hidden_states=encoder_hidden_states,\n cross_attention_kwargs=cross_attention_kwargs,\n attention_mask=attention_mask,\n encoder_attention_mask=encoder_attention_mask,\n return_dict=False,\n )[0]\n if MODE == \"write\":\n if gn_auto_machine_weight >= self.gn_weight:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n self.mean_bank.append([mean])\n self.var_bank.append([var])\n if MODE == \"read\":\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\n hidden_states_c = hidden_states_uc.clone()\n if do_classifier_free_guidance and style_fidelity > 0:\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\n\n output_states = output_states + (hidden_states,)\n\n if MODE == \"read\":\n self.mean_bank = []\n self.var_bank = []\n\n if self.downsamplers is not None:\n for downsampler in self.downsamplers:\n hidden_states = downsampler(hidden_states)\n\n output_states = output_states + (hidden_states,)\n\n return hidden_states, output_states\n\n def hacked_DownBlock2D_forward(self, hidden_states, temb=None):\n eps = 1e-6\n\n output_states = ()\n\n for i, resnet in enumerate(self.resnets):\n hidden_states = resnet(hidden_states, temb)\n\n if MODE == \"write\":\n if gn_auto_machine_weight >= self.gn_weight:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n self.mean_bank.append([mean])\n self.var_bank.append([var])\n if MODE == \"read\":\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\n hidden_states_c = hidden_states_uc.clone()\n if do_classifier_free_guidance and style_fidelity > 0:\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\n\n output_states = output_states + (hidden_states,)\n\n if MODE == \"read\":\n self.mean_bank = []\n self.var_bank = []\n\n if self.downsamplers is not None:\n for downsampler in self.downsamplers:\n hidden_states = downsampler(hidden_states)\n\n output_states = output_states + (hidden_states,)\n\n return hidden_states, output_states\n\n def hacked_CrossAttnUpBlock2D_forward(\n self,\n hidden_states: torch.FloatTensor,\n res_hidden_states_tuple: Tuple[torch.FloatTensor, ...],\n temb: Optional[torch.FloatTensor] = None,\n encoder_hidden_states: Optional[torch.FloatTensor] = None,\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\n upsample_size: Optional[int] = None,\n attention_mask: Optional[torch.FloatTensor] = None,\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\n ):\n eps = 1e-6\n # TODO(Patrick, William) - attention mask is not used\n for i, (resnet, attn) in enumerate(zip(self.resnets, self.attentions)):\n # pop res hidden states\n res_hidden_states = res_hidden_states_tuple[-1]\n res_hidden_states_tuple = res_hidden_states_tuple[:-1]\n hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)\n hidden_states = resnet(hidden_states, temb)\n hidden_states = attn(\n hidden_states,\n encoder_hidden_states=encoder_hidden_states,\n cross_attention_kwargs=cross_attention_kwargs,\n attention_mask=attention_mask,\n encoder_attention_mask=encoder_attention_mask,\n return_dict=False,\n )[0]\n\n if MODE == \"write\":\n if gn_auto_machine_weight >= self.gn_weight:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n self.mean_bank.append([mean])\n self.var_bank.append([var])\n if MODE == \"read\":\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\n hidden_states_c = hidden_states_uc.clone()\n if do_classifier_free_guidance and style_fidelity > 0:\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\n\n if MODE == \"read\":\n self.mean_bank = []\n self.var_bank = []\n\n if self.upsamplers is not None:\n for upsampler in self.upsamplers:\n hidden_states = upsampler(hidden_states, upsample_size)\n\n return hidden_states\n\n def hacked_UpBlock2D_forward(self, hidden_states, res_hidden_states_tuple, temb=None, upsample_size=None):\n eps = 1e-6\n for i, resnet in enumerate(self.resnets):\n # pop res hidden states\n res_hidden_states = res_hidden_states_tuple[-1]\n res_hidden_states_tuple = res_hidden_states_tuple[:-1]\n hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)\n hidden_states = resnet(hidden_states, temb)\n\n if MODE == \"write\":\n if gn_auto_machine_weight >= self.gn_weight:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n self.mean_bank.append([mean])\n self.var_bank.append([var])\n if MODE == \"read\":\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\n hidden_states_c = hidden_states_uc.clone()\n if do_classifier_free_guidance and style_fidelity > 0:\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\n\n if MODE == \"read\":\n self.mean_bank = []\n self.var_bank = []\n\n if self.upsamplers is not None:\n for upsampler in self.upsamplers:\n hidden_states = upsampler(hidden_states, upsample_size)\n\n return hidden_states\n\n if self.reference_attn:\n if self.fusion_blocks == \"midup\":\n attn_modules = [module for module in (torch_dfs(self.unet.mid_block)+torch_dfs(self.unet.up_blocks)) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)]\n elif self.fusion_blocks == \"full\":\n attn_modules = [module for module in torch_dfs(self.unet) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)] \n attn_modules = sorted(attn_modules, key=lambda x: -x.norm1.normalized_shape[0])\n\n for i, module in enumerate(attn_modules):\n module._original_inner_forward = module.forward\n module.forward = hacked_basic_transformer_inner_forward.__get__(module, BasicTransformerBlock)\n module.bank = []\n module.attn_weight = float(i) / float(len(attn_modules))\n\n if self.reference_adain:\n gn_modules = [self.unet.mid_block]\n self.unet.mid_block.gn_weight = 0\n\n down_blocks = self.unet.down_blocks\n for w, module in enumerate(down_blocks):\n module.gn_weight = 1.0 - float(w) / float(len(down_blocks))\n gn_modules.append(module)\n\n up_blocks = self.unet.up_blocks\n for w, module in enumerate(up_blocks):\n module.gn_weight = float(w) / float(len(up_blocks))\n gn_modules.append(module)\n\n for i, module in enumerate(gn_modules):\n if getattr(module, \"original_forward\", None) is None:\n module.original_forward = module.forward\n if i == 0:\n # mid_block\n module.forward = hacked_mid_forward.__get__(module, torch.nn.Module)\n elif isinstance(module, CrossAttnDownBlock2D):\n module.forward = hack_CrossAttnDownBlock2D_forward.__get__(module, CrossAttnDownBlock2D)\n elif isinstance(module, DownBlock2D):\n module.forward = hacked_DownBlock2D_forward.__get__(module, DownBlock2D)\n elif isinstance(module, CrossAttnUpBlock2D):\n module.forward = hacked_CrossAttnUpBlock2D_forward.__get__(module, CrossAttnUpBlock2D)\n elif isinstance(module, UpBlock2D):\n module.forward = hacked_UpBlock2D_forward.__get__(module, UpBlock2D)\n module.mean_bank = []\n module.var_bank = []\n module.gn_weight *= 2\n \n def update(self, writer, dtype=torch.float16):\n if self.reference_attn:\n if self.fusion_blocks == \"midup\":\n reader_attn_modules = [module for module in (torch_dfs(self.unet.mid_block)+torch_dfs(self.unet.up_blocks)) if isinstance(module, _BasicTransformerBlock)]\n writer_attn_modules = [module for module in (torch_dfs(writer.unet.mid_block)+torch_dfs(writer.unet.up_blocks)) if isinstance(module, BasicTransformerBlock)]\n elif self.fusion_blocks == \"full\":\n reader_attn_modules = [module for module in torch_dfs(self.unet) if isinstance(module, _BasicTransformerBlock)]\n writer_attn_modules = [module for module in torch_dfs(writer.unet) if isinstance(module, BasicTransformerBlock)]\n reader_attn_modules = sorted(reader_attn_modules, key=lambda x: -x.norm1.normalized_shape[0]) \n writer_attn_modules = sorted(writer_attn_modules, key=lambda x: -x.norm1.normalized_shape[0])\n for r, w in zip(reader_attn_modules, writer_attn_modules):\n r.bank = [v.clone().to(dtype) for v in w.bank]\n # w.bank.clear()\n if self.reference_adain:\n reader_gn_modules = [self.unet.mid_block]\n \n down_blocks = self.unet.down_blocks\n for w, module in enumerate(down_blocks):\n reader_gn_modules.append(module)\n\n up_blocks = self.unet.up_blocks\n for w, module in enumerate(up_blocks):\n reader_gn_modules.append(module)\n \n writer_gn_modules = [writer.unet.mid_block]\n \n down_blocks = writer.unet.down_blocks\n for w, module in enumerate(down_blocks):\n writer_gn_modules.append(module)\n\n up_blocks = writer.unet.up_blocks\n for w, module in enumerate(up_blocks):\n writer_gn_modules.append(module)\n \n for r, w in zip(reader_gn_modules, writer_gn_modules):\n if len(w.mean_bank) > 0 and isinstance(w.mean_bank[0], list):\n r.mean_bank = [[v.clone().to(dtype) for v in vl] for vl in w.mean_bank]\n r.var_bank = [[v.clone().to(dtype) for v in vl] for vl in w.var_bank]\n else:\n r.mean_bank = [v.clone().to(dtype) for v in w.mean_bank]\n r.var_bank = [v.clone().to(dtype) for v in w.var_bank]\n \n def clear(self):\n if self.reference_attn:\n if self.fusion_blocks == \"midup\":\n reader_attn_modules = [module for module in (torch_dfs(self.unet.mid_block)+torch_dfs(self.unet.up_blocks)) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)]\n elif self.fusion_blocks == \"full\":\n reader_attn_modules = [module for module in torch_dfs(self.unet) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)]\n reader_attn_modules = sorted(reader_attn_modules, key=lambda x: -x.norm1.normalized_shape[0])\n for r in reader_attn_modules:\n r.bank.clear()\n if self.reference_adain:\n reader_gn_modules = [self.unet.mid_block]\n \n down_blocks = self.unet.down_blocks\n for w, module in enumerate(down_blocks):\n reader_gn_modules.append(module)\n\n up_blocks = self.unet.up_blocks\n for w, module in enumerate(up_blocks):\n reader_gn_modules.append(module)\n \n for r in reader_gn_modules:\n r.mean_bank.clear()\n r.var_bank.clear()"},{"identifier":"get_context_scheduler","path":"magicanimate/pipelines/context.py","snippet":"def get_context_scheduler(name: str) -> Callable:\n if name == \"uniform\":\n return uniform\n else:\n raise ValueError(f\"Unknown context_overlap policy {name}\")"},{"identifier":"get_total_steps","path":"magicanimate/pipelines/context.py","snippet":"def get_total_steps(\n scheduler,\n timesteps: List[int],\n num_steps: Optional[int] = None,\n num_frames: int = ...,\n context_size: Optional[int] = None,\n context_stride: int = 3,\n context_overlap: int = 4,\n closed_loop: bool = True,\n):\n return sum(\n len(\n list(\n scheduler(\n i,\n num_steps,\n num_frames,\n context_size,\n context_stride,\n context_overlap,\n )\n )\n )\n for i in range(len(timesteps))\n )"},{"identifier":"get_tensor_interpolation_method","path":"magicanimate/utils/util.py","snippet":"def get_tensor_interpolation_method():\n return tensor_interpolation"}],"string":"[\n {\n \"identifier\": \"UNet3DConditionModel\",\n \"path\": \"magicanimate/models/unet_controlnet.py\",\n \"snippet\": \"class UNet3DConditionModel(ModelMixin, ConfigMixin):\\n _supports_gradient_checkpointing = True\\n\\n @register_to_config\\n def __init__(\\n self,\\n sample_size: Optional[int] = None,\\n in_channels: int = 4,\\n out_channels: int = 4,\\n center_input_sample: bool = False,\\n flip_sin_to_cos: bool = True,\\n freq_shift: int = 0, \\n down_block_types: Tuple[str] = (\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"DownBlock3D\\\",\\n ),\\n mid_block_type: str = \\\"UNetMidBlock3DCrossAttn\\\",\\n up_block_types: Tuple[str] = (\\n \\\"UpBlock3D\\\",\\n \\\"CrossAttnUpBlock3D\\\",\\n \\\"CrossAttnUpBlock3D\\\",\\n \\\"CrossAttnUpBlock3D\\\"\\n ),\\n only_cross_attention: Union[bool, Tuple[bool]] = False,\\n block_out_channels: Tuple[int] = (320, 640, 1280, 1280),\\n layers_per_block: int = 2,\\n downsample_padding: int = 1,\\n mid_block_scale_factor: float = 1,\\n act_fn: str = \\\"silu\\\",\\n norm_num_groups: int = 32,\\n norm_eps: float = 1e-5,\\n cross_attention_dim: int = 1280,\\n attention_head_dim: Union[int, Tuple[int]] = 8,\\n dual_cross_attention: bool = False,\\n use_linear_projection: bool = False,\\n class_embed_type: Optional[str] = None,\\n num_class_embeds: Optional[int] = None,\\n upcast_attention: bool = False,\\n resnet_time_scale_shift: str = \\\"default\\\",\\n \\n # Additional\\n use_motion_module = False,\\n motion_module_resolutions = ( 1,2,4,8 ),\\n motion_module_mid_block = False,\\n motion_module_decoder_only = False,\\n motion_module_type = None,\\n motion_module_kwargs = {},\\n unet_use_cross_frame_attention = None,\\n unet_use_temporal_attention = None,\\n ):\\n super().__init__()\\n\\n self.sample_size = sample_size\\n time_embed_dim = block_out_channels[0] * 4\\n\\n # input\\n self.conv_in = InflatedConv3d(in_channels, block_out_channels[0], kernel_size=3, padding=(1, 1))\\n\\n # time\\n self.time_proj = Timesteps(block_out_channels[0], flip_sin_to_cos, freq_shift)\\n timestep_input_dim = block_out_channels[0]\\n\\n self.time_embedding = TimestepEmbedding(timestep_input_dim, time_embed_dim)\\n\\n # class embedding\\n if class_embed_type is None and num_class_embeds is not None:\\n self.class_embedding = nn.Embedding(num_class_embeds, time_embed_dim)\\n elif class_embed_type == \\\"timestep\\\":\\n self.class_embedding = TimestepEmbedding(timestep_input_dim, time_embed_dim)\\n elif class_embed_type == \\\"identity\\\":\\n self.class_embedding = nn.Identity(time_embed_dim, time_embed_dim)\\n else:\\n self.class_embedding = None\\n\\n self.down_blocks = nn.ModuleList([])\\n self.mid_block = None\\n self.up_blocks = nn.ModuleList([])\\n\\n if isinstance(only_cross_attention, bool):\\n only_cross_attention = [only_cross_attention] * len(down_block_types)\\n\\n if isinstance(attention_head_dim, int):\\n attention_head_dim = (attention_head_dim,) * len(down_block_types)\\n\\n # down\\n output_channel = block_out_channels[0]\\n for i, down_block_type in enumerate(down_block_types):\\n res = 2 ** i\\n input_channel = output_channel\\n output_channel = block_out_channels[i]\\n is_final_block = i == len(block_out_channels) - 1\\n\\n down_block = get_down_block(\\n down_block_type,\\n num_layers=layers_per_block,\\n in_channels=input_channel,\\n out_channels=output_channel,\\n temb_channels=time_embed_dim,\\n add_downsample=not is_final_block,\\n resnet_eps=norm_eps,\\n resnet_act_fn=act_fn,\\n resnet_groups=norm_num_groups,\\n cross_attention_dim=cross_attention_dim,\\n attn_num_head_channels=attention_head_dim[i],\\n downsample_padding=downsample_padding,\\n dual_cross_attention=dual_cross_attention,\\n use_linear_projection=use_linear_projection,\\n only_cross_attention=only_cross_attention[i],\\n upcast_attention=upcast_attention,\\n resnet_time_scale_shift=resnet_time_scale_shift,\\n\\n unet_use_cross_frame_attention=unet_use_cross_frame_attention,\\n unet_use_temporal_attention=unet_use_temporal_attention,\\n \\n use_motion_module=use_motion_module and (res in motion_module_resolutions) and (not motion_module_decoder_only),\\n motion_module_type=motion_module_type,\\n motion_module_kwargs=motion_module_kwargs,\\n )\\n self.down_blocks.append(down_block)\\n\\n # mid\\n if mid_block_type == \\\"UNetMidBlock3DCrossAttn\\\":\\n self.mid_block = UNetMidBlock3DCrossAttn(\\n in_channels=block_out_channels[-1],\\n temb_channels=time_embed_dim,\\n resnet_eps=norm_eps,\\n resnet_act_fn=act_fn,\\n output_scale_factor=mid_block_scale_factor,\\n resnet_time_scale_shift=resnet_time_scale_shift,\\n cross_attention_dim=cross_attention_dim,\\n attn_num_head_channels=attention_head_dim[-1],\\n resnet_groups=norm_num_groups,\\n dual_cross_attention=dual_cross_attention,\\n use_linear_projection=use_linear_projection,\\n upcast_attention=upcast_attention,\\n\\n unet_use_cross_frame_attention=unet_use_cross_frame_attention,\\n unet_use_temporal_attention=unet_use_temporal_attention,\\n \\n use_motion_module=use_motion_module and motion_module_mid_block,\\n motion_module_type=motion_module_type,\\n motion_module_kwargs=motion_module_kwargs,\\n )\\n else:\\n raise ValueError(f\\\"unknown mid_block_type : {mid_block_type}\\\")\\n \\n # count how many layers upsample the videos\\n self.num_upsamplers = 0\\n\\n # up\\n reversed_block_out_channels = list(reversed(block_out_channels))\\n reversed_attention_head_dim = list(reversed(attention_head_dim))\\n only_cross_attention = list(reversed(only_cross_attention))\\n output_channel = reversed_block_out_channels[0]\\n for i, up_block_type in enumerate(up_block_types):\\n res = 2 ** (3 - i)\\n is_final_block = i == len(block_out_channels) - 1\\n\\n prev_output_channel = output_channel\\n output_channel = reversed_block_out_channels[i]\\n input_channel = reversed_block_out_channels[min(i + 1, len(block_out_channels) - 1)]\\n\\n # add upsample block for all BUT final layer\\n if not is_final_block:\\n add_upsample = True\\n self.num_upsamplers += 1\\n else:\\n add_upsample = False\\n\\n up_block = get_up_block(\\n up_block_type,\\n num_layers=layers_per_block + 1,\\n in_channels=input_channel,\\n out_channels=output_channel,\\n prev_output_channel=prev_output_channel,\\n temb_channels=time_embed_dim,\\n add_upsample=add_upsample,\\n resnet_eps=norm_eps,\\n resnet_act_fn=act_fn,\\n resnet_groups=norm_num_groups,\\n cross_attention_dim=cross_attention_dim,\\n attn_num_head_channels=reversed_attention_head_dim[i],\\n dual_cross_attention=dual_cross_attention,\\n use_linear_projection=use_linear_projection,\\n only_cross_attention=only_cross_attention[i],\\n upcast_attention=upcast_attention,\\n resnet_time_scale_shift=resnet_time_scale_shift,\\n\\n unet_use_cross_frame_attention=unet_use_cross_frame_attention,\\n unet_use_temporal_attention=unet_use_temporal_attention,\\n\\n use_motion_module=use_motion_module and (res in motion_module_resolutions),\\n motion_module_type=motion_module_type,\\n motion_module_kwargs=motion_module_kwargs,\\n )\\n self.up_blocks.append(up_block)\\n prev_output_channel = output_channel\\n\\n # out\\n self.conv_norm_out = nn.GroupNorm(num_channels=block_out_channels[0], num_groups=norm_num_groups, eps=norm_eps)\\n self.conv_act = nn.SiLU()\\n self.conv_out = InflatedConv3d(block_out_channels[0], out_channels, kernel_size=3, padding=1)\\n\\n def set_attention_slice(self, slice_size):\\n r\\\"\\\"\\\"\\n Enable sliced attention computation.\\n\\n When this option is enabled, the attention module will split the input tensor in slices, to compute attention\\n in several steps. This is useful to save some memory in exchange for a small speed decrease.\\n\\n Args:\\n slice_size (`str` or `int` or `list(int)`, *optional*, defaults to `\\\"auto\\\"`):\\n When `\\\"auto\\\"`, halves the input to the attention heads, so attention will be computed in two steps. If\\n `\\\"max\\\"`, maxium amount of memory will be saved by running only one slice at a time. If a number is\\n provided, uses as many slices as `attention_head_dim // slice_size`. In this case, `attention_head_dim`\\n must be a multiple of `slice_size`.\\n \\\"\\\"\\\"\\n sliceable_head_dims = []\\n\\n def fn_recursive_retrieve_slicable_dims(module: torch.nn.Module):\\n if hasattr(module, \\\"set_attention_slice\\\"):\\n sliceable_head_dims.append(module.sliceable_head_dim)\\n\\n for child in module.children():\\n fn_recursive_retrieve_slicable_dims(child)\\n\\n # retrieve number of attention layers\\n for module in self.children():\\n fn_recursive_retrieve_slicable_dims(module)\\n\\n num_slicable_layers = len(sliceable_head_dims)\\n\\n if slice_size == \\\"auto\\\":\\n # half the attention head size is usually a good trade-off between\\n # speed and memory\\n slice_size = [dim // 2 for dim in sliceable_head_dims]\\n elif slice_size == \\\"max\\\":\\n # make smallest slice possible\\n slice_size = num_slicable_layers * [1]\\n\\n slice_size = num_slicable_layers * [slice_size] if not isinstance(slice_size, list) else slice_size\\n\\n if len(slice_size) != len(sliceable_head_dims):\\n raise ValueError(\\n f\\\"You have provided {len(slice_size)}, but {self.config} has {len(sliceable_head_dims)} different\\\"\\n f\\\" attention layers. Make sure to match `len(slice_size)` to be {len(sliceable_head_dims)}.\\\"\\n )\\n\\n for i in range(len(slice_size)):\\n size = slice_size[i]\\n dim = sliceable_head_dims[i]\\n if size is not None and size > dim:\\n raise ValueError(f\\\"size {size} has to be smaller or equal to {dim}.\\\")\\n\\n # Recursively walk through all the children.\\n # Any children which exposes the set_attention_slice method\\n # gets the message\\n def fn_recursive_set_attention_slice(module: torch.nn.Module, slice_size: List[int]):\\n if hasattr(module, \\\"set_attention_slice\\\"):\\n module.set_attention_slice(slice_size.pop())\\n\\n for child in module.children():\\n fn_recursive_set_attention_slice(child, slice_size)\\n\\n reversed_slice_size = list(reversed(slice_size))\\n for module in self.children():\\n fn_recursive_set_attention_slice(module, reversed_slice_size)\\n\\n def _set_gradient_checkpointing(self, module, value=False):\\n if isinstance(module, (CrossAttnDownBlock3D, DownBlock3D, CrossAttnUpBlock3D, UpBlock3D)):\\n module.gradient_checkpointing = value\\n\\n def forward(\\n self,\\n sample: torch.FloatTensor,\\n timestep: Union[torch.Tensor, float, int],\\n encoder_hidden_states: torch.Tensor,\\n class_labels: Optional[torch.Tensor] = None,\\n attention_mask: Optional[torch.Tensor] = None,\\n # for controlnet\\n down_block_additional_residuals: Optional[Tuple[torch.Tensor]] = None,\\n mid_block_additional_residual: Optional[torch.Tensor] = None,\\n return_dict: bool = True,\\n ) -> Union[UNet3DConditionOutput, Tuple]:\\n r\\\"\\\"\\\"\\n Args:\\n sample (`torch.FloatTensor`): (batch, channel, height, width) noisy inputs tensor\\n timestep (`torch.FloatTensor` or `float` or `int`): (batch) timesteps\\n encoder_hidden_states (`torch.FloatTensor`): (batch, sequence_length, feature_dim) encoder hidden states\\n return_dict (`bool`, *optional*, defaults to `True`):\\n Whether or not to return a [`models.unet_2d_condition.UNet2DConditionOutput`] instead of a plain tuple.\\n\\n Returns:\\n [`~models.unet_2d_condition.UNet2DConditionOutput`] or `tuple`:\\n [`~models.unet_2d_condition.UNet2DConditionOutput`] if `return_dict` is True, otherwise a `tuple`. When\\n returning a tuple, the first element is the sample tensor.\\n \\\"\\\"\\\"\\n # By default samples have to be AT least a multiple of the overall upsampling factor.\\n # The overall upsampling factor is equal to 2 ** (# num of upsampling layears).\\n # However, the upsampling interpolation output size can be forced to fit any upsampling size\\n # on the fly if necessary.\\n default_overall_up_factor = 2**self.num_upsamplers\\n\\n # upsample size should be forwarded when sample is not a multiple of `default_overall_up_factor`\\n forward_upsample_size = False\\n upsample_size = None\\n\\n if any(s % default_overall_up_factor != 0 for s in sample.shape[-2:]):\\n logger.info(\\\"Forward upsample size to force interpolation output size.\\\")\\n forward_upsample_size = True\\n\\n # prepare attention_mask\\n if attention_mask is not None:\\n attention_mask = (1 - attention_mask.to(sample.dtype)) * -10000.0\\n attention_mask = attention_mask.unsqueeze(1)\\n\\n # center input if necessary\\n if self.config.center_input_sample:\\n sample = 2 * sample - 1.0\\n\\n # time\\n timesteps = timestep\\n if not torch.is_tensor(timesteps):\\n # This would be a good case for the `match` statement (Python 3.10+)\\n is_mps = sample.device.type == \\\"mps\\\"\\n if isinstance(timestep, float):\\n dtype = torch.float32 if is_mps else torch.float64\\n else:\\n dtype = torch.int32 if is_mps else torch.int64\\n timesteps = torch.tensor([timesteps], dtype=dtype, device=sample.device)\\n elif len(timesteps.shape) == 0:\\n timesteps = timesteps[None].to(sample.device)\\n\\n # broadcast to batch dimension in a way that's compatible with ONNX/Core ML\\n timesteps = timesteps.expand(sample.shape[0])\\n\\n t_emb = self.time_proj(timesteps)\\n\\n # timesteps does not contain any weights and will always return f32 tensors\\n # but time_embedding might actually be running in fp16. so we need to cast here.\\n # there might be better ways to encapsulate this.\\n t_emb = t_emb.to(dtype=self.dtype)\\n emb = self.time_embedding(t_emb)\\n\\n if self.class_embedding is not None:\\n if class_labels is None:\\n raise ValueError(\\\"class_labels should be provided when num_class_embeds > 0\\\")\\n\\n if self.config.class_embed_type == \\\"timestep\\\":\\n class_labels = self.time_proj(class_labels)\\n\\n class_emb = self.class_embedding(class_labels).to(dtype=self.dtype)\\n emb = emb + class_emb\\n\\n # pre-process\\n sample = self.conv_in(sample)\\n\\n # down\\n is_controlnet = mid_block_additional_residual is not None and down_block_additional_residuals is not None\\n\\n down_block_res_samples = (sample,)\\n for downsample_block in self.down_blocks:\\n if hasattr(downsample_block, \\\"has_cross_attention\\\") and downsample_block.has_cross_attention:\\n sample, res_samples = downsample_block(\\n hidden_states=sample,\\n temb=emb,\\n encoder_hidden_states=encoder_hidden_states,\\n attention_mask=attention_mask,\\n )\\n else:\\n sample, res_samples = downsample_block(hidden_states=sample, temb=emb, encoder_hidden_states=encoder_hidden_states)\\n\\n down_block_res_samples += res_samples\\n\\n if is_controlnet:\\n new_down_block_res_samples = ()\\n\\n for down_block_res_sample, down_block_additional_residual in zip(\\n down_block_res_samples, down_block_additional_residuals\\n ):\\n down_block_res_sample = down_block_res_sample + down_block_additional_residual\\n new_down_block_res_samples = new_down_block_res_samples + (down_block_res_sample,)\\n\\n down_block_res_samples = new_down_block_res_samples\\n\\n # mid\\n sample = self.mid_block(\\n sample, emb, encoder_hidden_states=encoder_hidden_states, attention_mask=attention_mask\\n )\\n\\n if is_controlnet:\\n sample = sample + mid_block_additional_residual\\n\\n # up\\n for i, upsample_block in enumerate(self.up_blocks):\\n is_final_block = i == len(self.up_blocks) - 1\\n\\n res_samples = down_block_res_samples[-len(upsample_block.resnets) :]\\n down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)]\\n\\n # if we have not reached the final block and need to forward the\\n # upsample size, we do it here\\n if not is_final_block and forward_upsample_size:\\n upsample_size = down_block_res_samples[-1].shape[2:]\\n\\n if hasattr(upsample_block, \\\"has_cross_attention\\\") and upsample_block.has_cross_attention:\\n sample = upsample_block(\\n hidden_states=sample,\\n temb=emb,\\n res_hidden_states_tuple=res_samples,\\n encoder_hidden_states=encoder_hidden_states,\\n upsample_size=upsample_size,\\n attention_mask=attention_mask,\\n )\\n else:\\n sample = upsample_block(\\n hidden_states=sample, temb=emb, res_hidden_states_tuple=res_samples, upsample_size=upsample_size, encoder_hidden_states=encoder_hidden_states,\\n )\\n\\n # post-process\\n sample = self.conv_norm_out(sample)\\n sample = self.conv_act(sample)\\n sample = self.conv_out(sample)\\n\\n if not return_dict:\\n return (sample,)\\n\\n return UNet3DConditionOutput(sample=sample)\\n\\n @classmethod\\n def from_pretrained_2d(cls, pretrained_model_path, subfolder=None, unet_additional_kwargs=None):\\n if subfolder is not None:\\n pretrained_model_path = os.path.join(pretrained_model_path, subfolder)\\n print(f\\\"loaded temporal unet's pretrained weights from {pretrained_model_path} ...\\\")\\n\\n config_file = os.path.join(pretrained_model_path, 'config.json')\\n if not os.path.isfile(config_file):\\n raise RuntimeError(f\\\"{config_file} does not exist\\\")\\n with open(config_file, \\\"r\\\") as f:\\n config = json.load(f)\\n config[\\\"_class_name\\\"] = cls.__name__\\n config[\\\"down_block_types\\\"] = [\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"CrossAttnDownBlock3D\\\",\\n \\\"DownBlock3D\\\"\\n ]\\n config[\\\"up_block_types\\\"] = [\\n \\\"UpBlock3D\\\",\\n \\\"CrossAttnUpBlock3D\\\",\\n \\\"CrossAttnUpBlock3D\\\",\\n \\\"CrossAttnUpBlock3D\\\"\\n ]\\n # config[\\\"mid_block_type\\\"] = \\\"UNetMidBlock3DCrossAttn\\\"\\n\\n from diffusers.utils import WEIGHTS_NAME\\n model = cls.from_config(config, **unet_additional_kwargs)\\n model_file = os.path.join(pretrained_model_path, WEIGHTS_NAME)\\n if not os.path.isfile(model_file):\\n raise RuntimeError(f\\\"{model_file} does not exist\\\")\\n state_dict = torch.load(model_file, map_location=\\\"cpu\\\")\\n\\n m, u = model.load_state_dict(state_dict, strict=False)\\n print(f\\\"### missing keys: {len(m)}; \\\\n### unexpected keys: {len(u)};\\\")\\n # print(f\\\"### missing keys:\\\\n{m}\\\\n### unexpected keys:\\\\n{u}\\\\n\\\")\\n \\n params = [p.numel() if \\\"temporal\\\" in n else 0 for n, p in model.named_parameters()]\\n print(f\\\"### Temporal Module Parameters: {sum(params) / 1e6} M\\\")\\n \\n return model\"\n },\n {\n \"identifier\": \"ControlNetProcessor\",\n \"path\": \"magicanimate/models/multicontrolnet.py\",\n \"snippet\": \"class ControlNetProcessor(object):\\n def __init__(\\n self,\\n controlnet: ControlNetModel,\\n # image: Union[torch.FloatTensor, PIL.Image.Image, List[torch.FloatTensor], List[PIL.Image.Image]],\\n # controlnet_cond = torch.FloatTensor, #fix\\n # conditioning_scale: float = 1.0,\\n ):\\n self.controlnet = controlnet\\n # self.image = image\\n # self.controlnet_cond = controlnet_cond #fix\\n # self.conditioning_scale = conditioning_scale\\n\\n # def _default_height_width(self, height, width, image):\\n # if isinstance(image, list):\\n # image = image[0]\\n\\n # if height is None:\\n # if isinstance(image, PIL.Image.Image):\\n # height = image.height\\n # elif isinstance(image, torch.Tensor):\\n # height = image.shape[3]\\n\\n # height = (height // 8) * 8 # round down to nearest multiple of 8\\n\\n # if width is None:\\n # if isinstance(image, PIL.Image.Image):\\n # width = image.width\\n # elif isinstance(image, torch.Tensor):\\n # width = image.shape[2]\\n\\n # width = (width // 8) * 8 # round down to nearest multiple of 8\\n\\n # return height, width\\n\\n # def default_height_width(self, height, width):\\n # return self._default_height_width(height, width, self.image)\\n\\n # def _prepare_image(self, image, width, height, batch_size, num_images_per_prompt, device, dtype):\\n # if not isinstance(image, torch.Tensor):\\n # if isinstance(image, PIL.Image.Image):\\n # image = [image]\\n\\n # if isinstance(image[0], PIL.Image.Image):\\n # image = [\\n # np.array(i.resize((width, height), resample=PIL_INTERPOLATION[\\\"lanczos\\\"]))[None, :] for i in image\\n # ]\\n # image = np.concatenate(image, axis=0)\\n # image = np.array(image).astype(np.float32) / 255.0\\n # image = image.transpose(0, 3, 1, 2)\\n # image = torch.from_numpy(image)\\n # elif isinstance(image[0], torch.Tensor):\\n # image = torch.cat(image, dim=0)\\n\\n # image_batch_size = image.shape[0]\\n\\n # if image_batch_size == 1:\\n # repeat_by = batch_size\\n # else:\\n # # image batch size is the same as prompt batch size\\n # repeat_by = num_images_per_prompt\\n\\n # image = image.repeat_interleave(repeat_by, dim=0)\\n\\n # image = image.to(device=device, dtype=dtype)\\n\\n # return image\\n\\n # def _check_inputs(self, image, prompt, prompt_embeds):\\n # image_is_pil = isinstance(image, PIL.Image.Image)\\n # image_is_tensor = isinstance(image, torch.Tensor)\\n # image_is_pil_list = isinstance(image, list) and isinstance(image[0], PIL.Image.Image)\\n # image_is_tensor_list = isinstance(image, list) and isinstance(image[0], torch.Tensor)\\n\\n # if not image_is_pil and not image_is_tensor and not image_is_pil_list and not image_is_tensor_list:\\n # raise TypeError(\\n # \\\"image must be passed and be one of PIL image, torch tensor, list of PIL images, or list of torch tensors\\\"\\n # )\\n\\n # if image_is_pil:\\n # image_batch_size = 1\\n # elif image_is_tensor:\\n # image_batch_size = image.shape[0]\\n # elif image_is_pil_list:\\n # image_batch_size = len(image)\\n # elif image_is_tensor_list:\\n # image_batch_size = len(image)\\n\\n # if prompt is not None and isinstance(prompt, str):\\n # prompt_batch_size = 1\\n # elif prompt is not None and isinstance(prompt, list):\\n # prompt_batch_size = len(prompt)\\n # elif prompt_embeds is not None:\\n # prompt_batch_size = prompt_embeds.shape[0]\\n\\n # if image_batch_size != 1 and image_batch_size != prompt_batch_size:\\n # raise ValueError(\\n # f\\\"If image batch size is not 1, image batch size must be same as prompt batch size. image batch size: {image_batch_size}, prompt batch size: {prompt_batch_size}\\\"\\n # )\\n\\n # def check_inputs(self, prompt, prompt_embeds):\\n # self._check_inputs(self.image, prompt, prompt_embeds)\\n\\n # def prepare_image(self, width, height, batch_size, num_images_per_prompt, device, do_classifier_free_guidance):\\n # self.image = self._prepare_image(\\n # self.image, width, height, batch_size, num_images_per_prompt, device, self.controlnet.dtype\\n # )\\n # if do_classifier_free_guidance:\\n # self.image = torch.cat([self.image] * 2)\\n\\n def __call__(\\n self,\\n controlnet_latent_input,\\n t,\\n encoder_hidden_states,\\n controlnet_cond, #fix\\n conditioning_scale,\\n return_dict,\\n ) -> Tuple:\\n down_block_res_samples, mid_block_res_sample = self.controlnet(\\n controlnet_latent_input,\\n t,\\n encoder_hidden_states,\\n controlnet_cond,\\n conditioning_scale, \\n return_dict=False,\\n )\\n down_block_res_samples = [\\n down_block_res_sample * conditioning_scale for down_block_res_sample in down_block_res_samples\\n ]\\n mid_block_res_sample *= conditioning_scale\\n return (down_block_res_samples, mid_block_res_sample)\"\n },\n {\n \"identifier\": \"ReferenceAttentionControl\",\n \"path\": \"magicanimate/models/mutual_self_attention.py\",\n \"snippet\": \"class ReferenceAttentionControl():\\n \\n def __init__(self, \\n unet,\\n mode=\\\"write\\\",\\n do_classifier_free_guidance=False,\\n attention_auto_machine_weight = float('inf'),\\n gn_auto_machine_weight = 1.0,\\n style_fidelity = 1.0,\\n reference_attn=True,\\n reference_adain=False,\\n fusion_blocks=\\\"midup\\\",\\n batch_size=1, \\n ) -> None:\\n # 10. Modify self attention and group norm\\n self.unet = unet\\n assert mode in [\\\"read\\\", \\\"write\\\"]\\n assert fusion_blocks in [\\\"midup\\\", \\\"full\\\"]\\n self.reference_attn = reference_attn\\n self.reference_adain = reference_adain\\n self.fusion_blocks = fusion_blocks\\n self.register_reference_hooks(\\n mode, \\n do_classifier_free_guidance,\\n attention_auto_machine_weight,\\n gn_auto_machine_weight,\\n style_fidelity,\\n reference_attn,\\n reference_adain,\\n fusion_blocks,\\n batch_size=batch_size, \\n )\\n\\n def register_reference_hooks(\\n self, \\n mode, \\n do_classifier_free_guidance,\\n attention_auto_machine_weight,\\n gn_auto_machine_weight,\\n style_fidelity,\\n reference_attn,\\n reference_adain,\\n dtype=torch.float16,\\n batch_size=1, \\n num_images_per_prompt=1, \\n device=torch.device(\\\"cpu\\\"), \\n fusion_blocks='midup',\\n ):\\n MODE = mode\\n do_classifier_free_guidance = do_classifier_free_guidance\\n attention_auto_machine_weight = attention_auto_machine_weight\\n gn_auto_machine_weight = gn_auto_machine_weight\\n style_fidelity = style_fidelity\\n reference_attn = reference_attn\\n reference_adain = reference_adain\\n fusion_blocks = fusion_blocks\\n num_images_per_prompt = num_images_per_prompt\\n dtype=dtype\\n if do_classifier_free_guidance:\\n uc_mask = (\\n torch.Tensor([1] * batch_size * num_images_per_prompt * 16 + [0] * batch_size * num_images_per_prompt * 16)\\n .to(device)\\n .bool()\\n )\\n else:\\n uc_mask = (\\n torch.Tensor([0] * batch_size * num_images_per_prompt * 2)\\n .to(device)\\n .bool()\\n )\\n \\n def hacked_basic_transformer_inner_forward(\\n self,\\n hidden_states: torch.FloatTensor,\\n attention_mask: Optional[torch.FloatTensor] = None,\\n encoder_hidden_states: Optional[torch.FloatTensor] = None,\\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\\n timestep: Optional[torch.LongTensor] = None,\\n cross_attention_kwargs: Dict[str, Any] = None,\\n class_labels: Optional[torch.LongTensor] = None,\\n video_length=None,\\n ):\\n if self.use_ada_layer_norm:\\n norm_hidden_states = self.norm1(hidden_states, timestep)\\n elif self.use_ada_layer_norm_zero:\\n norm_hidden_states, gate_msa, shift_mlp, scale_mlp, gate_mlp = self.norm1(\\n hidden_states, timestep, class_labels, hidden_dtype=hidden_states.dtype\\n )\\n else:\\n norm_hidden_states = self.norm1(hidden_states)\\n\\n # 1. Self-Attention\\n cross_attention_kwargs = cross_attention_kwargs if cross_attention_kwargs is not None else {}\\n if self.only_cross_attention:\\n attn_output = self.attn1(\\n norm_hidden_states,\\n encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None,\\n attention_mask=attention_mask,\\n **cross_attention_kwargs,\\n )\\n else:\\n if MODE == \\\"write\\\":\\n self.bank.append(norm_hidden_states.clone())\\n attn_output = self.attn1(\\n norm_hidden_states,\\n encoder_hidden_states=encoder_hidden_states if self.only_cross_attention else None,\\n attention_mask=attention_mask,\\n **cross_attention_kwargs,\\n )\\n if MODE == \\\"read\\\":\\n self.bank = [rearrange(d.unsqueeze(1).repeat(1, video_length, 1, 1), \\\"b t l c -> (b t) l c\\\")[:hidden_states.shape[0]] for d in self.bank]\\n hidden_states_uc = self.attn1(norm_hidden_states, \\n encoder_hidden_states=torch.cat([norm_hidden_states] + self.bank, dim=1),\\n attention_mask=attention_mask) + hidden_states\\n hidden_states_c = hidden_states_uc.clone()\\n _uc_mask = uc_mask.clone()\\n if do_classifier_free_guidance:\\n if hidden_states.shape[0] != _uc_mask.shape[0]:\\n _uc_mask = (\\n torch.Tensor([1] * (hidden_states.shape[0]//2) + [0] * (hidden_states.shape[0]//2))\\n .to(device)\\n .bool()\\n )\\n hidden_states_c[_uc_mask] = self.attn1(\\n norm_hidden_states[_uc_mask],\\n encoder_hidden_states=norm_hidden_states[_uc_mask],\\n attention_mask=attention_mask,\\n ) + hidden_states[_uc_mask]\\n hidden_states = hidden_states_c.clone()\\n \\n self.bank.clear()\\n if self.attn2 is not None:\\n # Cross-Attention\\n norm_hidden_states = (\\n self.norm2(hidden_states, timestep) if self.use_ada_layer_norm else self.norm2(hidden_states)\\n )\\n hidden_states = (\\n self.attn2(\\n norm_hidden_states, encoder_hidden_states=encoder_hidden_states, attention_mask=attention_mask\\n )\\n + hidden_states\\n )\\n\\n # Feed-forward\\n hidden_states = self.ff(self.norm3(hidden_states)) + hidden_states\\n\\n # Temporal-Attention\\n if self.unet_use_temporal_attention:\\n d = hidden_states.shape[1]\\n hidden_states = rearrange(hidden_states, \\\"(b f) d c -> (b d) f c\\\", f=video_length)\\n norm_hidden_states = (\\n self.norm_temp(hidden_states, timestep) if self.use_ada_layer_norm else self.norm_temp(hidden_states)\\n )\\n hidden_states = self.attn_temp(norm_hidden_states) + hidden_states\\n hidden_states = rearrange(hidden_states, \\\"(b d) f c -> (b f) d c\\\", d=d)\\n\\n return hidden_states\\n \\n if self.use_ada_layer_norm_zero:\\n attn_output = gate_msa.unsqueeze(1) * attn_output\\n hidden_states = attn_output + hidden_states\\n\\n if self.attn2 is not None:\\n norm_hidden_states = (\\n self.norm2(hidden_states, timestep) if self.use_ada_layer_norm else self.norm2(hidden_states)\\n )\\n\\n # 2. Cross-Attention\\n attn_output = self.attn2(\\n norm_hidden_states,\\n encoder_hidden_states=encoder_hidden_states,\\n attention_mask=encoder_attention_mask,\\n **cross_attention_kwargs,\\n )\\n hidden_states = attn_output + hidden_states\\n\\n # 3. Feed-forward\\n norm_hidden_states = self.norm3(hidden_states)\\n\\n if self.use_ada_layer_norm_zero:\\n norm_hidden_states = norm_hidden_states * (1 + scale_mlp[:, None]) + shift_mlp[:, None]\\n\\n ff_output = self.ff(norm_hidden_states)\\n\\n if self.use_ada_layer_norm_zero:\\n ff_output = gate_mlp.unsqueeze(1) * ff_output\\n\\n hidden_states = ff_output + hidden_states\\n\\n return hidden_states\\n\\n def hacked_mid_forward(self, *args, **kwargs):\\n eps = 1e-6\\n x = self.original_forward(*args, **kwargs)\\n if MODE == \\\"write\\\":\\n if gn_auto_machine_weight >= self.gn_weight:\\n var, mean = torch.var_mean(x, dim=(2, 3), keepdim=True, correction=0)\\n self.mean_bank.append(mean)\\n self.var_bank.append(var)\\n if MODE == \\\"read\\\":\\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\\n var, mean = torch.var_mean(x, dim=(2, 3), keepdim=True, correction=0)\\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\\n mean_acc = sum(self.mean_bank) / float(len(self.mean_bank))\\n var_acc = sum(self.var_bank) / float(len(self.var_bank))\\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\\n x_uc = (((x - mean) / std) * std_acc) + mean_acc\\n x_c = x_uc.clone()\\n if do_classifier_free_guidance and style_fidelity > 0:\\n x_c[uc_mask] = x[uc_mask]\\n x = style_fidelity * x_c + (1.0 - style_fidelity) * x_uc\\n self.mean_bank = []\\n self.var_bank = []\\n return x\\n\\n def hack_CrossAttnDownBlock2D_forward(\\n self,\\n hidden_states: torch.FloatTensor,\\n temb: Optional[torch.FloatTensor] = None,\\n encoder_hidden_states: Optional[torch.FloatTensor] = None,\\n attention_mask: Optional[torch.FloatTensor] = None,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\\n ):\\n eps = 1e-6\\n\\n # TODO(Patrick, William) - attention mask is not used\\n output_states = ()\\n\\n for i, (resnet, attn) in enumerate(zip(self.resnets, self.attentions)):\\n hidden_states = resnet(hidden_states, temb)\\n hidden_states = attn(\\n hidden_states,\\n encoder_hidden_states=encoder_hidden_states,\\n cross_attention_kwargs=cross_attention_kwargs,\\n attention_mask=attention_mask,\\n encoder_attention_mask=encoder_attention_mask,\\n return_dict=False,\\n )[0]\\n if MODE == \\\"write\\\":\\n if gn_auto_machine_weight >= self.gn_weight:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n self.mean_bank.append([mean])\\n self.var_bank.append([var])\\n if MODE == \\\"read\\\":\\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\\n hidden_states_c = hidden_states_uc.clone()\\n if do_classifier_free_guidance and style_fidelity > 0:\\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\\n\\n output_states = output_states + (hidden_states,)\\n\\n if MODE == \\\"read\\\":\\n self.mean_bank = []\\n self.var_bank = []\\n\\n if self.downsamplers is not None:\\n for downsampler in self.downsamplers:\\n hidden_states = downsampler(hidden_states)\\n\\n output_states = output_states + (hidden_states,)\\n\\n return hidden_states, output_states\\n\\n def hacked_DownBlock2D_forward(self, hidden_states, temb=None):\\n eps = 1e-6\\n\\n output_states = ()\\n\\n for i, resnet in enumerate(self.resnets):\\n hidden_states = resnet(hidden_states, temb)\\n\\n if MODE == \\\"write\\\":\\n if gn_auto_machine_weight >= self.gn_weight:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n self.mean_bank.append([mean])\\n self.var_bank.append([var])\\n if MODE == \\\"read\\\":\\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\\n hidden_states_c = hidden_states_uc.clone()\\n if do_classifier_free_guidance and style_fidelity > 0:\\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\\n\\n output_states = output_states + (hidden_states,)\\n\\n if MODE == \\\"read\\\":\\n self.mean_bank = []\\n self.var_bank = []\\n\\n if self.downsamplers is not None:\\n for downsampler in self.downsamplers:\\n hidden_states = downsampler(hidden_states)\\n\\n output_states = output_states + (hidden_states,)\\n\\n return hidden_states, output_states\\n\\n def hacked_CrossAttnUpBlock2D_forward(\\n self,\\n hidden_states: torch.FloatTensor,\\n res_hidden_states_tuple: Tuple[torch.FloatTensor, ...],\\n temb: Optional[torch.FloatTensor] = None,\\n encoder_hidden_states: Optional[torch.FloatTensor] = None,\\n cross_attention_kwargs: Optional[Dict[str, Any]] = None,\\n upsample_size: Optional[int] = None,\\n attention_mask: Optional[torch.FloatTensor] = None,\\n encoder_attention_mask: Optional[torch.FloatTensor] = None,\\n ):\\n eps = 1e-6\\n # TODO(Patrick, William) - attention mask is not used\\n for i, (resnet, attn) in enumerate(zip(self.resnets, self.attentions)):\\n # pop res hidden states\\n res_hidden_states = res_hidden_states_tuple[-1]\\n res_hidden_states_tuple = res_hidden_states_tuple[:-1]\\n hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)\\n hidden_states = resnet(hidden_states, temb)\\n hidden_states = attn(\\n hidden_states,\\n encoder_hidden_states=encoder_hidden_states,\\n cross_attention_kwargs=cross_attention_kwargs,\\n attention_mask=attention_mask,\\n encoder_attention_mask=encoder_attention_mask,\\n return_dict=False,\\n )[0]\\n\\n if MODE == \\\"write\\\":\\n if gn_auto_machine_weight >= self.gn_weight:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n self.mean_bank.append([mean])\\n self.var_bank.append([var])\\n if MODE == \\\"read\\\":\\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\\n hidden_states_c = hidden_states_uc.clone()\\n if do_classifier_free_guidance and style_fidelity > 0:\\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\\n\\n if MODE == \\\"read\\\":\\n self.mean_bank = []\\n self.var_bank = []\\n\\n if self.upsamplers is not None:\\n for upsampler in self.upsamplers:\\n hidden_states = upsampler(hidden_states, upsample_size)\\n\\n return hidden_states\\n\\n def hacked_UpBlock2D_forward(self, hidden_states, res_hidden_states_tuple, temb=None, upsample_size=None):\\n eps = 1e-6\\n for i, resnet in enumerate(self.resnets):\\n # pop res hidden states\\n res_hidden_states = res_hidden_states_tuple[-1]\\n res_hidden_states_tuple = res_hidden_states_tuple[:-1]\\n hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1)\\n hidden_states = resnet(hidden_states, temb)\\n\\n if MODE == \\\"write\\\":\\n if gn_auto_machine_weight >= self.gn_weight:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n self.mean_bank.append([mean])\\n self.var_bank.append([var])\\n if MODE == \\\"read\\\":\\n if len(self.mean_bank) > 0 and len(self.var_bank) > 0:\\n var, mean = torch.var_mean(hidden_states, dim=(2, 3), keepdim=True, correction=0)\\n std = torch.maximum(var, torch.zeros_like(var) + eps) ** 0.5\\n mean_acc = sum(self.mean_bank[i]) / float(len(self.mean_bank[i]))\\n var_acc = sum(self.var_bank[i]) / float(len(self.var_bank[i]))\\n std_acc = torch.maximum(var_acc, torch.zeros_like(var_acc) + eps) ** 0.5\\n hidden_states_uc = (((hidden_states - mean) / std) * std_acc) + mean_acc\\n hidden_states_c = hidden_states_uc.clone()\\n if do_classifier_free_guidance and style_fidelity > 0:\\n hidden_states_c[uc_mask] = hidden_states[uc_mask].to(hidden_states_c.dtype)\\n hidden_states = style_fidelity * hidden_states_c + (1.0 - style_fidelity) * hidden_states_uc\\n\\n if MODE == \\\"read\\\":\\n self.mean_bank = []\\n self.var_bank = []\\n\\n if self.upsamplers is not None:\\n for upsampler in self.upsamplers:\\n hidden_states = upsampler(hidden_states, upsample_size)\\n\\n return hidden_states\\n\\n if self.reference_attn:\\n if self.fusion_blocks == \\\"midup\\\":\\n attn_modules = [module for module in (torch_dfs(self.unet.mid_block)+torch_dfs(self.unet.up_blocks)) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)]\\n elif self.fusion_blocks == \\\"full\\\":\\n attn_modules = [module for module in torch_dfs(self.unet) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)] \\n attn_modules = sorted(attn_modules, key=lambda x: -x.norm1.normalized_shape[0])\\n\\n for i, module in enumerate(attn_modules):\\n module._original_inner_forward = module.forward\\n module.forward = hacked_basic_transformer_inner_forward.__get__(module, BasicTransformerBlock)\\n module.bank = []\\n module.attn_weight = float(i) / float(len(attn_modules))\\n\\n if self.reference_adain:\\n gn_modules = [self.unet.mid_block]\\n self.unet.mid_block.gn_weight = 0\\n\\n down_blocks = self.unet.down_blocks\\n for w, module in enumerate(down_blocks):\\n module.gn_weight = 1.0 - float(w) / float(len(down_blocks))\\n gn_modules.append(module)\\n\\n up_blocks = self.unet.up_blocks\\n for w, module in enumerate(up_blocks):\\n module.gn_weight = float(w) / float(len(up_blocks))\\n gn_modules.append(module)\\n\\n for i, module in enumerate(gn_modules):\\n if getattr(module, \\\"original_forward\\\", None) is None:\\n module.original_forward = module.forward\\n if i == 0:\\n # mid_block\\n module.forward = hacked_mid_forward.__get__(module, torch.nn.Module)\\n elif isinstance(module, CrossAttnDownBlock2D):\\n module.forward = hack_CrossAttnDownBlock2D_forward.__get__(module, CrossAttnDownBlock2D)\\n elif isinstance(module, DownBlock2D):\\n module.forward = hacked_DownBlock2D_forward.__get__(module, DownBlock2D)\\n elif isinstance(module, CrossAttnUpBlock2D):\\n module.forward = hacked_CrossAttnUpBlock2D_forward.__get__(module, CrossAttnUpBlock2D)\\n elif isinstance(module, UpBlock2D):\\n module.forward = hacked_UpBlock2D_forward.__get__(module, UpBlock2D)\\n module.mean_bank = []\\n module.var_bank = []\\n module.gn_weight *= 2\\n \\n def update(self, writer, dtype=torch.float16):\\n if self.reference_attn:\\n if self.fusion_blocks == \\\"midup\\\":\\n reader_attn_modules = [module for module in (torch_dfs(self.unet.mid_block)+torch_dfs(self.unet.up_blocks)) if isinstance(module, _BasicTransformerBlock)]\\n writer_attn_modules = [module for module in (torch_dfs(writer.unet.mid_block)+torch_dfs(writer.unet.up_blocks)) if isinstance(module, BasicTransformerBlock)]\\n elif self.fusion_blocks == \\\"full\\\":\\n reader_attn_modules = [module for module in torch_dfs(self.unet) if isinstance(module, _BasicTransformerBlock)]\\n writer_attn_modules = [module for module in torch_dfs(writer.unet) if isinstance(module, BasicTransformerBlock)]\\n reader_attn_modules = sorted(reader_attn_modules, key=lambda x: -x.norm1.normalized_shape[0]) \\n writer_attn_modules = sorted(writer_attn_modules, key=lambda x: -x.norm1.normalized_shape[0])\\n for r, w in zip(reader_attn_modules, writer_attn_modules):\\n r.bank = [v.clone().to(dtype) for v in w.bank]\\n # w.bank.clear()\\n if self.reference_adain:\\n reader_gn_modules = [self.unet.mid_block]\\n \\n down_blocks = self.unet.down_blocks\\n for w, module in enumerate(down_blocks):\\n reader_gn_modules.append(module)\\n\\n up_blocks = self.unet.up_blocks\\n for w, module in enumerate(up_blocks):\\n reader_gn_modules.append(module)\\n \\n writer_gn_modules = [writer.unet.mid_block]\\n \\n down_blocks = writer.unet.down_blocks\\n for w, module in enumerate(down_blocks):\\n writer_gn_modules.append(module)\\n\\n up_blocks = writer.unet.up_blocks\\n for w, module in enumerate(up_blocks):\\n writer_gn_modules.append(module)\\n \\n for r, w in zip(reader_gn_modules, writer_gn_modules):\\n if len(w.mean_bank) > 0 and isinstance(w.mean_bank[0], list):\\n r.mean_bank = [[v.clone().to(dtype) for v in vl] for vl in w.mean_bank]\\n r.var_bank = [[v.clone().to(dtype) for v in vl] for vl in w.var_bank]\\n else:\\n r.mean_bank = [v.clone().to(dtype) for v in w.mean_bank]\\n r.var_bank = [v.clone().to(dtype) for v in w.var_bank]\\n \\n def clear(self):\\n if self.reference_attn:\\n if self.fusion_blocks == \\\"midup\\\":\\n reader_attn_modules = [module for module in (torch_dfs(self.unet.mid_block)+torch_dfs(self.unet.up_blocks)) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)]\\n elif self.fusion_blocks == \\\"full\\\":\\n reader_attn_modules = [module for module in torch_dfs(self.unet) if isinstance(module, BasicTransformerBlock) or isinstance(module, _BasicTransformerBlock)]\\n reader_attn_modules = sorted(reader_attn_modules, key=lambda x: -x.norm1.normalized_shape[0])\\n for r in reader_attn_modules:\\n r.bank.clear()\\n if self.reference_adain:\\n reader_gn_modules = [self.unet.mid_block]\\n \\n down_blocks = self.unet.down_blocks\\n for w, module in enumerate(down_blocks):\\n reader_gn_modules.append(module)\\n\\n up_blocks = self.unet.up_blocks\\n for w, module in enumerate(up_blocks):\\n reader_gn_modules.append(module)\\n \\n for r in reader_gn_modules:\\n r.mean_bank.clear()\\n r.var_bank.clear()\"\n },\n {\n \"identifier\": \"get_context_scheduler\",\n \"path\": \"magicanimate/pipelines/context.py\",\n \"snippet\": \"def get_context_scheduler(name: str) -> Callable:\\n if name == \\\"uniform\\\":\\n return uniform\\n else:\\n raise ValueError(f\\\"Unknown context_overlap policy {name}\\\")\"\n },\n {\n \"identifier\": \"get_total_steps\",\n \"path\": \"magicanimate/pipelines/context.py\",\n \"snippet\": \"def get_total_steps(\\n scheduler,\\n timesteps: List[int],\\n num_steps: Optional[int] = None,\\n num_frames: int = ...,\\n context_size: Optional[int] = None,\\n context_stride: int = 3,\\n context_overlap: int = 4,\\n closed_loop: bool = True,\\n):\\n return sum(\\n len(\\n list(\\n scheduler(\\n i,\\n num_steps,\\n num_frames,\\n context_size,\\n context_stride,\\n context_overlap,\\n )\\n )\\n )\\n for i in range(len(timesteps))\\n )\"\n },\n {\n \"identifier\": \"get_tensor_interpolation_method\",\n \"path\": \"magicanimate/utils/util.py\",\n \"snippet\": \"def get_tensor_interpolation_method():\\n return tensor_interpolation\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import inspect, math\nimport numpy as np\nimport torch\nimport torch.distributed as dist\nfrom typing import Callable, List, Optional, Union\nfrom dataclasses import dataclass\nfrom PIL import Image\nfrom tqdm import tqdm\nfrom diffusers.utils import is_accelerate_available\nfrom packaging import version\nfrom transformers import CLIPTextModel, CLIPTokenizer\nfrom diffusers.configuration_utils import FrozenDict\nfrom diffusers.models import AutoencoderKL\nfrom diffusers.pipeline_utils import DiffusionPipeline\nfrom diffusers.schedulers import (\n DDIMScheduler,\n DPMSolverMultistepScheduler,\n EulerAncestralDiscreteScheduler,\n EulerDiscreteScheduler,\n LMSDiscreteScheduler,\n PNDMScheduler,\n)\nfrom diffusers.utils import deprecate, logging, BaseOutput\nfrom einops import rearrange\nfrom magicanimate.models.unet_controlnet import UNet3DConditionModel\nfrom magicanimate.models.multicontrolnet import ControlNetProcessor #fix\nfrom magicanimate.models.mutual_self_attention import ReferenceAttentionControl\nfrom magicanimate.pipelines.context import (\n get_context_scheduler,\n get_total_steps\n)\nfrom magicanimate.utils.util import get_tensor_interpolation_method\n from accelerate import cpu_offload"},"token_num":{"kind":"number","value":15775,"string":"15,775"},"cropped_code":{"kind":"string","value":" verbose=False\n ):\n \"\"\"\n Inverse sampling for DDIM Inversion\n \"\"\"\n if verbose:\n print(\"timestep: \", timestep)\n next_step = timestep\n timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999)\n alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod\n alpha_prod_t_next = self.scheduler.alphas_cumprod[next_step]\n beta_prod_t = 1 - alpha_prod_t\n pred_x0 = (x - beta_prod_t**0.5 * model_output) / alpha_prod_t**0.5\n pred_dir = (1 - alpha_prod_t_next)**0.5 * model_output\n x_next = alpha_prod_t_next**0.5 * pred_x0 + pred_dir\n return x_next, pred_x0\n\n @torch.no_grad()\n def images2latents(self, images, dtype):\n \"\"\"\n Convert RGB image to VAE latents\n \"\"\"\n device = self._execution_device\n images = torch.from_numpy(images).float().to(dtype) / 127.5 - 1\n images = rearrange(images, \"f h w c -> f c h w\").to(device)\n latents = []\n for frame_idx in range(images.shape[0]):\n latents.append(self.vae.encode(images[frame_idx:frame_idx+1])['latent_dist'].mean * 0.18215)\n latents = torch.cat(latents)\n return latents\n\n @torch.no_grad()\n def invert(\n self,\n image: torch.Tensor,\n prompt,\n num_inference_steps=20,\n num_actual_inference_steps=10,\n eta=0.0,\n return_intermediates=False,\n **kwargs):\n \"\"\"\n Adapted from: https://github.com/Yujun-Shi/DragDiffusion/blob/main/drag_pipeline.py#L440\n invert a real image into noise map with determinisc DDIM inversion\n \"\"\"\n device = self._execution_device\n batch_size = image.shape[0]\n if isinstance(prompt, list):\n if batch_size == 1:\n image = image.expand(len(prompt), -1, -1, -1)\n elif isinstance(prompt, str):\n if batch_size > 1:\n prompt = [prompt] * batch_size\n\n # text embeddings\n text_input = self.tokenizer(\n prompt,\n padding=\"max_length\",\n max_length=77,\n return_tensors=\"pt\"\n )\n text_embeddings = self.text_encoder(text_input.input_ids.to(device))[0]\n print(\"input text embeddings :\", text_embeddings.shape)\n # define initial latents\n latents = self.images2latents(image)\n\n print(\"latents shape: \", latents.shape)\n # interative sampling\n self.scheduler.set_timesteps(num_inference_steps)\n print(\"Valid timesteps: \", reversed(self.scheduler.timesteps))\n latents_list = [latents]\n pred_x0_list = [latents]\n for i, t in enumerate(tqdm(reversed(self.scheduler.timesteps), desc=\"DDIM Inversion\")):\n\n if num_actual_inference_steps is not None and i >= num_actual_inference_steps:\n continue\n model_inputs = latents\n\n # predict the noise\n # NOTE: the u-net here is UNet3D, therefore the model_inputs need to be of shape (b c f h w)\n model_inputs = rearrange(model_inputs, \"f c h w -> 1 c f h w\")\n noise_pred = self.unet(model_inputs, t, encoder_hidden_states=text_embeddings).sample\n noise_pred = rearrange(noise_pred, \"b c f h w -> (b f) c h w\")\n \n # compute the previous noise sample x_t-1 -> x_t\n latents, pred_x0 = self.next_step(noise_pred, t, latents)\n latents_list.append(latents)\n pred_x0_list.append(pred_x0)\n\n if return_intermediates:\n # return the intermediate laters during inversion\n return latents, latents_list\n return latents\n \n def interpolate_latents(self, latents: torch.Tensor, interpolation_factor:int, device ):\n if interpolation_factor < 2:\n return latents\n\n new_latents = torch.zeros(\n (latents.shape[0],latents.shape[1],((latents.shape[2]-1) * interpolation_factor)+1, latents.shape[3],latents.shape[4]),\n device=latents.device,\n dtype=latents.dtype,\n )\n\n org_video_length = latents.shape[2]\n rate = [i/interpolation_factor for i in range(interpolation_factor)][1:]\n\n new_index = 0\n\n v0 = None\n v1 = None\n\n for i0,i1 in zip( range( org_video_length ),range( org_video_length )[1:] ):\n v0 = latents[:,:,i0,:,:]\n v1 = latents[:,:,i1,:,:]\n\n new_latents[:,:,new_index,:,:] = v0\n new_index += 1\n\n for f in rate:\n"},"all_code":{"kind":"string","value":"# *************************************************************************\n# This file may have been modified by Bytedance Inc. (“Bytedance Inc.'s Mo-\n# difications”). All Bytedance Inc.'s Modifications are Copyright (2023) B-\n# ytedance Inc.. \n# *************************************************************************\n\n# Adapted from https://github.com/showlab/Tune-A-Video/blob/main/tuneavideo/pipelines/pipeline_tuneavideo.py\n\n# Copyright 2023 The HuggingFace Team. All rights reserved.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\"\"\"\nTODO:\n1. support multi-controlnet\n2. [DONE] support DDIM inversion\n3. support Prompt-to-prompt\n\"\"\"\n\n\n\n\n# from magicanimate.models.controlnet import ControlNetModel\n\nlogger = logging.get_logger(__name__) # pylint: disable=invalid-name\n\n\n@dataclass\nclass AnimationPipelineOutput(BaseOutput):\n videos: Union[torch.Tensor, np.ndarray]\n\n\nclass AnimationPipeline(DiffusionPipeline):\n _optional_components = []\n\n def __init__(\n self,\n vae: AutoencoderKL,\n text_encoder: CLIPTextModel,\n tokenizer: CLIPTokenizer,\n unet: UNet3DConditionModel,\n # controlnet: ControlNetModel,\n # processors: List[ControlNetProcessor],\n scheduler: Union[\n DDIMScheduler,\n PNDMScheduler,\n LMSDiscreteScheduler,\n EulerDiscreteScheduler,\n EulerAncestralDiscreteScheduler,\n DPMSolverMultistepScheduler,\n ],\n ):\n super().__init__()\n\n if hasattr(scheduler.config, \"steps_offset\") and scheduler.config.steps_offset != 1:\n deprecation_message = (\n f\"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`\"\n f\" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure \"\n \"to update the config accordingly as leaving `steps_offset` might led to incorrect results\"\n \" in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,\"\n \" it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`\"\n \" file\"\n )\n deprecate(\"steps_offset!=1\", \"1.0.0\", deprecation_message, standard_warn=False)\n new_config = dict(scheduler.config)\n new_config[\"steps_offset\"] = 1\n scheduler._internal_dict = FrozenDict(new_config)\n\n if hasattr(scheduler.config, \"clip_sample\") and scheduler.config.clip_sample is True:\n deprecation_message = (\n f\"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`.\"\n \" `clip_sample` should be set to False in the configuration file. Please make sure to update the\"\n \" config accordingly as not setting `clip_sample` in the config might lead to incorrect results in\"\n \" future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very\"\n \" nice if you could open a Pull request for the `scheduler/scheduler_config.json` file\"\n )\n deprecate(\"clip_sample not set\", \"1.0.0\", deprecation_message, standard_warn=False)\n new_config = dict(scheduler.config)\n new_config[\"clip_sample\"] = False\n scheduler._internal_dict = FrozenDict(new_config)\n\n is_unet_version_less_0_9_0 = hasattr(unet.config, \"_diffusers_version\") and version.parse(\n version.parse(unet.config._diffusers_version).base_version\n ) < version.parse(\"0.9.0.dev0\")\n is_unet_sample_size_less_64 = hasattr(unet.config, \"sample_size\") and unet.config.sample_size < 64\n if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:\n deprecation_message = (\n \"The configuration file of the unet has set the default `sample_size` to smaller than\"\n \" 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the\"\n \" following: \\n- CompVis/stable-diffusion-v1-4 \\n- CompVis/stable-diffusion-v1-3 \\n-\"\n \" CompVis/stable-diffusion-v1-2 \\n- CompVis/stable-diffusion-v1-1 \\n- runwayml/stable-diffusion-v1-5\"\n \" \\n- runwayml/stable-diffusion-inpainting \\n you should change 'sample_size' to 64 in the\"\n \" configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`\"\n \" in the config might lead to incorrect results in future versions. If you have downloaded this\"\n \" checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for\"\n \" the `unet/config.json` file\"\n )\n deprecate(\"sample_size<64\", \"1.0.0\", deprecation_message, standard_warn=False)\n new_config = dict(unet.config)\n new_config[\"sample_size\"] = 64\n unet._internal_dict = FrozenDict(new_config)\n\n self.register_modules(\n vae=vae,\n text_encoder=text_encoder,\n tokenizer=tokenizer,\n unet=unet,\n # controlnet1=processors[0],\n scheduler=scheduler,\n )\n self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)\n\n def enable_vae_slicing(self):\n self.vae.enable_slicing()\n\n def disable_vae_slicing(self):\n self.vae.disable_slicing()\n\n def enable_sequential_cpu_offload(self, gpu_id=0):\n if is_accelerate_available():\n else:\n raise ImportError(\"Please install accelerate via `pip install accelerate`\")\n\n device = torch.device(f\"cuda:{gpu_id}\")\n\n for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae]:\n if cpu_offloaded_model is not None:\n cpu_offload(cpu_offloaded_model, device)\n\n\n @property\n def _execution_device(self):\n if self.device != torch.device(\"meta\") or not hasattr(self.unet, \"_hf_hook\"):\n return self.device\n for module in self.unet.modules():\n if (\n hasattr(module, \"_hf_hook\")\n and hasattr(module._hf_hook, \"execution_device\")\n and module._hf_hook.execution_device is not None\n ):\n return torch.device(module._hf_hook.execution_device)\n return self.device\n\n def _encode_prompt(self, prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt):\n batch_size = len(prompt) if isinstance(prompt, list) else 1\n\n text_inputs = self.tokenizer(\n prompt,\n padding=\"max_length\",\n max_length=self.tokenizer.model_max_length,\n truncation=True,\n return_tensors=\"pt\",\n )\n text_input_ids = text_inputs.input_ids\n untruncated_ids = self.tokenizer(prompt, padding=\"longest\", return_tensors=\"pt\").input_ids\n\n if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids):\n removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])\n logger.warning(\n \"The following part of your input was truncated because CLIP can only handle sequences up to\"\n f\" {self.tokenizer.model_max_length} tokens: {removed_text}\"\n )\n\n if hasattr(self.text_encoder.config, \"use_attention_mask\") and self.text_encoder.config.use_attention_mask:\n attention_mask = text_inputs.attention_mask.to(device)\n else:\n attention_mask = None\n\n text_embeddings = self.text_encoder(\n text_input_ids.to(device),\n attention_mask=attention_mask,\n )\n text_embeddings = text_embeddings[0]\n\n # duplicate text embeddings for each generation per prompt, using mps friendly method\n bs_embed, seq_len, _ = text_embeddings.shape\n text_embeddings = text_embeddings.repeat(1, num_videos_per_prompt, 1)\n text_embeddings = text_embeddings.view(bs_embed * num_videos_per_prompt, seq_len, -1)\n\n # get unconditional embeddings for classifier free guidance\n if do_classifier_free_guidance:\n uncond_tokens: List[str]\n if negative_prompt is None:\n uncond_tokens = [\"\"] * batch_size\n elif type(prompt) is not type(negative_prompt):\n raise TypeError(\n f\"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !=\"\n f\" {type(prompt)}.\"\n )\n elif isinstance(negative_prompt, str):\n uncond_tokens = [negative_prompt]\n elif batch_size != len(negative_prompt):\n raise ValueError(\n f\"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:\"\n f\" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches\"\n \" the batch size of `prompt`.\"\n )\n else:\n uncond_tokens = negative_prompt\n\n max_length = text_input_ids.shape[-1]\n uncond_input = self.tokenizer(\n uncond_tokens,\n padding=\"max_length\",\n max_length=max_length,\n truncation=True,\n return_tensors=\"pt\",\n )\n\n if hasattr(self.text_encoder.config, \"use_attention_mask\") and self.text_encoder.config.use_attention_mask:\n attention_mask = uncond_input.attention_mask.to(device)\n else:\n attention_mask = None\n\n uncond_embeddings = self.text_encoder(\n uncond_input.input_ids.to(device),\n attention_mask=attention_mask,\n )\n uncond_embeddings = uncond_embeddings[0]\n\n # duplicate unconditional embeddings for each generation per prompt, using mps friendly method\n seq_len = uncond_embeddings.shape[1]\n uncond_embeddings = uncond_embeddings.repeat(1, num_videos_per_prompt, 1)\n uncond_embeddings = uncond_embeddings.view(batch_size * num_videos_per_prompt, seq_len, -1)\n\n # For classifier free guidance, we need to do two forward passes.\n # Here we concatenate the unconditional and text embeddings into a single batch\n # to avoid doing two forward passes\n text_embeddings = torch.cat([uncond_embeddings, text_embeddings])\n\n return text_embeddings\n\n def decode_latents(self, latents, rank, decoder_consistency=None):\n video_length = latents.shape[2]\n latents = 1 / 0.18215 * latents\n latents = rearrange(latents, \"b c f h w -> (b f) c h w\")\n # video = self.vae.decode(latents).sample\n video = []\n for frame_idx in tqdm(range(latents.shape[0]), disable=(rank!=0)):\n if decoder_consistency is not None:\n video.append(decoder_consistency(latents[frame_idx:frame_idx+1]))\n else:\n video.append(self.vae.decode(latents[frame_idx:frame_idx+1]).sample)\n video = torch.cat(video)\n video = rearrange(video, \"(b f) c h w -> b c f h w\", f=video_length)\n video = (video / 2 + 0.5).clamp(0, 1)\n # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16\n video = video.cpu().float().numpy()\n return video\n\n def prepare_extra_step_kwargs(self, generator, eta):\n # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature\n # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.\n # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502\n # and should be between [0, 1]\n\n accepts_eta = \"eta\" in set(inspect.signature(self.scheduler.step).parameters.keys())\n extra_step_kwargs = {}\n if accepts_eta:\n extra_step_kwargs[\"eta\"] = eta\n\n # check if the scheduler accepts generator\n accepts_generator = \"generator\" in set(inspect.signature(self.scheduler.step).parameters.keys())\n if accepts_generator:\n extra_step_kwargs[\"generator\"] = generator\n return extra_step_kwargs\n\n def check_inputs(self, prompt, height, width, callback_steps):\n if not isinstance(prompt, str) and not isinstance(prompt, list):\n raise ValueError(f\"`prompt` has to be of type `str` or `list` but is {type(prompt)}\")\n\n if height % 8 != 0 or width % 8 != 0:\n raise ValueError(f\"`height` and `width` have to be divisible by 8 but are {height} and {width}.\")\n\n if (callback_steps is None) or (\n callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)\n ):\n raise ValueError(\n f\"`callback_steps` has to be a positive integer but is {callback_steps} of type\"\n f\" {type(callback_steps)}.\"\n )\n\n def prepare_latents(self, batch_size, num_channels_latents, video_length, height, width, dtype, device, generator, latents=None, clip_length=16):\n shape = (batch_size, num_channels_latents, clip_length, height // self.vae_scale_factor, width // self.vae_scale_factor)\n if isinstance(generator, list) and len(generator) != batch_size:\n raise ValueError(\n f\"You have passed a list of generators of length {len(generator)}, but requested an effective batch\"\n f\" size of {batch_size}. Make sure the batch size matches the length of the generators.\"\n )\n if latents is None:\n rand_device = \"cpu\" if device.type == \"mps\" else device\n\n if isinstance(generator, list):\n latents = [\n torch.randn(shape, generator=generator[i], device=rand_device, dtype=dtype)\n for i in range(batch_size)\n ]\n latents = torch.cat(latents, dim=0).to(device)\n else:\n latents = torch.randn(shape, generator=generator, device=rand_device, dtype=dtype).to(device)\n \n latents = latents.repeat(1, 1, video_length//clip_length, 1, 1)\n else:\n if latents.shape != shape:\n raise ValueError(f\"Unexpected latents shape, got {latents.shape}, expected {shape}\")\n latents = latents.to(device)\n\n # scale the initial noise by the standard deviation required by the scheduler\n latents = latents * self.scheduler.init_noise_sigma\n return latents\n\n def prepare_condition(self, condition1, condition2, num_videos_per_prompt, device, dtype, do_classifier_free_guidance):\n # Prepare first condition\n condition1 = torch.from_numpy(condition1.copy()).to(device=device, dtype=dtype) / 255.0\n condition1 = torch.stack([condition1 for _ in range(num_videos_per_prompt)], dim=0)\n condition1 = rearrange(condition1, 'b f h w c -> (b f) c h w').clone()\n\n # Prepare second condition\n condition2 = torch.from_numpy(condition2.copy()).to(device=device, dtype=dtype) / 255.0\n condition2 = torch.stack([condition2 for _ in range(num_videos_per_prompt)], dim=0)\n condition2 = rearrange(condition2, 'b f h w c -> (b f) c h w').clone()\n\n # Here, we're averaging the two conditions\n combined_condition = (condition1*8+condition2*2)/10\n\n if do_classifier_free_guidance:\n combined_condition = torch.cat([combined_condition] * 2)\n\n #combined_condition = torch.from_numpy(combined_condition.copy()).to(device=device, dtype=dtype)\n return combined_condition\n\n def next_step(\n self,\n model_output: torch.FloatTensor,\n timestep: int,\n x: torch.FloatTensor,\n eta=0.,\n verbose=False\n ):\n \"\"\"\n Inverse sampling for DDIM Inversion\n \"\"\"\n if verbose:\n print(\"timestep: \", timestep)\n next_step = timestep\n timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999)\n alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod\n alpha_prod_t_next = self.scheduler.alphas_cumprod[next_step]\n beta_prod_t = 1 - alpha_prod_t\n pred_x0 = (x - beta_prod_t**0.5 * model_output) / alpha_prod_t**0.5\n pred_dir = (1 - alpha_prod_t_next)**0.5 * model_output\n x_next = alpha_prod_t_next**0.5 * pred_x0 + pred_dir\n return x_next, pred_x0\n\n @torch.no_grad()\n def images2latents(self, images, dtype):\n \"\"\"\n Convert RGB image to VAE latents\n \"\"\"\n device = self._execution_device\n images = torch.from_numpy(images).float().to(dtype) / 127.5 - 1\n images = rearrange(images, \"f h w c -> f c h w\").to(device)\n latents = []\n for frame_idx in range(images.shape[0]):\n latents.append(self.vae.encode(images[frame_idx:frame_idx+1])['latent_dist'].mean * 0.18215)\n latents = torch.cat(latents)\n return latents\n\n @torch.no_grad()\n def invert(\n self,\n image: torch.Tensor,\n prompt,\n num_inference_steps=20,\n num_actual_inference_steps=10,\n eta=0.0,\n return_intermediates=False,\n **kwargs):\n \"\"\"\n Adapted from: https://github.com/Yujun-Shi/DragDiffusion/blob/main/drag_pipeline.py#L440\n invert a real image into noise map with determinisc DDIM inversion\n \"\"\"\n device = self._execution_device\n batch_size = image.shape[0]\n if isinstance(prompt, list):\n if batch_size == 1:\n image = image.expand(len(prompt), -1, -1, -1)\n elif isinstance(prompt, str):\n if batch_size > 1:\n prompt = [prompt] * batch_size\n\n # text embeddings\n text_input = self.tokenizer(\n prompt,\n padding=\"max_length\",\n max_length=77,\n return_tensors=\"pt\"\n )\n text_embeddings = self.text_encoder(text_input.input_ids.to(device))[0]\n print(\"input text embeddings :\", text_embeddings.shape)\n # define initial latents\n latents = self.images2latents(image)\n\n print(\"latents shape: \", latents.shape)\n # interative sampling\n self.scheduler.set_timesteps(num_inference_steps)\n print(\"Valid timesteps: \", reversed(self.scheduler.timesteps))\n latents_list = [latents]\n pred_x0_list = [latents]\n for i, t in enumerate(tqdm(reversed(self.scheduler.timesteps), desc=\"DDIM Inversion\")):\n\n if num_actual_inference_steps is not None and i >= num_actual_inference_steps:\n continue\n model_inputs = latents\n\n # predict the noise\n # NOTE: the u-net here is UNet3D, therefore the model_inputs need to be of shape (b c f h w)\n model_inputs = rearrange(model_inputs, \"f c h w -> 1 c f h w\")\n noise_pred = self.unet(model_inputs, t, encoder_hidden_states=text_embeddings).sample\n noise_pred = rearrange(noise_pred, \"b c f h w -> (b f) c h w\")\n \n # compute the previous noise sample x_t-1 -> x_t\n latents, pred_x0 = self.next_step(noise_pred, t, latents)\n latents_list.append(latents)\n pred_x0_list.append(pred_x0)\n\n if return_intermediates:\n # return the intermediate laters during inversion\n return latents, latents_list\n return latents\n \n def interpolate_latents(self, latents: torch.Tensor, interpolation_factor:int, device ):\n if interpolation_factor < 2:\n return latents\n\n new_latents = torch.zeros(\n (latents.shape[0],latents.shape[1],((latents.shape[2]-1) * interpolation_factor)+1, latents.shape[3],latents.shape[4]),\n device=latents.device,\n dtype=latents.dtype,\n )\n\n org_video_length = latents.shape[2]\n rate = [i/interpolation_factor for i in range(interpolation_factor)][1:]\n\n new_index = 0\n\n v0 = None\n v1 = None\n\n for i0,i1 in zip( range( org_video_length ),range( org_video_length )[1:] ):\n v0 = latents[:,:,i0,:,:]\n v1 = latents[:,:,i1,:,:]\n\n new_latents[:,:,new_index,:,:] = v0\n new_index += 1\n\n for f in rate:"},"next_line":{"kind":"string","value":" v = get_tensor_interpolation_method()(v0.to(device=device),v1.to(device=device),f)"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-12-15 01:22:37+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5679,"cells":{"repo_name":{"kind":"string","value":"Azure-Samples/functions-python-web-crawler"},"file_path":{"kind":"string","value":".venv/Lib/site-packages/urllib3/connection.py"},"context":{"kind":"list like","value":[{"identifier":"HTTPHeaderDict","path":".venv/Lib/site-packages/urllib3/_collections.py","snippet":"class HTTPHeaderDict(typing.MutableMapping[str, str]):\n \"\"\"\n :param headers:\n An iterable of field-value pairs. Must not contain multiple field names\n when compared case-insensitively.\n\n :param kwargs:\n Additional field-value pairs to pass in to ``dict.update``.\n\n A ``dict`` like container for storing HTTP Headers.\n\n Field names are stored and compared case-insensitively in compliance with\n RFC 7230. Iteration provides the first case-sensitive key seen for each\n case-insensitive pair.\n\n Using ``__setitem__`` syntax overwrites fields that compare equal\n case-insensitively in order to maintain ``dict``'s api. For fields that\n compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``\n in a loop.\n\n If multiple fields that are equal case-insensitively are passed to the\n constructor or ``.update``, the behavior is undefined and some will be\n lost.\n\n >>> headers = HTTPHeaderDict()\n >>> headers.add('Set-Cookie', 'foo=bar')\n >>> headers.add('set-cookie', 'baz=quxx')\n >>> headers['content-length'] = '7'\n >>> headers['SET-cookie']\n 'foo=bar, baz=quxx'\n >>> headers['Content-Length']\n '7'\n \"\"\"\n\n _container: typing.MutableMapping[str, list[str]]\n\n def __init__(self, headers: ValidHTTPHeaderSource | None = None, **kwargs: str):\n super().__init__()\n self._container = {} # 'dict' is insert-ordered\n if headers is not None:\n if isinstance(headers, HTTPHeaderDict):\n self._copy_from(headers)\n else:\n self.extend(headers)\n if kwargs:\n self.extend(kwargs)\n\n def __setitem__(self, key: str, val: str) -> None:\n # avoid a bytes/str comparison by decoding before httplib\n if isinstance(key, bytes):\n key = key.decode(\"latin-1\")\n self._container[key.lower()] = [key, val]\n\n def __getitem__(self, key: str) -> str:\n val = self._container[key.lower()]\n return \", \".join(val[1:])\n\n def __delitem__(self, key: str) -> None:\n del self._container[key.lower()]\n\n def __contains__(self, key: object) -> bool:\n if isinstance(key, str):\n return key.lower() in self._container\n return False\n\n def setdefault(self, key: str, default: str = \"\") -> str:\n return super().setdefault(key, default)\n\n def __eq__(self, other: object) -> bool:\n maybe_constructable = ensure_can_construct_http_header_dict(other)\n if maybe_constructable is None:\n return False\n else:\n other_as_http_header_dict = type(self)(maybe_constructable)\n\n return {k.lower(): v for k, v in self.itermerged()} == {\n k.lower(): v for k, v in other_as_http_header_dict.itermerged()\n }\n\n def __ne__(self, other: object) -> bool:\n return not self.__eq__(other)\n\n def __len__(self) -> int:\n return len(self._container)\n\n def __iter__(self) -> typing.Iterator[str]:\n # Only provide the originally cased names\n for vals in self._container.values():\n yield vals[0]\n\n def discard(self, key: str) -> None:\n try:\n del self[key]\n except KeyError:\n pass\n\n def add(self, key: str, val: str, *, combine: bool = False) -> None:\n \"\"\"Adds a (name, value) pair, doesn't overwrite the value if it already\n exists.\n\n If this is called with combine=True, instead of adding a new header value\n as a distinct item during iteration, this will instead append the value to\n any existing header value with a comma. If no existing header value exists\n for the key, then the value will simply be added, ignoring the combine parameter.\n\n >>> headers = HTTPHeaderDict(foo='bar')\n >>> headers.add('Foo', 'baz')\n >>> headers['foo']\n 'bar, baz'\n >>> list(headers.items())\n [('foo', 'bar'), ('foo', 'baz')]\n >>> headers.add('foo', 'quz', combine=True)\n >>> list(headers.items())\n [('foo', 'bar, baz, quz')]\n \"\"\"\n # avoid a bytes/str comparison by decoding before httplib\n if isinstance(key, bytes):\n key = key.decode(\"latin-1\")\n key_lower = key.lower()\n new_vals = [key, val]\n # Keep the common case aka no item present as fast as possible\n vals = self._container.setdefault(key_lower, new_vals)\n if new_vals is not vals:\n # if there are values here, then there is at least the initial\n # key/value pair\n assert len(vals) >= 2\n if combine:\n vals[-1] = vals[-1] + \", \" + val\n else:\n vals.append(val)\n\n def extend(self, *args: ValidHTTPHeaderSource, **kwargs: str) -> None:\n \"\"\"Generic import function for any type of header-like object.\n Adapted version of MutableMapping.update in order to insert items\n with self.add instead of self.__setitem__\n \"\"\"\n if len(args) > 1:\n raise TypeError(\n f\"extend() takes at most 1 positional arguments ({len(args)} given)\"\n )\n other = args[0] if len(args) >= 1 else ()\n\n if isinstance(other, HTTPHeaderDict):\n for key, val in other.iteritems():\n self.add(key, val)\n elif isinstance(other, typing.Mapping):\n for key, val in other.items():\n self.add(key, val)\n elif isinstance(other, typing.Iterable):\n other = typing.cast(typing.Iterable[typing.Tuple[str, str]], other)\n for key, value in other:\n self.add(key, value)\n elif hasattr(other, \"keys\") and hasattr(other, \"__getitem__\"):\n # THIS IS NOT A TYPESAFE BRANCH\n # In this branch, the object has a `keys` attr but is not a Mapping or any of\n # the other types indicated in the method signature. We do some stuff with\n # it as though it partially implements the Mapping interface, but we're not\n # doing that stuff safely AT ALL.\n for key in other.keys():\n self.add(key, other[key])\n\n for key, value in kwargs.items():\n self.add(key, value)\n\n @typing.overload\n def getlist(self, key: str) -> list[str]:\n ...\n\n @typing.overload\n def getlist(self, key: str, default: _DT) -> list[str] | _DT:\n ...\n\n def getlist(\n self, key: str, default: _Sentinel | _DT = _Sentinel.not_passed\n ) -> list[str] | _DT:\n \"\"\"Returns a list of all the values for the named field. Returns an\n empty list if the key doesn't exist.\"\"\"\n try:\n vals = self._container[key.lower()]\n except KeyError:\n if default is _Sentinel.not_passed:\n # _DT is unbound; empty list is instance of List[str]\n return []\n # _DT is bound; default is instance of _DT\n return default\n else:\n # _DT may or may not be bound; vals[1:] is instance of List[str], which\n # meets our external interface requirement of `Union[List[str], _DT]`.\n return vals[1:]\n\n def _prepare_for_method_change(self) -> Self:\n \"\"\"\n Remove content-specific header fields before changing the request\n method to GET or HEAD according to RFC 9110, Section 15.4.\n \"\"\"\n content_specific_headers = [\n \"Content-Encoding\",\n \"Content-Language\",\n \"Content-Location\",\n \"Content-Type\",\n \"Content-Length\",\n \"Digest\",\n \"Last-Modified\",\n ]\n for header in content_specific_headers:\n self.discard(header)\n return self\n\n # Backwards compatibility for httplib\n getheaders = getlist\n getallmatchingheaders = getlist\n iget = getlist\n\n # Backwards compatibility for http.cookiejar\n get_all = getlist\n\n def __repr__(self) -> str:\n return f\"{type(self).__name__}({dict(self.itermerged())})\"\n\n def _copy_from(self, other: HTTPHeaderDict) -> None:\n for key in other:\n val = other.getlist(key)\n self._container[key.lower()] = [key, *val]\n\n def copy(self) -> HTTPHeaderDict:\n clone = type(self)()\n clone._copy_from(self)\n return clone\n\n def iteritems(self) -> typing.Iterator[tuple[str, str]]:\n \"\"\"Iterate over all header lines, including duplicate ones.\"\"\"\n for key in self:\n vals = self._container[key.lower()]\n for val in vals[1:]:\n yield vals[0], val\n\n def itermerged(self) -> typing.Iterator[tuple[str, str]]:\n \"\"\"Iterate over all headers, merging duplicate ones together.\"\"\"\n for key in self:\n val = self._container[key.lower()]\n yield val[0], \", \".join(val[1:])\n\n def items(self) -> HTTPHeaderDictItemView: # type: ignore[override]\n return HTTPHeaderDictItemView(self)\n\n def _has_value_for_header(self, header_name: str, potential_value: str) -> bool:\n if header_name in self:\n return potential_value in self._container[header_name.lower()][1:]\n return False\n\n def __ior__(self, other: object) -> HTTPHeaderDict:\n # Supports extending a header dict in-place using operator |=\n # combining items with add instead of __setitem__\n maybe_constructable = ensure_can_construct_http_header_dict(other)\n if maybe_constructable is None:\n return NotImplemented\n self.extend(maybe_constructable)\n return self\n\n def __or__(self, other: object) -> HTTPHeaderDict:\n # Supports merging header dicts using operator |\n # combining items with add instead of __setitem__\n maybe_constructable = ensure_can_construct_http_header_dict(other)\n if maybe_constructable is None:\n return NotImplemented\n result = self.copy()\n result.extend(maybe_constructable)\n return result\n\n def __ror__(self, other: object) -> HTTPHeaderDict:\n # Supports merging header dicts using operator | when other is on left side\n # combining items with add instead of __setitem__\n maybe_constructable = ensure_can_construct_http_header_dict(other)\n if maybe_constructable is None:\n return NotImplemented\n result = type(self)(maybe_constructable)\n result.extend(self)\n return result"},{"identifier":"assert_header_parsing","path":".venv/Lib/site-packages/urllib3/util/response.py","snippet":"def assert_header_parsing(headers: httplib.HTTPMessage) -> None:\n \"\"\"\n Asserts whether all headers have been successfully parsed.\n Extracts encountered errors from the result of parsing headers.\n\n Only works on Python 3.\n\n :param http.client.HTTPMessage headers: Headers to verify.\n\n :raises urllib3.exceptions.HeaderParsingError:\n If parsing errors are found.\n \"\"\"\n\n # This will fail silently if we pass in the wrong kind of parameter.\n # To make debugging easier add an explicit check.\n if not isinstance(headers, httplib.HTTPMessage):\n raise TypeError(f\"expected httplib.Message, got {type(headers)}.\")\n\n unparsed_data = None\n\n # get_payload is actually email.message.Message.get_payload;\n # we're only interested in the result if it's not a multipart message\n if not headers.is_multipart():\n payload = headers.get_payload()\n\n if isinstance(payload, (bytes, str)):\n unparsed_data = payload\n\n # httplib is assuming a response body is available\n # when parsing headers even when httplib only sends\n # header data to parse_headers() This results in\n # defects on multipart responses in particular.\n # See: https://github.com/urllib3/urllib3/issues/800\n\n # So we ignore the following defects:\n # - StartBoundaryNotFoundDefect:\n # The claimed start boundary was never found.\n # - MultipartInvariantViolationDefect:\n # A message claimed to be a multipart but no subparts were found.\n defects = [\n defect\n for defect in headers.defects\n if not isinstance(\n defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect)\n )\n ]\n\n if defects or unparsed_data:\n raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)"},{"identifier":"_DEFAULT_TIMEOUT","path":".venv/Lib/site-packages/urllib3/util/timeout.py","snippet":"_DEFAULT_TIMEOUT: Final[_TYPE_DEFAULT] = _TYPE_DEFAULT.token"},{"identifier":"_TYPE_TIMEOUT","path":".venv/Lib/site-packages/urllib3/util/timeout.py","snippet":"_TYPE_TIMEOUT = typing.Optional[typing.Union[float, _TYPE_DEFAULT]]"},{"identifier":"Timeout","path":".venv/Lib/site-packages/urllib3/util/timeout.py","snippet":"class Timeout:\n \"\"\"Timeout configuration.\n\n Timeouts can be defined as a default for a pool:\n\n .. code-block:: python\n\n import urllib3\n\n timeout = urllib3.util.Timeout(connect=2.0, read=7.0)\n\n http = urllib3.PoolManager(timeout=timeout)\n\n resp = http.request(\"GET\", \"https://example.com/\")\n\n print(resp.status)\n\n Or per-request (which overrides the default for the pool):\n\n .. code-block:: python\n\n response = http.request(\"GET\", \"https://example.com/\", timeout=Timeout(10))\n\n Timeouts can be disabled by setting all the parameters to ``None``:\n\n .. code-block:: python\n\n no_timeout = Timeout(connect=None, read=None)\n response = http.request(\"GET\", \"https://example.com/\", timeout=no_timeout)\n\n\n :param total:\n This combines the connect and read timeouts into one; the read timeout\n will be set to the time leftover from the connect attempt. In the\n event that both a connect timeout and a total are specified, or a read\n timeout and a total are specified, the shorter timeout will be applied.\n\n Defaults to None.\n\n :type total: int, float, or None\n\n :param connect:\n The maximum amount of time (in seconds) to wait for a connection\n attempt to a server to succeed. Omitting the parameter will default the\n connect timeout to the system default, probably `the global default\n timeout in socket.py\n <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.\n None will set an infinite timeout for connection attempts.\n\n :type connect: int, float, or None\n\n :param read:\n The maximum amount of time (in seconds) to wait between consecutive\n read operations for a response from the server. Omitting the parameter\n will default the read timeout to the system default, probably `the\n global default timeout in socket.py\n <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.\n None will set an infinite timeout.\n\n :type read: int, float, or None\n\n .. note::\n\n Many factors can affect the total amount of time for urllib3 to return\n an HTTP response.\n\n For example, Python's DNS resolver does not obey the timeout specified\n on the socket. Other factors that can affect total request time include\n high CPU load, high swap, the program running at a low priority level,\n or other behaviors.\n\n In addition, the read and total timeouts only measure the time between\n read operations on the socket connecting the client and the server,\n not the total amount of time for the request to return a complete\n response. For most requests, the timeout is raised because the server\n has not sent the first byte in the specified time. This is not always\n the case; if a server streams one byte every fifteen seconds, a timeout\n of 20 seconds will not trigger, even though the request will take\n several minutes to complete.\n\n If your goal is to cut off any request after a set amount of wall clock\n time, consider having a second \"watcher\" thread to cut off a slow\n request.\n \"\"\"\n\n #: A sentinel object representing the default timeout value\n DEFAULT_TIMEOUT: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT\n\n def __init__(\n self,\n total: _TYPE_TIMEOUT = None,\n connect: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\n read: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\n ) -> None:\n self._connect = self._validate_timeout(connect, \"connect\")\n self._read = self._validate_timeout(read, \"read\")\n self.total = self._validate_timeout(total, \"total\")\n self._start_connect: float | None = None\n\n def __repr__(self) -> str:\n return f\"{type(self).__name__}(connect={self._connect!r}, read={self._read!r}, total={self.total!r})\"\n\n # __str__ provided for backwards compatibility\n __str__ = __repr__\n\n @staticmethod\n def resolve_default_timeout(timeout: _TYPE_TIMEOUT) -> float | None:\n return getdefaulttimeout() if timeout is _DEFAULT_TIMEOUT else timeout\n\n @classmethod\n def _validate_timeout(cls, value: _TYPE_TIMEOUT, name: str) -> _TYPE_TIMEOUT:\n \"\"\"Check that a timeout attribute is valid.\n\n :param value: The timeout value to validate\n :param name: The name of the timeout attribute to validate. This is\n used to specify in error messages.\n :return: The validated and casted version of the given value.\n :raises ValueError: If it is a numeric value less than or equal to\n zero, or the type is not an integer, float, or None.\n \"\"\"\n if value is None or value is _DEFAULT_TIMEOUT:\n return value\n\n if isinstance(value, bool):\n raise ValueError(\n \"Timeout cannot be a boolean value. It must \"\n \"be an int, float or None.\"\n )\n try:\n float(value)\n except (TypeError, ValueError):\n raise ValueError(\n \"Timeout value %s was %s, but it must be an \"\n \"int, float or None.\" % (name, value)\n ) from None\n\n try:\n if value <= 0:\n raise ValueError(\n \"Attempted to set %s timeout to %s, but the \"\n \"timeout cannot be set to a value less \"\n \"than or equal to 0.\" % (name, value)\n )\n except TypeError:\n raise ValueError(\n \"Timeout value %s was %s, but it must be an \"\n \"int, float or None.\" % (name, value)\n ) from None\n\n return value\n\n @classmethod\n def from_float(cls, timeout: _TYPE_TIMEOUT) -> Timeout:\n \"\"\"Create a new Timeout from a legacy timeout value.\n\n The timeout value used by httplib.py sets the same timeout on the\n connect(), and recv() socket requests. This creates a :class:`Timeout`\n object that sets the individual timeouts to the ``timeout`` value\n passed to this function.\n\n :param timeout: The legacy timeout value.\n :type timeout: integer, float, :attr:`urllib3.util.Timeout.DEFAULT_TIMEOUT`, or None\n :return: Timeout object\n :rtype: :class:`Timeout`\n \"\"\"\n return Timeout(read=timeout, connect=timeout)\n\n def clone(self) -> Timeout:\n \"\"\"Create a copy of the timeout object\n\n Timeout properties are stored per-pool but each request needs a fresh\n Timeout object to ensure each one has its own start/stop configured.\n\n :return: a copy of the timeout object\n :rtype: :class:`Timeout`\n \"\"\"\n # We can't use copy.deepcopy because that will also create a new object\n # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to\n # detect the user default.\n return Timeout(connect=self._connect, read=self._read, total=self.total)\n\n def start_connect(self) -> float:\n \"\"\"Start the timeout clock, used during a connect() attempt\n\n :raises urllib3.exceptions.TimeoutStateError: if you attempt\n to start a timer that has been started already.\n \"\"\"\n if self._start_connect is not None:\n raise TimeoutStateError(\"Timeout timer has already been started.\")\n self._start_connect = time.monotonic()\n return self._start_connect\n\n def get_connect_duration(self) -> float:\n \"\"\"Gets the time elapsed since the call to :meth:`start_connect`.\n\n :return: Elapsed time in seconds.\n :rtype: float\n :raises urllib3.exceptions.TimeoutStateError: if you attempt\n to get duration for a timer that hasn't been started.\n \"\"\"\n if self._start_connect is None:\n raise TimeoutStateError(\n \"Can't get connect duration for timer that has not started.\"\n )\n return time.monotonic() - self._start_connect\n\n @property\n def connect_timeout(self) -> _TYPE_TIMEOUT:\n \"\"\"Get the value to use when setting a connection timeout.\n\n This will be a positive float or integer, the value None\n (never timeout), or the default system timeout.\n\n :return: Connect timeout.\n :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None\n \"\"\"\n if self.total is None:\n return self._connect\n\n if self._connect is None or self._connect is _DEFAULT_TIMEOUT:\n return self.total\n\n return min(self._connect, self.total) # type: ignore[type-var]\n\n @property\n def read_timeout(self) -> float | None:\n \"\"\"Get the value for the read timeout.\n\n This assumes some time has elapsed in the connection timeout and\n computes the read timeout appropriately.\n\n If self.total is set, the read timeout is dependent on the amount of\n time taken by the connect timeout. If the connection time has not been\n established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be\n raised.\n\n :return: Value to use for the read timeout.\n :rtype: int, float or None\n :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`\n has not yet been called on this object.\n \"\"\"\n if (\n self.total is not None\n and self.total is not _DEFAULT_TIMEOUT\n and self._read is not None\n and self._read is not _DEFAULT_TIMEOUT\n ):\n # In case the connect timeout has not yet been established.\n if self._start_connect is None:\n return self._read\n return max(0, min(self.total - self.get_connect_duration(), self._read))\n elif self.total is not None and self.total is not _DEFAULT_TIMEOUT:\n return max(0, self.total - self.get_connect_duration())\n else:\n return self.resolve_default_timeout(self._read)"},{"identifier":"to_str","path":".venv/Lib/site-packages/urllib3/util/util.py","snippet":"def to_str(\n x: str | bytes, encoding: str | None = None, errors: str | None = None\n) -> str:\n if isinstance(x, str):\n return x\n elif not isinstance(x, bytes):\n raise TypeError(f\"not expecting type {type(x).__name__}\")\n if encoding or errors:\n return x.decode(encoding or \"utf-8\", errors=errors or \"strict\")\n return x.decode()"},{"identifier":"wait_for_read","path":".venv/Lib/site-packages/urllib3/util/wait.py","snippet":"def wait_for_read(sock: socket.socket, timeout: float | None = None) -> bool:\n \"\"\"Waits for reading to be available on a given socket.\n Returns True if the socket is readable, or False if the timeout expired.\n \"\"\"\n return wait_for_socket(sock, read=True, timeout=timeout)"},{"identifier":"_TYPE_BODY","path":".venv/Lib/site-packages/urllib3/_base_connection.py","snippet":"_TYPE_BODY = typing.Union[bytes, typing.IO[typing.Any], typing.Iterable[bytes], str]"},{"identifier":"ProxyConfig","path":".venv/Lib/site-packages/urllib3/_base_connection.py","snippet":"class ProxyConfig(typing.NamedTuple):\n ssl_context: ssl.SSLContext | None\n use_forwarding_for_https: bool\n assert_hostname: None | str | Literal[False]\n assert_fingerprint: str | None"},{"identifier":"_ResponseOptions","path":".venv/Lib/site-packages/urllib3/_base_connection.py","snippet":"class _ResponseOptions(typing.NamedTuple):\n # TODO: Remove this in favor of a better\n # HTTP request/response lifecycle tracking.\n request_method: str\n request_url: str\n preload_content: bool\n decode_content: bool\n enforce_content_length: bool"},{"identifier":"__version__","path":".venv/Lib/site-packages/urllib3/_version.py","snippet":""},{"identifier":"ConnectTimeoutError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class ConnectTimeoutError(TimeoutError):\n \"\"\"Raised when a socket timeout occurs while connecting to a server\"\"\""},{"identifier":"HeaderParsingError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class HeaderParsingError(HTTPError):\n \"\"\"Raised by assert_header_parsing, but we convert it to a log.warning statement.\"\"\"\n\n def __init__(\n self, defects: list[MessageDefect], unparsed_data: bytes | str | None\n ) -> None:\n message = f\"{defects or 'Unknown'}, unparsed data: {unparsed_data!r}\"\n super().__init__(message)"},{"identifier":"NameResolutionError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class NameResolutionError(NewConnectionError):\n \"\"\"Raised when host name resolution fails.\"\"\"\n\n def __init__(self, host: str, conn: HTTPConnection, reason: socket.gaierror):\n message = f\"Failed to resolve '{host}' ({reason})\"\n super().__init__(conn, message)"},{"identifier":"NewConnectionError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class NewConnectionError(ConnectTimeoutError, HTTPError):\n \"\"\"Raised when we fail to establish a new connection. Usually ECONNREFUSED.\"\"\"\n\n def __init__(self, conn: HTTPConnection, message: str) -> None:\n self.conn = conn\n super().__init__(f\"{conn}: {message}\")\n\n @property\n def pool(self) -> HTTPConnection:\n warnings.warn(\n \"The 'pool' property is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Use 'conn' instead.\",\n DeprecationWarning,\n stacklevel=2,\n )\n\n return self.conn"},{"identifier":"ProxyError","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class ProxyError(HTTPError):\n \"\"\"Raised when the connection to a proxy fails.\"\"\"\n\n # The original error is also available as __cause__.\n original_error: Exception\n\n def __init__(self, message: str, error: Exception) -> None:\n super().__init__(message, error)\n self.original_error = error"},{"identifier":"SystemTimeWarning","path":".venv/Lib/site-packages/urllib3/exceptions.py","snippet":"class SystemTimeWarning(SecurityWarning):\n \"\"\"Warned when system time is suspected to be wrong\"\"\""},{"identifier":"connection","path":".venv/Lib/site-packages/urllib3/util/connection.py","snippet":"_TYPE_SOCKET_OPTIONS = typing.Sequence[typing.Tuple[int, int, typing.Union[int, bytes]]]\nHAS_IPV6 = _has_ipv6(\"::1\")\ndef is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific\ndef create_connection(\n address: tuple[str, int],\n timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\n source_address: tuple[str, int] | None = None,\n socket_options: _TYPE_SOCKET_OPTIONS | None = None,\n) -> socket.socket:\ndef _set_socket_options(\n sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None\n) -> None:\ndef allowed_gai_family() -> socket.AddressFamily:\ndef _has_ipv6(host: str) -> bool:"},{"identifier":"ssl_","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"HAS_NEVER_CHECK_COMMON_NAME = False\nIS_PYOPENSSL = False\nALPN_PROTOCOLS = [\"http/1.1\"]\n_TYPE_VERSION_INFO = typing.Tuple[int, int, int, str, int]\nHASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256}\n_SSL_VERSION_TO_TLS_VERSION: dict[int, int] = {}\n HAS_NEVER_CHECK_COMMON_NAME = False\n OP_NO_COMPRESSION = 0x20000 # type: ignore[assignment]\n OP_NO_TICKET = 0x4000 # type: ignore[assignment]\n PROTOCOL_TLS_CLIENT = 16 # type: ignore[assignment]\n_TYPE_PEER_CERT_RET = typing.Union[\"_TYPE_PEER_CERT_RET_DICT\", bytes, None]\ndef _is_bpo_43522_fixed(\n implementation_name: str,\n version_info: _TYPE_VERSION_INFO,\n pypy_version_info: _TYPE_VERSION_INFO | None,\n) -> bool:\ndef _is_has_never_check_common_name_reliable(\n openssl_version: str,\n openssl_version_number: int,\n implementation_name: str,\n version_info: _TYPE_VERSION_INFO,\n pypy_version_info: _TYPE_VERSION_INFO | None,\n) -> bool:\ndef assert_fingerprint(cert: bytes | None, fingerprint: str) -> None:\ndef resolve_cert_reqs(candidate: None | int | str) -> VerifyMode:\ndef resolve_ssl_version(candidate: None | int | str) -> int:\ndef create_urllib3_context(\n ssl_version: int | None = None,\n cert_reqs: int | None = None,\n options: int | None = None,\n ciphers: str | None = None,\n ssl_minimum_version: int | None = None,\n ssl_maximum_version: int | None = None,\n) -> ssl.SSLContext:\ndef ssl_wrap_socket(\n sock: socket.socket,\n keyfile: str | None = ...,\n certfile: str | None = ...,\n cert_reqs: int | None = ...,\n ca_certs: str | None = ...,\n server_hostname: str | None = ...,\n ssl_version: int | None = ...,\n ciphers: str | None = ...,\n ssl_context: ssl.SSLContext | None = ...,\n ca_cert_dir: str | None = ...,\n key_password: str | None = ...,\n ca_cert_data: None | str | bytes = ...,\n tls_in_tls: Literal[False] = ...,\n) -> ssl.SSLSocket:\ndef ssl_wrap_socket(\n sock: socket.socket,\n keyfile: str | None = ...,\n certfile: str | None = ...,\n cert_reqs: int | None = ...,\n ca_certs: str | None = ...,\n server_hostname: str | None = ...,\n ssl_version: int | None = ...,\n ciphers: str | None = ...,\n ssl_context: ssl.SSLContext | None = ...,\n ca_cert_dir: str | None = ...,\n key_password: str | None = ...,\n ca_cert_data: None | str | bytes = ...,\n tls_in_tls: bool = ...,\n) -> ssl.SSLSocket | SSLTransportType:\ndef ssl_wrap_socket(\n sock: socket.socket,\n keyfile: str | None = None,\n certfile: str | None = None,\n cert_reqs: int | None = None,\n ca_certs: str | None = None,\n server_hostname: str | None = None,\n ssl_version: int | None = None,\n ciphers: str | None = None,\n ssl_context: ssl.SSLContext | None = None,\n ca_cert_dir: str | None = None,\n key_password: str | None = None,\n ca_cert_data: None | str | bytes = None,\n tls_in_tls: bool = False,\n) -> ssl.SSLSocket | SSLTransportType:\ndef is_ipaddress(hostname: str | bytes) -> bool:\ndef _is_key_file_encrypted(key_file: str) -> bool:\ndef _ssl_wrap_socket_impl(\n sock: socket.socket,\n ssl_context: ssl.SSLContext,\n tls_in_tls: bool,\n server_hostname: str | None = None,\n) -> ssl.SSLSocket | SSLTransportType:\n class _TYPE_PEER_CERT_RET_DICT(TypedDict, total=False):"},{"identifier":"SKIP_HEADER","path":".venv/Lib/site-packages/urllib3/util/request.py","snippet":"SKIP_HEADER = \"@@@SKIP_HEADER@@@\""},{"identifier":"SKIPPABLE_HEADERS","path":".venv/Lib/site-packages/urllib3/util/request.py","snippet":"SKIPPABLE_HEADERS = frozenset([\"accept-encoding\", \"host\", \"user-agent\"])"},{"identifier":"body_to_chunks","path":".venv/Lib/site-packages/urllib3/util/request.py","snippet":"def body_to_chunks(\n body: typing.Any | None, method: str, blocksize: int\n) -> ChunksAndContentLength:\n \"\"\"Takes the HTTP request method, body, and blocksize and\n transforms them into an iterable of chunks to pass to\n socket.sendall() and an optional 'Content-Length' header.\n\n A 'Content-Length' of 'None' indicates the length of the body\n can't be determined so should use 'Transfer-Encoding: chunked'\n for framing instead.\n \"\"\"\n\n chunks: typing.Iterable[bytes] | None\n content_length: int | None\n\n # No body, we need to make a recommendation on 'Content-Length'\n # based on whether that request method is expected to have\n # a body or not.\n if body is None:\n chunks = None\n if method.upper() not in _METHODS_NOT_EXPECTING_BODY:\n content_length = 0\n else:\n content_length = None\n\n # Bytes or strings become bytes\n elif isinstance(body, (str, bytes)):\n chunks = (to_bytes(body),)\n content_length = len(chunks[0])\n\n # File-like object, TODO: use seek() and tell() for length?\n elif hasattr(body, \"read\"):\n\n def chunk_readable() -> typing.Iterable[bytes]:\n nonlocal body, blocksize\n encode = isinstance(body, io.TextIOBase)\n while True:\n datablock = body.read(blocksize)\n if not datablock:\n break\n if encode:\n datablock = datablock.encode(\"iso-8859-1\")\n yield datablock\n\n chunks = chunk_readable()\n content_length = None\n\n # Otherwise we need to start checking via duck-typing.\n else:\n try:\n # Check if the body implements the buffer API.\n mv = memoryview(body)\n except TypeError:\n try:\n # Check if the body is an iterable\n chunks = iter(body)\n content_length = None\n except TypeError:\n raise TypeError(\n f\"'body' must be a bytes-like object, file-like \"\n f\"object, or iterable. Instead was {body!r}\"\n ) from None\n else:\n # Since it implements the buffer API can be passed directly to socket.sendall()\n chunks = (body,)\n content_length = mv.nbytes\n\n return ChunksAndContentLength(chunks=chunks, content_length=content_length)"},{"identifier":"assert_fingerprint","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"def assert_fingerprint(cert: bytes | None, fingerprint: str) -> None:\n \"\"\"\n Checks if given fingerprint matches the supplied certificate.\n\n :param cert:\n Certificate as bytes object.\n :param fingerprint:\n Fingerprint as string of hexdigits, can be interspersed by colons.\n \"\"\"\n\n if cert is None:\n raise SSLError(\"No certificate for the peer.\")\n\n fingerprint = fingerprint.replace(\":\", \"\").lower()\n digest_length = len(fingerprint)\n hashfunc = HASHFUNC_MAP.get(digest_length)\n if not hashfunc:\n raise SSLError(f\"Fingerprint of invalid length: {fingerprint}\")\n\n # We need encode() here for py32; works on py2 and p33.\n fingerprint_bytes = unhexlify(fingerprint.encode())\n\n cert_digest = hashfunc(cert).digest()\n\n if not hmac.compare_digest(cert_digest, fingerprint_bytes):\n raise SSLError(\n f'Fingerprints did not match. Expected \"{fingerprint}\", got \"{cert_digest.hex()}\"'\n )"},{"identifier":"create_urllib3_context","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"def create_urllib3_context(\n ssl_version: int | None = None,\n cert_reqs: int | None = None,\n options: int | None = None,\n ciphers: str | None = None,\n ssl_minimum_version: int | None = None,\n ssl_maximum_version: int | None = None,\n) -> ssl.SSLContext:\n \"\"\"Creates and configures an :class:`ssl.SSLContext` instance for use with urllib3.\n\n :param ssl_version:\n The desired protocol version to use. This will default to\n PROTOCOL_SSLv23 which will negotiate the highest protocol that both\n the server and your installation of OpenSSL support.\n\n This parameter is deprecated instead use 'ssl_minimum_version'.\n :param ssl_minimum_version:\n The minimum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value.\n :param ssl_maximum_version:\n The maximum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value.\n Not recommended to set to anything other than 'ssl.TLSVersion.MAXIMUM_SUPPORTED' which is the\n default value.\n :param cert_reqs:\n Whether to require the certificate verification. This defaults to\n ``ssl.CERT_REQUIRED``.\n :param options:\n Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,\n ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``.\n :param ciphers:\n Which cipher suites to allow the server to select. Defaults to either system configured\n ciphers if OpenSSL 1.1.1+, otherwise uses a secure default set of ciphers.\n :returns:\n Constructed SSLContext object with specified options\n :rtype: SSLContext\n \"\"\"\n if SSLContext is None:\n raise TypeError(\"Can't create an SSLContext object without an ssl module\")\n\n # This means 'ssl_version' was specified as an exact value.\n if ssl_version not in (None, PROTOCOL_TLS, PROTOCOL_TLS_CLIENT):\n # Disallow setting 'ssl_version' and 'ssl_minimum|maximum_version'\n # to avoid conflicts.\n if ssl_minimum_version is not None or ssl_maximum_version is not None:\n raise ValueError(\n \"Can't specify both 'ssl_version' and either \"\n \"'ssl_minimum_version' or 'ssl_maximum_version'\"\n )\n\n # 'ssl_version' is deprecated and will be removed in the future.\n else:\n # Use 'ssl_minimum_version' and 'ssl_maximum_version' instead.\n ssl_minimum_version = _SSL_VERSION_TO_TLS_VERSION.get(\n ssl_version, TLSVersion.MINIMUM_SUPPORTED\n )\n ssl_maximum_version = _SSL_VERSION_TO_TLS_VERSION.get(\n ssl_version, TLSVersion.MAXIMUM_SUPPORTED\n )\n\n # This warning message is pushing users to use 'ssl_minimum_version'\n # instead of both min/max. Best practice is to only set the minimum version and\n # keep the maximum version to be it's default value: 'TLSVersion.MAXIMUM_SUPPORTED'\n warnings.warn(\n \"'ssl_version' option is deprecated and will be \"\n \"removed in urllib3 v2.1.0. Instead use 'ssl_minimum_version'\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n\n # PROTOCOL_TLS is deprecated in Python 3.10 so we always use PROTOCOL_TLS_CLIENT\n context = SSLContext(PROTOCOL_TLS_CLIENT)\n\n if ssl_minimum_version is not None:\n context.minimum_version = ssl_minimum_version\n else: # Python <3.10 defaults to 'MINIMUM_SUPPORTED' so explicitly set TLSv1.2 here\n context.minimum_version = TLSVersion.TLSv1_2\n\n if ssl_maximum_version is not None:\n context.maximum_version = ssl_maximum_version\n\n # Unless we're given ciphers defer to either system ciphers in\n # the case of OpenSSL 1.1.1+ or use our own secure default ciphers.\n if ciphers:\n context.set_ciphers(ciphers)\n\n # Setting the default here, as we may have no ssl module on import\n cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs\n\n if options is None:\n options = 0\n # SSLv2 is easily broken and is considered harmful and dangerous\n options |= OP_NO_SSLv2\n # SSLv3 has several problems and is now dangerous\n options |= OP_NO_SSLv3\n # Disable compression to prevent CRIME attacks for OpenSSL 1.0+\n # (issue #309)\n options |= OP_NO_COMPRESSION\n # TLSv1.2 only. Unless set explicitly, do not request tickets.\n # This may save some bandwidth on wire, and although the ticket is encrypted,\n # there is a risk associated with it being on wire,\n # if the server is not rotating its ticketing keys properly.\n options |= OP_NO_TICKET\n\n context.options |= options\n\n # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is\n # necessary for conditional client cert authentication with TLS 1.3.\n # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older\n # versions of Python. We only enable if certificate verification is enabled to work\n # around Python issue #37428\n # See: https://bugs.python.org/issue37428\n if (\n cert_reqs == ssl.CERT_REQUIRED\n and getattr(context, \"post_handshake_auth\", None) is not None\n ):\n context.post_handshake_auth = True\n\n # The order of the below lines setting verify_mode and check_hostname\n # matter due to safe-guards SSLContext has to prevent an SSLContext with\n # check_hostname=True, verify_mode=NONE/OPTIONAL.\n # We always set 'check_hostname=False' for pyOpenSSL so we rely on our own\n # 'ssl.match_hostname()' implementation.\n if cert_reqs == ssl.CERT_REQUIRED and not IS_PYOPENSSL:\n context.verify_mode = cert_reqs\n context.check_hostname = True\n else:\n context.check_hostname = False\n context.verify_mode = cert_reqs\n\n try:\n context.hostname_checks_common_name = False\n except AttributeError: # Defensive: for CPython < 3.8.9 and 3.9.3; for PyPy < 7.3.8\n pass\n\n # Enable logging of TLS session keys via defacto standard environment variable\n # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values.\n if hasattr(context, \"keylog_filename\"):\n sslkeylogfile = os.environ.get(\"SSLKEYLOGFILE\")\n if sslkeylogfile:\n context.keylog_filename = sslkeylogfile\n\n return context"},{"identifier":"is_ipaddress","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"def is_ipaddress(hostname: str | bytes) -> bool:\n \"\"\"Detects whether the hostname given is an IPv4 or IPv6 address.\n Also detects IPv6 addresses with Zone IDs.\n\n :param str hostname: Hostname to examine.\n :return: True if the hostname is an IP address, False otherwise.\n \"\"\"\n if isinstance(hostname, bytes):\n # IDN A-label bytes are ASCII compatible.\n hostname = hostname.decode(\"ascii\")\n return bool(_IPV4_RE.match(hostname) or _BRACELESS_IPV6_ADDRZ_RE.match(hostname))"},{"identifier":"resolve_cert_reqs","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"def resolve_cert_reqs(candidate: None | int | str) -> VerifyMode:\n \"\"\"\n Resolves the argument to a numeric constant, which can be passed to\n the wrap_socket function/method from the ssl module.\n Defaults to :data:`ssl.CERT_REQUIRED`.\n If given a string it is assumed to be the name of the constant in the\n :mod:`ssl` module or its abbreviation.\n (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.\n If it's neither `None` nor a string we assume it is already the numeric\n constant which can directly be passed to wrap_socket.\n \"\"\"\n if candidate is None:\n return CERT_REQUIRED\n\n if isinstance(candidate, str):\n res = getattr(ssl, candidate, None)\n if res is None:\n res = getattr(ssl, \"CERT_\" + candidate)\n return res # type: ignore[no-any-return]\n\n return candidate # type: ignore[return-value]"},{"identifier":"resolve_ssl_version","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"def resolve_ssl_version(candidate: None | int | str) -> int:\n \"\"\"\n like resolve_cert_reqs\n \"\"\"\n if candidate is None:\n return PROTOCOL_TLS\n\n if isinstance(candidate, str):\n res = getattr(ssl, candidate, None)\n if res is None:\n res = getattr(ssl, \"PROTOCOL_\" + candidate)\n return typing.cast(int, res)\n\n return candidate"},{"identifier":"ssl_wrap_socket","path":".venv/Lib/site-packages/urllib3/util/ssl_.py","snippet":"@typing.overload\ndef ssl_wrap_socket(\n sock: socket.socket,\n keyfile: str | None = ...,\n certfile: str | None = ...,\n cert_reqs: int | None = ...,\n ca_certs: str | None = ...,\n server_hostname: str | None = ...,\n ssl_version: int | None = ...,\n ciphers: str | None = ...,\n ssl_context: ssl.SSLContext | None = ...,\n ca_cert_dir: str | None = ...,\n key_password: str | None = ...,\n ca_cert_data: None | str | bytes = ...,\n tls_in_tls: Literal[False] = ...,\n) -> ssl.SSLSocket:\n ..."},{"identifier":"CertificateError","path":".venv/Lib/site-packages/urllib3/util/ssl_match_hostname.py","snippet":"class CertificateError(ValueError):\n pass"},{"identifier":"match_hostname","path":".venv/Lib/site-packages/urllib3/util/ssl_match_hostname.py","snippet":"def match_hostname(\n cert: _TYPE_PEER_CERT_RET_DICT | None,\n hostname: str,\n hostname_checks_common_name: bool = False,\n) -> None:\n \"\"\"Verify that *cert* (in decoded format as returned by\n SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125\n rules are followed, but IP addresses are not accepted for *hostname*.\n\n CertificateError is raised on failure. On success, the function\n returns nothing.\n \"\"\"\n if not cert:\n raise ValueError(\n \"empty or no certificate, match_hostname needs a \"\n \"SSL socket or SSL context with either \"\n \"CERT_OPTIONAL or CERT_REQUIRED\"\n )\n try:\n # Divergence from upstream: ipaddress can't handle byte str\n #\n # The ipaddress module shipped with Python < 3.9 does not support\n # scoped IPv6 addresses so we unconditionally strip the Zone IDs for\n # now. Once we drop support for Python 3.9 we can remove this branch.\n if \"%\" in hostname:\n host_ip = ipaddress.ip_address(hostname[: hostname.rfind(\"%\")])\n else:\n host_ip = ipaddress.ip_address(hostname)\n\n except ValueError:\n # Not an IP address (common case)\n host_ip = None\n dnsnames = []\n san: tuple[tuple[str, str], ...] = cert.get(\"subjectAltName\", ())\n key: str\n value: str\n for key, value in san:\n if key == \"DNS\":\n if host_ip is None and _dnsname_match(value, hostname):\n return\n dnsnames.append(value)\n elif key == \"IP Address\":\n if host_ip is not None and _ipaddress_match(value, host_ip):\n return\n dnsnames.append(value)\n\n # We only check 'commonName' if it's enabled and we're not verifying\n # an IP address. IP addresses aren't valid within 'commonName'.\n if hostname_checks_common_name and host_ip is None and not dnsnames:\n for sub in cert.get(\"subject\", ()):\n for key, value in sub:\n if key == \"commonName\":\n if _dnsname_match(value, hostname):\n return\n dnsnames.append(value)\n\n if len(dnsnames) > 1:\n raise CertificateError(\n \"hostname %r \"\n \"doesn't match either of %s\" % (hostname, \", \".join(map(repr, dnsnames)))\n )\n elif len(dnsnames) == 1:\n raise CertificateError(f\"hostname {hostname!r} doesn't match {dnsnames[0]!r}\")\n else:\n raise CertificateError(\"no appropriate subjectAltName fields were found\")"},{"identifier":"Url","path":".venv/Lib/site-packages/urllib3/util/url.py","snippet":"class Url(\n typing.NamedTuple(\n \"Url\",\n [\n (\"scheme\", typing.Optional[str]),\n (\"auth\", typing.Optional[str]),\n (\"host\", typing.Optional[str]),\n (\"port\", typing.Optional[int]),\n (\"path\", typing.Optional[str]),\n (\"query\", typing.Optional[str]),\n (\"fragment\", typing.Optional[str]),\n ],\n )\n):\n \"\"\"\n Data structure for representing an HTTP URL. Used as a return value for\n :func:`parse_url`. Both the scheme and host are normalized as they are\n both case-insensitive according to RFC 3986.\n \"\"\"\n\n def __new__( # type: ignore[no-untyped-def]\n cls,\n scheme: str | None = None,\n auth: str | None = None,\n host: str | None = None,\n port: int | None = None,\n path: str | None = None,\n query: str | None = None,\n fragment: str | None = None,\n ):\n if path and not path.startswith(\"/\"):\n path = \"/\" + path\n if scheme is not None:\n scheme = scheme.lower()\n return super().__new__(cls, scheme, auth, host, port, path, query, fragment)\n\n @property\n def hostname(self) -> str | None:\n \"\"\"For backwards-compatibility with urlparse. We're nice like that.\"\"\"\n return self.host\n\n @property\n def request_uri(self) -> str:\n \"\"\"Absolute path including the query string.\"\"\"\n uri = self.path or \"/\"\n\n if self.query is not None:\n uri += \"?\" + self.query\n\n return uri\n\n @property\n def authority(self) -> str | None:\n \"\"\"\n Authority component as defined in RFC 3986 3.2.\n This includes userinfo (auth), host and port.\n\n i.e.\n userinfo@host:port\n \"\"\"\n userinfo = self.auth\n netloc = self.netloc\n if netloc is None or userinfo is None:\n return netloc\n else:\n return f\"{userinfo}@{netloc}\"\n\n @property\n def netloc(self) -> str | None:\n \"\"\"\n Network location including host and port.\n\n If you need the equivalent of urllib.parse's ``netloc``,\n use the ``authority`` property instead.\n \"\"\"\n if self.host is None:\n return None\n if self.port:\n return f\"{self.host}:{self.port}\"\n return self.host\n\n @property\n def url(self) -> str:\n \"\"\"\n Convert self into a url\n\n This function should more or less round-trip with :func:`.parse_url`. The\n returned url may not be exactly the same as the url inputted to\n :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls\n with a blank port will have : removed).\n\n Example:\n\n .. code-block:: python\n\n import urllib3\n\n U = urllib3.util.parse_url(\"https://google.com/mail/\")\n\n print(U.url)\n # \"https://google.com/mail/\"\n\n print( urllib3.util.Url(\"https\", \"username:password\",\n \"host.com\", 80, \"/path\", \"query\", \"fragment\"\n ).url\n )\n # \"https://username:password@host.com:80/path?query#fragment\"\n \"\"\"\n scheme, auth, host, port, path, query, fragment = self\n url = \"\"\n\n # We use \"is not None\" we want things to happen with empty strings (or 0 port)\n if scheme is not None:\n url += scheme + \"://\"\n if auth is not None:\n url += auth + \"@\"\n if host is not None:\n url += host\n if port is not None:\n url += \":\" + str(port)\n if path is not None:\n url += path\n if query is not None:\n url += \"?\" + query\n if fragment is not None:\n url += \"#\" + fragment\n\n return url\n\n def __str__(self) -> str:\n return self.url"}],"string":"[\n {\n \"identifier\": \"HTTPHeaderDict\",\n \"path\": \".venv/Lib/site-packages/urllib3/_collections.py\",\n \"snippet\": \"class HTTPHeaderDict(typing.MutableMapping[str, str]):\\n \\\"\\\"\\\"\\n :param headers:\\n An iterable of field-value pairs. Must not contain multiple field names\\n when compared case-insensitively.\\n\\n :param kwargs:\\n Additional field-value pairs to pass in to ``dict.update``.\\n\\n A ``dict`` like container for storing HTTP Headers.\\n\\n Field names are stored and compared case-insensitively in compliance with\\n RFC 7230. Iteration provides the first case-sensitive key seen for each\\n case-insensitive pair.\\n\\n Using ``__setitem__`` syntax overwrites fields that compare equal\\n case-insensitively in order to maintain ``dict``'s api. For fields that\\n compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add``\\n in a loop.\\n\\n If multiple fields that are equal case-insensitively are passed to the\\n constructor or ``.update``, the behavior is undefined and some will be\\n lost.\\n\\n >>> headers = HTTPHeaderDict()\\n >>> headers.add('Set-Cookie', 'foo=bar')\\n >>> headers.add('set-cookie', 'baz=quxx')\\n >>> headers['content-length'] = '7'\\n >>> headers['SET-cookie']\\n 'foo=bar, baz=quxx'\\n >>> headers['Content-Length']\\n '7'\\n \\\"\\\"\\\"\\n\\n _container: typing.MutableMapping[str, list[str]]\\n\\n def __init__(self, headers: ValidHTTPHeaderSource | None = None, **kwargs: str):\\n super().__init__()\\n self._container = {} # 'dict' is insert-ordered\\n if headers is not None:\\n if isinstance(headers, HTTPHeaderDict):\\n self._copy_from(headers)\\n else:\\n self.extend(headers)\\n if kwargs:\\n self.extend(kwargs)\\n\\n def __setitem__(self, key: str, val: str) -> None:\\n # avoid a bytes/str comparison by decoding before httplib\\n if isinstance(key, bytes):\\n key = key.decode(\\\"latin-1\\\")\\n self._container[key.lower()] = [key, val]\\n\\n def __getitem__(self, key: str) -> str:\\n val = self._container[key.lower()]\\n return \\\", \\\".join(val[1:])\\n\\n def __delitem__(self, key: str) -> None:\\n del self._container[key.lower()]\\n\\n def __contains__(self, key: object) -> bool:\\n if isinstance(key, str):\\n return key.lower() in self._container\\n return False\\n\\n def setdefault(self, key: str, default: str = \\\"\\\") -> str:\\n return super().setdefault(key, default)\\n\\n def __eq__(self, other: object) -> bool:\\n maybe_constructable = ensure_can_construct_http_header_dict(other)\\n if maybe_constructable is None:\\n return False\\n else:\\n other_as_http_header_dict = type(self)(maybe_constructable)\\n\\n return {k.lower(): v for k, v in self.itermerged()} == {\\n k.lower(): v for k, v in other_as_http_header_dict.itermerged()\\n }\\n\\n def __ne__(self, other: object) -> bool:\\n return not self.__eq__(other)\\n\\n def __len__(self) -> int:\\n return len(self._container)\\n\\n def __iter__(self) -> typing.Iterator[str]:\\n # Only provide the originally cased names\\n for vals in self._container.values():\\n yield vals[0]\\n\\n def discard(self, key: str) -> None:\\n try:\\n del self[key]\\n except KeyError:\\n pass\\n\\n def add(self, key: str, val: str, *, combine: bool = False) -> None:\\n \\\"\\\"\\\"Adds a (name, value) pair, doesn't overwrite the value if it already\\n exists.\\n\\n If this is called with combine=True, instead of adding a new header value\\n as a distinct item during iteration, this will instead append the value to\\n any existing header value with a comma. If no existing header value exists\\n for the key, then the value will simply be added, ignoring the combine parameter.\\n\\n >>> headers = HTTPHeaderDict(foo='bar')\\n >>> headers.add('Foo', 'baz')\\n >>> headers['foo']\\n 'bar, baz'\\n >>> list(headers.items())\\n [('foo', 'bar'), ('foo', 'baz')]\\n >>> headers.add('foo', 'quz', combine=True)\\n >>> list(headers.items())\\n [('foo', 'bar, baz, quz')]\\n \\\"\\\"\\\"\\n # avoid a bytes/str comparison by decoding before httplib\\n if isinstance(key, bytes):\\n key = key.decode(\\\"latin-1\\\")\\n key_lower = key.lower()\\n new_vals = [key, val]\\n # Keep the common case aka no item present as fast as possible\\n vals = self._container.setdefault(key_lower, new_vals)\\n if new_vals is not vals:\\n # if there are values here, then there is at least the initial\\n # key/value pair\\n assert len(vals) >= 2\\n if combine:\\n vals[-1] = vals[-1] + \\\", \\\" + val\\n else:\\n vals.append(val)\\n\\n def extend(self, *args: ValidHTTPHeaderSource, **kwargs: str) -> None:\\n \\\"\\\"\\\"Generic import function for any type of header-like object.\\n Adapted version of MutableMapping.update in order to insert items\\n with self.add instead of self.__setitem__\\n \\\"\\\"\\\"\\n if len(args) > 1:\\n raise TypeError(\\n f\\\"extend() takes at most 1 positional arguments ({len(args)} given)\\\"\\n )\\n other = args[0] if len(args) >= 1 else ()\\n\\n if isinstance(other, HTTPHeaderDict):\\n for key, val in other.iteritems():\\n self.add(key, val)\\n elif isinstance(other, typing.Mapping):\\n for key, val in other.items():\\n self.add(key, val)\\n elif isinstance(other, typing.Iterable):\\n other = typing.cast(typing.Iterable[typing.Tuple[str, str]], other)\\n for key, value in other:\\n self.add(key, value)\\n elif hasattr(other, \\\"keys\\\") and hasattr(other, \\\"__getitem__\\\"):\\n # THIS IS NOT A TYPESAFE BRANCH\\n # In this branch, the object has a `keys` attr but is not a Mapping or any of\\n # the other types indicated in the method signature. We do some stuff with\\n # it as though it partially implements the Mapping interface, but we're not\\n # doing that stuff safely AT ALL.\\n for key in other.keys():\\n self.add(key, other[key])\\n\\n for key, value in kwargs.items():\\n self.add(key, value)\\n\\n @typing.overload\\n def getlist(self, key: str) -> list[str]:\\n ...\\n\\n @typing.overload\\n def getlist(self, key: str, default: _DT) -> list[str] | _DT:\\n ...\\n\\n def getlist(\\n self, key: str, default: _Sentinel | _DT = _Sentinel.not_passed\\n ) -> list[str] | _DT:\\n \\\"\\\"\\\"Returns a list of all the values for the named field. Returns an\\n empty list if the key doesn't exist.\\\"\\\"\\\"\\n try:\\n vals = self._container[key.lower()]\\n except KeyError:\\n if default is _Sentinel.not_passed:\\n # _DT is unbound; empty list is instance of List[str]\\n return []\\n # _DT is bound; default is instance of _DT\\n return default\\n else:\\n # _DT may or may not be bound; vals[1:] is instance of List[str], which\\n # meets our external interface requirement of `Union[List[str], _DT]`.\\n return vals[1:]\\n\\n def _prepare_for_method_change(self) -> Self:\\n \\\"\\\"\\\"\\n Remove content-specific header fields before changing the request\\n method to GET or HEAD according to RFC 9110, Section 15.4.\\n \\\"\\\"\\\"\\n content_specific_headers = [\\n \\\"Content-Encoding\\\",\\n \\\"Content-Language\\\",\\n \\\"Content-Location\\\",\\n \\\"Content-Type\\\",\\n \\\"Content-Length\\\",\\n \\\"Digest\\\",\\n \\\"Last-Modified\\\",\\n ]\\n for header in content_specific_headers:\\n self.discard(header)\\n return self\\n\\n # Backwards compatibility for httplib\\n getheaders = getlist\\n getallmatchingheaders = getlist\\n iget = getlist\\n\\n # Backwards compatibility for http.cookiejar\\n get_all = getlist\\n\\n def __repr__(self) -> str:\\n return f\\\"{type(self).__name__}({dict(self.itermerged())})\\\"\\n\\n def _copy_from(self, other: HTTPHeaderDict) -> None:\\n for key in other:\\n val = other.getlist(key)\\n self._container[key.lower()] = [key, *val]\\n\\n def copy(self) -> HTTPHeaderDict:\\n clone = type(self)()\\n clone._copy_from(self)\\n return clone\\n\\n def iteritems(self) -> typing.Iterator[tuple[str, str]]:\\n \\\"\\\"\\\"Iterate over all header lines, including duplicate ones.\\\"\\\"\\\"\\n for key in self:\\n vals = self._container[key.lower()]\\n for val in vals[1:]:\\n yield vals[0], val\\n\\n def itermerged(self) -> typing.Iterator[tuple[str, str]]:\\n \\\"\\\"\\\"Iterate over all headers, merging duplicate ones together.\\\"\\\"\\\"\\n for key in self:\\n val = self._container[key.lower()]\\n yield val[0], \\\", \\\".join(val[1:])\\n\\n def items(self) -> HTTPHeaderDictItemView: # type: ignore[override]\\n return HTTPHeaderDictItemView(self)\\n\\n def _has_value_for_header(self, header_name: str, potential_value: str) -> bool:\\n if header_name in self:\\n return potential_value in self._container[header_name.lower()][1:]\\n return False\\n\\n def __ior__(self, other: object) -> HTTPHeaderDict:\\n # Supports extending a header dict in-place using operator |=\\n # combining items with add instead of __setitem__\\n maybe_constructable = ensure_can_construct_http_header_dict(other)\\n if maybe_constructable is None:\\n return NotImplemented\\n self.extend(maybe_constructable)\\n return self\\n\\n def __or__(self, other: object) -> HTTPHeaderDict:\\n # Supports merging header dicts using operator |\\n # combining items with add instead of __setitem__\\n maybe_constructable = ensure_can_construct_http_header_dict(other)\\n if maybe_constructable is None:\\n return NotImplemented\\n result = self.copy()\\n result.extend(maybe_constructable)\\n return result\\n\\n def __ror__(self, other: object) -> HTTPHeaderDict:\\n # Supports merging header dicts using operator | when other is on left side\\n # combining items with add instead of __setitem__\\n maybe_constructable = ensure_can_construct_http_header_dict(other)\\n if maybe_constructable is None:\\n return NotImplemented\\n result = type(self)(maybe_constructable)\\n result.extend(self)\\n return result\"\n },\n {\n \"identifier\": \"assert_header_parsing\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/response.py\",\n \"snippet\": \"def assert_header_parsing(headers: httplib.HTTPMessage) -> None:\\n \\\"\\\"\\\"\\n Asserts whether all headers have been successfully parsed.\\n Extracts encountered errors from the result of parsing headers.\\n\\n Only works on Python 3.\\n\\n :param http.client.HTTPMessage headers: Headers to verify.\\n\\n :raises urllib3.exceptions.HeaderParsingError:\\n If parsing errors are found.\\n \\\"\\\"\\\"\\n\\n # This will fail silently if we pass in the wrong kind of parameter.\\n # To make debugging easier add an explicit check.\\n if not isinstance(headers, httplib.HTTPMessage):\\n raise TypeError(f\\\"expected httplib.Message, got {type(headers)}.\\\")\\n\\n unparsed_data = None\\n\\n # get_payload is actually email.message.Message.get_payload;\\n # we're only interested in the result if it's not a multipart message\\n if not headers.is_multipart():\\n payload = headers.get_payload()\\n\\n if isinstance(payload, (bytes, str)):\\n unparsed_data = payload\\n\\n # httplib is assuming a response body is available\\n # when parsing headers even when httplib only sends\\n # header data to parse_headers() This results in\\n # defects on multipart responses in particular.\\n # See: https://github.com/urllib3/urllib3/issues/800\\n\\n # So we ignore the following defects:\\n # - StartBoundaryNotFoundDefect:\\n # The claimed start boundary was never found.\\n # - MultipartInvariantViolationDefect:\\n # A message claimed to be a multipart but no subparts were found.\\n defects = [\\n defect\\n for defect in headers.defects\\n if not isinstance(\\n defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect)\\n )\\n ]\\n\\n if defects or unparsed_data:\\n raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data)\"\n },\n {\n \"identifier\": \"_DEFAULT_TIMEOUT\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/timeout.py\",\n \"snippet\": \"_DEFAULT_TIMEOUT: Final[_TYPE_DEFAULT] = _TYPE_DEFAULT.token\"\n },\n {\n \"identifier\": \"_TYPE_TIMEOUT\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/timeout.py\",\n \"snippet\": \"_TYPE_TIMEOUT = typing.Optional[typing.Union[float, _TYPE_DEFAULT]]\"\n },\n {\n \"identifier\": \"Timeout\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/timeout.py\",\n \"snippet\": \"class Timeout:\\n \\\"\\\"\\\"Timeout configuration.\\n\\n Timeouts can be defined as a default for a pool:\\n\\n .. code-block:: python\\n\\n import urllib3\\n\\n timeout = urllib3.util.Timeout(connect=2.0, read=7.0)\\n\\n http = urllib3.PoolManager(timeout=timeout)\\n\\n resp = http.request(\\\"GET\\\", \\\"https://example.com/\\\")\\n\\n print(resp.status)\\n\\n Or per-request (which overrides the default for the pool):\\n\\n .. code-block:: python\\n\\n response = http.request(\\\"GET\\\", \\\"https://example.com/\\\", timeout=Timeout(10))\\n\\n Timeouts can be disabled by setting all the parameters to ``None``:\\n\\n .. code-block:: python\\n\\n no_timeout = Timeout(connect=None, read=None)\\n response = http.request(\\\"GET\\\", \\\"https://example.com/\\\", timeout=no_timeout)\\n\\n\\n :param total:\\n This combines the connect and read timeouts into one; the read timeout\\n will be set to the time leftover from the connect attempt. In the\\n event that both a connect timeout and a total are specified, or a read\\n timeout and a total are specified, the shorter timeout will be applied.\\n\\n Defaults to None.\\n\\n :type total: int, float, or None\\n\\n :param connect:\\n The maximum amount of time (in seconds) to wait for a connection\\n attempt to a server to succeed. Omitting the parameter will default the\\n connect timeout to the system default, probably `the global default\\n timeout in socket.py\\n <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.\\n None will set an infinite timeout for connection attempts.\\n\\n :type connect: int, float, or None\\n\\n :param read:\\n The maximum amount of time (in seconds) to wait between consecutive\\n read operations for a response from the server. Omitting the parameter\\n will default the read timeout to the system default, probably `the\\n global default timeout in socket.py\\n <http://hg.python.org/cpython/file/603b4d593758/Lib/socket.py#l535>`_.\\n None will set an infinite timeout.\\n\\n :type read: int, float, or None\\n\\n .. note::\\n\\n Many factors can affect the total amount of time for urllib3 to return\\n an HTTP response.\\n\\n For example, Python's DNS resolver does not obey the timeout specified\\n on the socket. Other factors that can affect total request time include\\n high CPU load, high swap, the program running at a low priority level,\\n or other behaviors.\\n\\n In addition, the read and total timeouts only measure the time between\\n read operations on the socket connecting the client and the server,\\n not the total amount of time for the request to return a complete\\n response. For most requests, the timeout is raised because the server\\n has not sent the first byte in the specified time. This is not always\\n the case; if a server streams one byte every fifteen seconds, a timeout\\n of 20 seconds will not trigger, even though the request will take\\n several minutes to complete.\\n\\n If your goal is to cut off any request after a set amount of wall clock\\n time, consider having a second \\\"watcher\\\" thread to cut off a slow\\n request.\\n \\\"\\\"\\\"\\n\\n #: A sentinel object representing the default timeout value\\n DEFAULT_TIMEOUT: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT\\n\\n def __init__(\\n self,\\n total: _TYPE_TIMEOUT = None,\\n connect: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\\n read: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\\n ) -> None:\\n self._connect = self._validate_timeout(connect, \\\"connect\\\")\\n self._read = self._validate_timeout(read, \\\"read\\\")\\n self.total = self._validate_timeout(total, \\\"total\\\")\\n self._start_connect: float | None = None\\n\\n def __repr__(self) -> str:\\n return f\\\"{type(self).__name__}(connect={self._connect!r}, read={self._read!r}, total={self.total!r})\\\"\\n\\n # __str__ provided for backwards compatibility\\n __str__ = __repr__\\n\\n @staticmethod\\n def resolve_default_timeout(timeout: _TYPE_TIMEOUT) -> float | None:\\n return getdefaulttimeout() if timeout is _DEFAULT_TIMEOUT else timeout\\n\\n @classmethod\\n def _validate_timeout(cls, value: _TYPE_TIMEOUT, name: str) -> _TYPE_TIMEOUT:\\n \\\"\\\"\\\"Check that a timeout attribute is valid.\\n\\n :param value: The timeout value to validate\\n :param name: The name of the timeout attribute to validate. This is\\n used to specify in error messages.\\n :return: The validated and casted version of the given value.\\n :raises ValueError: If it is a numeric value less than or equal to\\n zero, or the type is not an integer, float, or None.\\n \\\"\\\"\\\"\\n if value is None or value is _DEFAULT_TIMEOUT:\\n return value\\n\\n if isinstance(value, bool):\\n raise ValueError(\\n \\\"Timeout cannot be a boolean value. It must \\\"\\n \\\"be an int, float or None.\\\"\\n )\\n try:\\n float(value)\\n except (TypeError, ValueError):\\n raise ValueError(\\n \\\"Timeout value %s was %s, but it must be an \\\"\\n \\\"int, float or None.\\\" % (name, value)\\n ) from None\\n\\n try:\\n if value <= 0:\\n raise ValueError(\\n \\\"Attempted to set %s timeout to %s, but the \\\"\\n \\\"timeout cannot be set to a value less \\\"\\n \\\"than or equal to 0.\\\" % (name, value)\\n )\\n except TypeError:\\n raise ValueError(\\n \\\"Timeout value %s was %s, but it must be an \\\"\\n \\\"int, float or None.\\\" % (name, value)\\n ) from None\\n\\n return value\\n\\n @classmethod\\n def from_float(cls, timeout: _TYPE_TIMEOUT) -> Timeout:\\n \\\"\\\"\\\"Create a new Timeout from a legacy timeout value.\\n\\n The timeout value used by httplib.py sets the same timeout on the\\n connect(), and recv() socket requests. This creates a :class:`Timeout`\\n object that sets the individual timeouts to the ``timeout`` value\\n passed to this function.\\n\\n :param timeout: The legacy timeout value.\\n :type timeout: integer, float, :attr:`urllib3.util.Timeout.DEFAULT_TIMEOUT`, or None\\n :return: Timeout object\\n :rtype: :class:`Timeout`\\n \\\"\\\"\\\"\\n return Timeout(read=timeout, connect=timeout)\\n\\n def clone(self) -> Timeout:\\n \\\"\\\"\\\"Create a copy of the timeout object\\n\\n Timeout properties are stored per-pool but each request needs a fresh\\n Timeout object to ensure each one has its own start/stop configured.\\n\\n :return: a copy of the timeout object\\n :rtype: :class:`Timeout`\\n \\\"\\\"\\\"\\n # We can't use copy.deepcopy because that will also create a new object\\n # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to\\n # detect the user default.\\n return Timeout(connect=self._connect, read=self._read, total=self.total)\\n\\n def start_connect(self) -> float:\\n \\\"\\\"\\\"Start the timeout clock, used during a connect() attempt\\n\\n :raises urllib3.exceptions.TimeoutStateError: if you attempt\\n to start a timer that has been started already.\\n \\\"\\\"\\\"\\n if self._start_connect is not None:\\n raise TimeoutStateError(\\\"Timeout timer has already been started.\\\")\\n self._start_connect = time.monotonic()\\n return self._start_connect\\n\\n def get_connect_duration(self) -> float:\\n \\\"\\\"\\\"Gets the time elapsed since the call to :meth:`start_connect`.\\n\\n :return: Elapsed time in seconds.\\n :rtype: float\\n :raises urllib3.exceptions.TimeoutStateError: if you attempt\\n to get duration for a timer that hasn't been started.\\n \\\"\\\"\\\"\\n if self._start_connect is None:\\n raise TimeoutStateError(\\n \\\"Can't get connect duration for timer that has not started.\\\"\\n )\\n return time.monotonic() - self._start_connect\\n\\n @property\\n def connect_timeout(self) -> _TYPE_TIMEOUT:\\n \\\"\\\"\\\"Get the value to use when setting a connection timeout.\\n\\n This will be a positive float or integer, the value None\\n (never timeout), or the default system timeout.\\n\\n :return: Connect timeout.\\n :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None\\n \\\"\\\"\\\"\\n if self.total is None:\\n return self._connect\\n\\n if self._connect is None or self._connect is _DEFAULT_TIMEOUT:\\n return self.total\\n\\n return min(self._connect, self.total) # type: ignore[type-var]\\n\\n @property\\n def read_timeout(self) -> float | None:\\n \\\"\\\"\\\"Get the value for the read timeout.\\n\\n This assumes some time has elapsed in the connection timeout and\\n computes the read timeout appropriately.\\n\\n If self.total is set, the read timeout is dependent on the amount of\\n time taken by the connect timeout. If the connection time has not been\\n established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be\\n raised.\\n\\n :return: Value to use for the read timeout.\\n :rtype: int, float or None\\n :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`\\n has not yet been called on this object.\\n \\\"\\\"\\\"\\n if (\\n self.total is not None\\n and self.total is not _DEFAULT_TIMEOUT\\n and self._read is not None\\n and self._read is not _DEFAULT_TIMEOUT\\n ):\\n # In case the connect timeout has not yet been established.\\n if self._start_connect is None:\\n return self._read\\n return max(0, min(self.total - self.get_connect_duration(), self._read))\\n elif self.total is not None and self.total is not _DEFAULT_TIMEOUT:\\n return max(0, self.total - self.get_connect_duration())\\n else:\\n return self.resolve_default_timeout(self._read)\"\n },\n {\n \"identifier\": \"to_str\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/util.py\",\n \"snippet\": \"def to_str(\\n x: str | bytes, encoding: str | None = None, errors: str | None = None\\n) -> str:\\n if isinstance(x, str):\\n return x\\n elif not isinstance(x, bytes):\\n raise TypeError(f\\\"not expecting type {type(x).__name__}\\\")\\n if encoding or errors:\\n return x.decode(encoding or \\\"utf-8\\\", errors=errors or \\\"strict\\\")\\n return x.decode()\"\n },\n {\n \"identifier\": \"wait_for_read\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/wait.py\",\n \"snippet\": \"def wait_for_read(sock: socket.socket, timeout: float | None = None) -> bool:\\n \\\"\\\"\\\"Waits for reading to be available on a given socket.\\n Returns True if the socket is readable, or False if the timeout expired.\\n \\\"\\\"\\\"\\n return wait_for_socket(sock, read=True, timeout=timeout)\"\n },\n {\n \"identifier\": \"_TYPE_BODY\",\n \"path\": \".venv/Lib/site-packages/urllib3/_base_connection.py\",\n \"snippet\": \"_TYPE_BODY = typing.Union[bytes, typing.IO[typing.Any], typing.Iterable[bytes], str]\"\n },\n {\n \"identifier\": \"ProxyConfig\",\n \"path\": \".venv/Lib/site-packages/urllib3/_base_connection.py\",\n \"snippet\": \"class ProxyConfig(typing.NamedTuple):\\n ssl_context: ssl.SSLContext | None\\n use_forwarding_for_https: bool\\n assert_hostname: None | str | Literal[False]\\n assert_fingerprint: str | None\"\n },\n {\n \"identifier\": \"_ResponseOptions\",\n \"path\": \".venv/Lib/site-packages/urllib3/_base_connection.py\",\n \"snippet\": \"class _ResponseOptions(typing.NamedTuple):\\n # TODO: Remove this in favor of a better\\n # HTTP request/response lifecycle tracking.\\n request_method: str\\n request_url: str\\n preload_content: bool\\n decode_content: bool\\n enforce_content_length: bool\"\n },\n {\n \"identifier\": \"__version__\",\n \"path\": \".venv/Lib/site-packages/urllib3/_version.py\",\n \"snippet\": \"\"\n },\n {\n \"identifier\": \"ConnectTimeoutError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class ConnectTimeoutError(TimeoutError):\\n \\\"\\\"\\\"Raised when a socket timeout occurs while connecting to a server\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"HeaderParsingError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class HeaderParsingError(HTTPError):\\n \\\"\\\"\\\"Raised by assert_header_parsing, but we convert it to a log.warning statement.\\\"\\\"\\\"\\n\\n def __init__(\\n self, defects: list[MessageDefect], unparsed_data: bytes | str | None\\n ) -> None:\\n message = f\\\"{defects or 'Unknown'}, unparsed data: {unparsed_data!r}\\\"\\n super().__init__(message)\"\n },\n {\n \"identifier\": \"NameResolutionError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class NameResolutionError(NewConnectionError):\\n \\\"\\\"\\\"Raised when host name resolution fails.\\\"\\\"\\\"\\n\\n def __init__(self, host: str, conn: HTTPConnection, reason: socket.gaierror):\\n message = f\\\"Failed to resolve '{host}' ({reason})\\\"\\n super().__init__(conn, message)\"\n },\n {\n \"identifier\": \"NewConnectionError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class NewConnectionError(ConnectTimeoutError, HTTPError):\\n \\\"\\\"\\\"Raised when we fail to establish a new connection. Usually ECONNREFUSED.\\\"\\\"\\\"\\n\\n def __init__(self, conn: HTTPConnection, message: str) -> None:\\n self.conn = conn\\n super().__init__(f\\\"{conn}: {message}\\\")\\n\\n @property\\n def pool(self) -> HTTPConnection:\\n warnings.warn(\\n \\\"The 'pool' property is deprecated and will be removed \\\"\\n \\\"in urllib3 v2.1.0. Use 'conn' instead.\\\",\\n DeprecationWarning,\\n stacklevel=2,\\n )\\n\\n return self.conn\"\n },\n {\n \"identifier\": \"ProxyError\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class ProxyError(HTTPError):\\n \\\"\\\"\\\"Raised when the connection to a proxy fails.\\\"\\\"\\\"\\n\\n # The original error is also available as __cause__.\\n original_error: Exception\\n\\n def __init__(self, message: str, error: Exception) -> None:\\n super().__init__(message, error)\\n self.original_error = error\"\n },\n {\n \"identifier\": \"SystemTimeWarning\",\n \"path\": \".venv/Lib/site-packages/urllib3/exceptions.py\",\n \"snippet\": \"class SystemTimeWarning(SecurityWarning):\\n \\\"\\\"\\\"Warned when system time is suspected to be wrong\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"connection\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/connection.py\",\n \"snippet\": \"_TYPE_SOCKET_OPTIONS = typing.Sequence[typing.Tuple[int, int, typing.Union[int, bytes]]]\\nHAS_IPV6 = _has_ipv6(\\\"::1\\\")\\ndef is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific\\ndef create_connection(\\n address: tuple[str, int],\\n timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\\n source_address: tuple[str, int] | None = None,\\n socket_options: _TYPE_SOCKET_OPTIONS | None = None,\\n) -> socket.socket:\\ndef _set_socket_options(\\n sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None\\n) -> None:\\ndef allowed_gai_family() -> socket.AddressFamily:\\ndef _has_ipv6(host: str) -> bool:\"\n },\n {\n \"identifier\": \"ssl_\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"HAS_NEVER_CHECK_COMMON_NAME = False\\nIS_PYOPENSSL = False\\nALPN_PROTOCOLS = [\\\"http/1.1\\\"]\\n_TYPE_VERSION_INFO = typing.Tuple[int, int, int, str, int]\\nHASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256}\\n_SSL_VERSION_TO_TLS_VERSION: dict[int, int] = {}\\n HAS_NEVER_CHECK_COMMON_NAME = False\\n OP_NO_COMPRESSION = 0x20000 # type: ignore[assignment]\\n OP_NO_TICKET = 0x4000 # type: ignore[assignment]\\n PROTOCOL_TLS_CLIENT = 16 # type: ignore[assignment]\\n_TYPE_PEER_CERT_RET = typing.Union[\\\"_TYPE_PEER_CERT_RET_DICT\\\", bytes, None]\\ndef _is_bpo_43522_fixed(\\n implementation_name: str,\\n version_info: _TYPE_VERSION_INFO,\\n pypy_version_info: _TYPE_VERSION_INFO | None,\\n) -> bool:\\ndef _is_has_never_check_common_name_reliable(\\n openssl_version: str,\\n openssl_version_number: int,\\n implementation_name: str,\\n version_info: _TYPE_VERSION_INFO,\\n pypy_version_info: _TYPE_VERSION_INFO | None,\\n) -> bool:\\ndef assert_fingerprint(cert: bytes | None, fingerprint: str) -> None:\\ndef resolve_cert_reqs(candidate: None | int | str) -> VerifyMode:\\ndef resolve_ssl_version(candidate: None | int | str) -> int:\\ndef create_urllib3_context(\\n ssl_version: int | None = None,\\n cert_reqs: int | None = None,\\n options: int | None = None,\\n ciphers: str | None = None,\\n ssl_minimum_version: int | None = None,\\n ssl_maximum_version: int | None = None,\\n) -> ssl.SSLContext:\\ndef ssl_wrap_socket(\\n sock: socket.socket,\\n keyfile: str | None = ...,\\n certfile: str | None = ...,\\n cert_reqs: int | None = ...,\\n ca_certs: str | None = ...,\\n server_hostname: str | None = ...,\\n ssl_version: int | None = ...,\\n ciphers: str | None = ...,\\n ssl_context: ssl.SSLContext | None = ...,\\n ca_cert_dir: str | None = ...,\\n key_password: str | None = ...,\\n ca_cert_data: None | str | bytes = ...,\\n tls_in_tls: Literal[False] = ...,\\n) -> ssl.SSLSocket:\\ndef ssl_wrap_socket(\\n sock: socket.socket,\\n keyfile: str | None = ...,\\n certfile: str | None = ...,\\n cert_reqs: int | None = ...,\\n ca_certs: str | None = ...,\\n server_hostname: str | None = ...,\\n ssl_version: int | None = ...,\\n ciphers: str | None = ...,\\n ssl_context: ssl.SSLContext | None = ...,\\n ca_cert_dir: str | None = ...,\\n key_password: str | None = ...,\\n ca_cert_data: None | str | bytes = ...,\\n tls_in_tls: bool = ...,\\n) -> ssl.SSLSocket | SSLTransportType:\\ndef ssl_wrap_socket(\\n sock: socket.socket,\\n keyfile: str | None = None,\\n certfile: str | None = None,\\n cert_reqs: int | None = None,\\n ca_certs: str | None = None,\\n server_hostname: str | None = None,\\n ssl_version: int | None = None,\\n ciphers: str | None = None,\\n ssl_context: ssl.SSLContext | None = None,\\n ca_cert_dir: str | None = None,\\n key_password: str | None = None,\\n ca_cert_data: None | str | bytes = None,\\n tls_in_tls: bool = False,\\n) -> ssl.SSLSocket | SSLTransportType:\\ndef is_ipaddress(hostname: str | bytes) -> bool:\\ndef _is_key_file_encrypted(key_file: str) -> bool:\\ndef _ssl_wrap_socket_impl(\\n sock: socket.socket,\\n ssl_context: ssl.SSLContext,\\n tls_in_tls: bool,\\n server_hostname: str | None = None,\\n) -> ssl.SSLSocket | SSLTransportType:\\n class _TYPE_PEER_CERT_RET_DICT(TypedDict, total=False):\"\n },\n {\n \"identifier\": \"SKIP_HEADER\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/request.py\",\n \"snippet\": \"SKIP_HEADER = \\\"@@@SKIP_HEADER@@@\\\"\"\n },\n {\n \"identifier\": \"SKIPPABLE_HEADERS\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/request.py\",\n \"snippet\": \"SKIPPABLE_HEADERS = frozenset([\\\"accept-encoding\\\", \\\"host\\\", \\\"user-agent\\\"])\"\n },\n {\n \"identifier\": \"body_to_chunks\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/request.py\",\n \"snippet\": \"def body_to_chunks(\\n body: typing.Any | None, method: str, blocksize: int\\n) -> ChunksAndContentLength:\\n \\\"\\\"\\\"Takes the HTTP request method, body, and blocksize and\\n transforms them into an iterable of chunks to pass to\\n socket.sendall() and an optional 'Content-Length' header.\\n\\n A 'Content-Length' of 'None' indicates the length of the body\\n can't be determined so should use 'Transfer-Encoding: chunked'\\n for framing instead.\\n \\\"\\\"\\\"\\n\\n chunks: typing.Iterable[bytes] | None\\n content_length: int | None\\n\\n # No body, we need to make a recommendation on 'Content-Length'\\n # based on whether that request method is expected to have\\n # a body or not.\\n if body is None:\\n chunks = None\\n if method.upper() not in _METHODS_NOT_EXPECTING_BODY:\\n content_length = 0\\n else:\\n content_length = None\\n\\n # Bytes or strings become bytes\\n elif isinstance(body, (str, bytes)):\\n chunks = (to_bytes(body),)\\n content_length = len(chunks[0])\\n\\n # File-like object, TODO: use seek() and tell() for length?\\n elif hasattr(body, \\\"read\\\"):\\n\\n def chunk_readable() -> typing.Iterable[bytes]:\\n nonlocal body, blocksize\\n encode = isinstance(body, io.TextIOBase)\\n while True:\\n datablock = body.read(blocksize)\\n if not datablock:\\n break\\n if encode:\\n datablock = datablock.encode(\\\"iso-8859-1\\\")\\n yield datablock\\n\\n chunks = chunk_readable()\\n content_length = None\\n\\n # Otherwise we need to start checking via duck-typing.\\n else:\\n try:\\n # Check if the body implements the buffer API.\\n mv = memoryview(body)\\n except TypeError:\\n try:\\n # Check if the body is an iterable\\n chunks = iter(body)\\n content_length = None\\n except TypeError:\\n raise TypeError(\\n f\\\"'body' must be a bytes-like object, file-like \\\"\\n f\\\"object, or iterable. Instead was {body!r}\\\"\\n ) from None\\n else:\\n # Since it implements the buffer API can be passed directly to socket.sendall()\\n chunks = (body,)\\n content_length = mv.nbytes\\n\\n return ChunksAndContentLength(chunks=chunks, content_length=content_length)\"\n },\n {\n \"identifier\": \"assert_fingerprint\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"def assert_fingerprint(cert: bytes | None, fingerprint: str) -> None:\\n \\\"\\\"\\\"\\n Checks if given fingerprint matches the supplied certificate.\\n\\n :param cert:\\n Certificate as bytes object.\\n :param fingerprint:\\n Fingerprint as string of hexdigits, can be interspersed by colons.\\n \\\"\\\"\\\"\\n\\n if cert is None:\\n raise SSLError(\\\"No certificate for the peer.\\\")\\n\\n fingerprint = fingerprint.replace(\\\":\\\", \\\"\\\").lower()\\n digest_length = len(fingerprint)\\n hashfunc = HASHFUNC_MAP.get(digest_length)\\n if not hashfunc:\\n raise SSLError(f\\\"Fingerprint of invalid length: {fingerprint}\\\")\\n\\n # We need encode() here for py32; works on py2 and p33.\\n fingerprint_bytes = unhexlify(fingerprint.encode())\\n\\n cert_digest = hashfunc(cert).digest()\\n\\n if not hmac.compare_digest(cert_digest, fingerprint_bytes):\\n raise SSLError(\\n f'Fingerprints did not match. Expected \\\"{fingerprint}\\\", got \\\"{cert_digest.hex()}\\\"'\\n )\"\n },\n {\n \"identifier\": \"create_urllib3_context\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"def create_urllib3_context(\\n ssl_version: int | None = None,\\n cert_reqs: int | None = None,\\n options: int | None = None,\\n ciphers: str | None = None,\\n ssl_minimum_version: int | None = None,\\n ssl_maximum_version: int | None = None,\\n) -> ssl.SSLContext:\\n \\\"\\\"\\\"Creates and configures an :class:`ssl.SSLContext` instance for use with urllib3.\\n\\n :param ssl_version:\\n The desired protocol version to use. This will default to\\n PROTOCOL_SSLv23 which will negotiate the highest protocol that both\\n the server and your installation of OpenSSL support.\\n\\n This parameter is deprecated instead use 'ssl_minimum_version'.\\n :param ssl_minimum_version:\\n The minimum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value.\\n :param ssl_maximum_version:\\n The maximum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value.\\n Not recommended to set to anything other than 'ssl.TLSVersion.MAXIMUM_SUPPORTED' which is the\\n default value.\\n :param cert_reqs:\\n Whether to require the certificate verification. This defaults to\\n ``ssl.CERT_REQUIRED``.\\n :param options:\\n Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,\\n ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``.\\n :param ciphers:\\n Which cipher suites to allow the server to select. Defaults to either system configured\\n ciphers if OpenSSL 1.1.1+, otherwise uses a secure default set of ciphers.\\n :returns:\\n Constructed SSLContext object with specified options\\n :rtype: SSLContext\\n \\\"\\\"\\\"\\n if SSLContext is None:\\n raise TypeError(\\\"Can't create an SSLContext object without an ssl module\\\")\\n\\n # This means 'ssl_version' was specified as an exact value.\\n if ssl_version not in (None, PROTOCOL_TLS, PROTOCOL_TLS_CLIENT):\\n # Disallow setting 'ssl_version' and 'ssl_minimum|maximum_version'\\n # to avoid conflicts.\\n if ssl_minimum_version is not None or ssl_maximum_version is not None:\\n raise ValueError(\\n \\\"Can't specify both 'ssl_version' and either \\\"\\n \\\"'ssl_minimum_version' or 'ssl_maximum_version'\\\"\\n )\\n\\n # 'ssl_version' is deprecated and will be removed in the future.\\n else:\\n # Use 'ssl_minimum_version' and 'ssl_maximum_version' instead.\\n ssl_minimum_version = _SSL_VERSION_TO_TLS_VERSION.get(\\n ssl_version, TLSVersion.MINIMUM_SUPPORTED\\n )\\n ssl_maximum_version = _SSL_VERSION_TO_TLS_VERSION.get(\\n ssl_version, TLSVersion.MAXIMUM_SUPPORTED\\n )\\n\\n # This warning message is pushing users to use 'ssl_minimum_version'\\n # instead of both min/max. Best practice is to only set the minimum version and\\n # keep the maximum version to be it's default value: 'TLSVersion.MAXIMUM_SUPPORTED'\\n warnings.warn(\\n \\\"'ssl_version' option is deprecated and will be \\\"\\n \\\"removed in urllib3 v2.1.0. Instead use 'ssl_minimum_version'\\\",\\n category=DeprecationWarning,\\n stacklevel=2,\\n )\\n\\n # PROTOCOL_TLS is deprecated in Python 3.10 so we always use PROTOCOL_TLS_CLIENT\\n context = SSLContext(PROTOCOL_TLS_CLIENT)\\n\\n if ssl_minimum_version is not None:\\n context.minimum_version = ssl_minimum_version\\n else: # Python <3.10 defaults to 'MINIMUM_SUPPORTED' so explicitly set TLSv1.2 here\\n context.minimum_version = TLSVersion.TLSv1_2\\n\\n if ssl_maximum_version is not None:\\n context.maximum_version = ssl_maximum_version\\n\\n # Unless we're given ciphers defer to either system ciphers in\\n # the case of OpenSSL 1.1.1+ or use our own secure default ciphers.\\n if ciphers:\\n context.set_ciphers(ciphers)\\n\\n # Setting the default here, as we may have no ssl module on import\\n cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs\\n\\n if options is None:\\n options = 0\\n # SSLv2 is easily broken and is considered harmful and dangerous\\n options |= OP_NO_SSLv2\\n # SSLv3 has several problems and is now dangerous\\n options |= OP_NO_SSLv3\\n # Disable compression to prevent CRIME attacks for OpenSSL 1.0+\\n # (issue #309)\\n options |= OP_NO_COMPRESSION\\n # TLSv1.2 only. Unless set explicitly, do not request tickets.\\n # This may save some bandwidth on wire, and although the ticket is encrypted,\\n # there is a risk associated with it being on wire,\\n # if the server is not rotating its ticketing keys properly.\\n options |= OP_NO_TICKET\\n\\n context.options |= options\\n\\n # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is\\n # necessary for conditional client cert authentication with TLS 1.3.\\n # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older\\n # versions of Python. We only enable if certificate verification is enabled to work\\n # around Python issue #37428\\n # See: https://bugs.python.org/issue37428\\n if (\\n cert_reqs == ssl.CERT_REQUIRED\\n and getattr(context, \\\"post_handshake_auth\\\", None) is not None\\n ):\\n context.post_handshake_auth = True\\n\\n # The order of the below lines setting verify_mode and check_hostname\\n # matter due to safe-guards SSLContext has to prevent an SSLContext with\\n # check_hostname=True, verify_mode=NONE/OPTIONAL.\\n # We always set 'check_hostname=False' for pyOpenSSL so we rely on our own\\n # 'ssl.match_hostname()' implementation.\\n if cert_reqs == ssl.CERT_REQUIRED and not IS_PYOPENSSL:\\n context.verify_mode = cert_reqs\\n context.check_hostname = True\\n else:\\n context.check_hostname = False\\n context.verify_mode = cert_reqs\\n\\n try:\\n context.hostname_checks_common_name = False\\n except AttributeError: # Defensive: for CPython < 3.8.9 and 3.9.3; for PyPy < 7.3.8\\n pass\\n\\n # Enable logging of TLS session keys via defacto standard environment variable\\n # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values.\\n if hasattr(context, \\\"keylog_filename\\\"):\\n sslkeylogfile = os.environ.get(\\\"SSLKEYLOGFILE\\\")\\n if sslkeylogfile:\\n context.keylog_filename = sslkeylogfile\\n\\n return context\"\n },\n {\n \"identifier\": \"is_ipaddress\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"def is_ipaddress(hostname: str | bytes) -> bool:\\n \\\"\\\"\\\"Detects whether the hostname given is an IPv4 or IPv6 address.\\n Also detects IPv6 addresses with Zone IDs.\\n\\n :param str hostname: Hostname to examine.\\n :return: True if the hostname is an IP address, False otherwise.\\n \\\"\\\"\\\"\\n if isinstance(hostname, bytes):\\n # IDN A-label bytes are ASCII compatible.\\n hostname = hostname.decode(\\\"ascii\\\")\\n return bool(_IPV4_RE.match(hostname) or _BRACELESS_IPV6_ADDRZ_RE.match(hostname))\"\n },\n {\n \"identifier\": \"resolve_cert_reqs\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"def resolve_cert_reqs(candidate: None | int | str) -> VerifyMode:\\n \\\"\\\"\\\"\\n Resolves the argument to a numeric constant, which can be passed to\\n the wrap_socket function/method from the ssl module.\\n Defaults to :data:`ssl.CERT_REQUIRED`.\\n If given a string it is assumed to be the name of the constant in the\\n :mod:`ssl` module or its abbreviation.\\n (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.\\n If it's neither `None` nor a string we assume it is already the numeric\\n constant which can directly be passed to wrap_socket.\\n \\\"\\\"\\\"\\n if candidate is None:\\n return CERT_REQUIRED\\n\\n if isinstance(candidate, str):\\n res = getattr(ssl, candidate, None)\\n if res is None:\\n res = getattr(ssl, \\\"CERT_\\\" + candidate)\\n return res # type: ignore[no-any-return]\\n\\n return candidate # type: ignore[return-value]\"\n },\n {\n \"identifier\": \"resolve_ssl_version\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"def resolve_ssl_version(candidate: None | int | str) -> int:\\n \\\"\\\"\\\"\\n like resolve_cert_reqs\\n \\\"\\\"\\\"\\n if candidate is None:\\n return PROTOCOL_TLS\\n\\n if isinstance(candidate, str):\\n res = getattr(ssl, candidate, None)\\n if res is None:\\n res = getattr(ssl, \\\"PROTOCOL_\\\" + candidate)\\n return typing.cast(int, res)\\n\\n return candidate\"\n },\n {\n \"identifier\": \"ssl_wrap_socket\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_.py\",\n \"snippet\": \"@typing.overload\\ndef ssl_wrap_socket(\\n sock: socket.socket,\\n keyfile: str | None = ...,\\n certfile: str | None = ...,\\n cert_reqs: int | None = ...,\\n ca_certs: str | None = ...,\\n server_hostname: str | None = ...,\\n ssl_version: int | None = ...,\\n ciphers: str | None = ...,\\n ssl_context: ssl.SSLContext | None = ...,\\n ca_cert_dir: str | None = ...,\\n key_password: str | None = ...,\\n ca_cert_data: None | str | bytes = ...,\\n tls_in_tls: Literal[False] = ...,\\n) -> ssl.SSLSocket:\\n ...\"\n },\n {\n \"identifier\": \"CertificateError\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_match_hostname.py\",\n \"snippet\": \"class CertificateError(ValueError):\\n pass\"\n },\n {\n \"identifier\": \"match_hostname\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/ssl_match_hostname.py\",\n \"snippet\": \"def match_hostname(\\n cert: _TYPE_PEER_CERT_RET_DICT | None,\\n hostname: str,\\n hostname_checks_common_name: bool = False,\\n) -> None:\\n \\\"\\\"\\\"Verify that *cert* (in decoded format as returned by\\n SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125\\n rules are followed, but IP addresses are not accepted for *hostname*.\\n\\n CertificateError is raised on failure. On success, the function\\n returns nothing.\\n \\\"\\\"\\\"\\n if not cert:\\n raise ValueError(\\n \\\"empty or no certificate, match_hostname needs a \\\"\\n \\\"SSL socket or SSL context with either \\\"\\n \\\"CERT_OPTIONAL or CERT_REQUIRED\\\"\\n )\\n try:\\n # Divergence from upstream: ipaddress can't handle byte str\\n #\\n # The ipaddress module shipped with Python < 3.9 does not support\\n # scoped IPv6 addresses so we unconditionally strip the Zone IDs for\\n # now. Once we drop support for Python 3.9 we can remove this branch.\\n if \\\"%\\\" in hostname:\\n host_ip = ipaddress.ip_address(hostname[: hostname.rfind(\\\"%\\\")])\\n else:\\n host_ip = ipaddress.ip_address(hostname)\\n\\n except ValueError:\\n # Not an IP address (common case)\\n host_ip = None\\n dnsnames = []\\n san: tuple[tuple[str, str], ...] = cert.get(\\\"subjectAltName\\\", ())\\n key: str\\n value: str\\n for key, value in san:\\n if key == \\\"DNS\\\":\\n if host_ip is None and _dnsname_match(value, hostname):\\n return\\n dnsnames.append(value)\\n elif key == \\\"IP Address\\\":\\n if host_ip is not None and _ipaddress_match(value, host_ip):\\n return\\n dnsnames.append(value)\\n\\n # We only check 'commonName' if it's enabled and we're not verifying\\n # an IP address. IP addresses aren't valid within 'commonName'.\\n if hostname_checks_common_name and host_ip is None and not dnsnames:\\n for sub in cert.get(\\\"subject\\\", ()):\\n for key, value in sub:\\n if key == \\\"commonName\\\":\\n if _dnsname_match(value, hostname):\\n return\\n dnsnames.append(value)\\n\\n if len(dnsnames) > 1:\\n raise CertificateError(\\n \\\"hostname %r \\\"\\n \\\"doesn't match either of %s\\\" % (hostname, \\\", \\\".join(map(repr, dnsnames)))\\n )\\n elif len(dnsnames) == 1:\\n raise CertificateError(f\\\"hostname {hostname!r} doesn't match {dnsnames[0]!r}\\\")\\n else:\\n raise CertificateError(\\\"no appropriate subjectAltName fields were found\\\")\"\n },\n {\n \"identifier\": \"Url\",\n \"path\": \".venv/Lib/site-packages/urllib3/util/url.py\",\n \"snippet\": \"class Url(\\n typing.NamedTuple(\\n \\\"Url\\\",\\n [\\n (\\\"scheme\\\", typing.Optional[str]),\\n (\\\"auth\\\", typing.Optional[str]),\\n (\\\"host\\\", typing.Optional[str]),\\n (\\\"port\\\", typing.Optional[int]),\\n (\\\"path\\\", typing.Optional[str]),\\n (\\\"query\\\", typing.Optional[str]),\\n (\\\"fragment\\\", typing.Optional[str]),\\n ],\\n )\\n):\\n \\\"\\\"\\\"\\n Data structure for representing an HTTP URL. Used as a return value for\\n :func:`parse_url`. Both the scheme and host are normalized as they are\\n both case-insensitive according to RFC 3986.\\n \\\"\\\"\\\"\\n\\n def __new__( # type: ignore[no-untyped-def]\\n cls,\\n scheme: str | None = None,\\n auth: str | None = None,\\n host: str | None = None,\\n port: int | None = None,\\n path: str | None = None,\\n query: str | None = None,\\n fragment: str | None = None,\\n ):\\n if path and not path.startswith(\\\"/\\\"):\\n path = \\\"/\\\" + path\\n if scheme is not None:\\n scheme = scheme.lower()\\n return super().__new__(cls, scheme, auth, host, port, path, query, fragment)\\n\\n @property\\n def hostname(self) -> str | None:\\n \\\"\\\"\\\"For backwards-compatibility with urlparse. We're nice like that.\\\"\\\"\\\"\\n return self.host\\n\\n @property\\n def request_uri(self) -> str:\\n \\\"\\\"\\\"Absolute path including the query string.\\\"\\\"\\\"\\n uri = self.path or \\\"/\\\"\\n\\n if self.query is not None:\\n uri += \\\"?\\\" + self.query\\n\\n return uri\\n\\n @property\\n def authority(self) -> str | None:\\n \\\"\\\"\\\"\\n Authority component as defined in RFC 3986 3.2.\\n This includes userinfo (auth), host and port.\\n\\n i.e.\\n userinfo@host:port\\n \\\"\\\"\\\"\\n userinfo = self.auth\\n netloc = self.netloc\\n if netloc is None or userinfo is None:\\n return netloc\\n else:\\n return f\\\"{userinfo}@{netloc}\\\"\\n\\n @property\\n def netloc(self) -> str | None:\\n \\\"\\\"\\\"\\n Network location including host and port.\\n\\n If you need the equivalent of urllib.parse's ``netloc``,\\n use the ``authority`` property instead.\\n \\\"\\\"\\\"\\n if self.host is None:\\n return None\\n if self.port:\\n return f\\\"{self.host}:{self.port}\\\"\\n return self.host\\n\\n @property\\n def url(self) -> str:\\n \\\"\\\"\\\"\\n Convert self into a url\\n\\n This function should more or less round-trip with :func:`.parse_url`. The\\n returned url may not be exactly the same as the url inputted to\\n :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls\\n with a blank port will have : removed).\\n\\n Example:\\n\\n .. code-block:: python\\n\\n import urllib3\\n\\n U = urllib3.util.parse_url(\\\"https://google.com/mail/\\\")\\n\\n print(U.url)\\n # \\\"https://google.com/mail/\\\"\\n\\n print( urllib3.util.Url(\\\"https\\\", \\\"username:password\\\",\\n \\\"host.com\\\", 80, \\\"/path\\\", \\\"query\\\", \\\"fragment\\\"\\n ).url\\n )\\n # \\\"https://username:password@host.com:80/path?query#fragment\\\"\\n \\\"\\\"\\\"\\n scheme, auth, host, port, path, query, fragment = self\\n url = \\\"\\\"\\n\\n # We use \\\"is not None\\\" we want things to happen with empty strings (or 0 port)\\n if scheme is not None:\\n url += scheme + \\\"://\\\"\\n if auth is not None:\\n url += auth + \\\"@\\\"\\n if host is not None:\\n url += host\\n if port is not None:\\n url += \\\":\\\" + str(port)\\n if path is not None:\\n url += path\\n if query is not None:\\n url += \\\"?\\\" + query\\n if fragment is not None:\\n url += \\\"#\\\" + fragment\\n\\n return url\\n\\n def __str__(self) -> str:\\n return self.url\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import datetime\nimport logging\nimport os\nimport re\nimport socket\nimport sys\nimport typing\nimport warnings\n import ssl\nfrom http.client import HTTPConnection as _HTTPConnection\nfrom http.client import HTTPException as HTTPException # noqa: F401\nfrom http.client import ResponseNotReady\nfrom socket import timeout as SocketTimeout\n from typing import Literal\n from .response import HTTPResponse\n from .util.ssl_ import _TYPE_PEER_CERT_RET_DICT\n from .util.ssltransport import SSLTransport\nfrom ._collections import HTTPHeaderDict\nfrom .util.response import assert_header_parsing\nfrom .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT, Timeout\nfrom .util.util import to_str\nfrom .util.wait import wait_for_read\nfrom ._base_connection import _TYPE_BODY\nfrom ._base_connection import ProxyConfig as ProxyConfig\nfrom ._base_connection import _ResponseOptions as _ResponseOptions\nfrom ._version import __version__\nfrom .exceptions import (\n ConnectTimeoutError,\n HeaderParsingError,\n NameResolutionError,\n NewConnectionError,\n ProxyError,\n SystemTimeWarning,\n)\nfrom .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection, ssl_\nfrom .util.request import body_to_chunks\nfrom .util.ssl_ import assert_fingerprint as _assert_fingerprint\nfrom .util.ssl_ import (\n create_urllib3_context,\n is_ipaddress,\n resolve_cert_reqs,\n resolve_ssl_version,\n ssl_wrap_socket,\n)\nfrom .util.ssl_match_hostname import CertificateError, match_hostname\nfrom .util.url import Url\n from .response import HTTPResponse"},"token_num":{"kind":"number","value":15841,"string":"15,841"},"cropped_code":{"kind":"string","value":" (\n f\"System time is way off (before {RECENT_DATE}). This will probably \"\n \"lead to SSL verification errors\"\n ),\n SystemTimeWarning,\n )\n\n sock_and_verified = _ssl_wrap_socket_and_match_hostname(\n sock=sock,\n cert_reqs=self.cert_reqs,\n ssl_version=self.ssl_version,\n ssl_minimum_version=self.ssl_minimum_version,\n ssl_maximum_version=self.ssl_maximum_version,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n ca_cert_data=self.ca_cert_data,\n cert_file=self.cert_file,\n key_file=self.key_file,\n key_password=self.key_password,\n server_hostname=server_hostname,\n ssl_context=self.ssl_context,\n tls_in_tls=tls_in_tls,\n assert_hostname=self.assert_hostname,\n assert_fingerprint=self.assert_fingerprint,\n )\n self.sock = sock_and_verified.socket\n self.is_verified = sock_and_verified.is_verified\n\n # If there's a proxy to be connected to we are fully connected.\n # This is set twice (once above and here) due to forwarding proxies\n # not using tunnelling.\n self._has_connected_to_proxy = bool(self.proxy)\n\n def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:\n \"\"\"\n Establish a TLS connection to the proxy using the provided SSL context.\n \"\"\"\n # `_connect_tls_proxy` is called when self._tunnel_host is truthy.\n proxy_config = typing.cast(ProxyConfig, self.proxy_config)\n ssl_context = proxy_config.ssl_context\n sock_and_verified = _ssl_wrap_socket_and_match_hostname(\n sock,\n cert_reqs=self.cert_reqs,\n ssl_version=self.ssl_version,\n ssl_minimum_version=self.ssl_minimum_version,\n ssl_maximum_version=self.ssl_maximum_version,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n ca_cert_data=self.ca_cert_data,\n server_hostname=hostname,\n ssl_context=ssl_context,\n assert_hostname=proxy_config.assert_hostname,\n assert_fingerprint=proxy_config.assert_fingerprint,\n # Features that aren't implemented for proxies yet:\n cert_file=None,\n key_file=None,\n key_password=None,\n tls_in_tls=False,\n )\n self.proxy_is_verified = sock_and_verified.is_verified\n return sock_and_verified.socket # type: ignore[return-value]\n\n\nclass _WrappedAndVerifiedSocket(typing.NamedTuple):\n \"\"\"\n Wrapped socket and whether the connection is\n verified after the TLS handshake\n \"\"\"\n\n socket: ssl.SSLSocket | SSLTransport\n is_verified: bool\n\n\ndef _ssl_wrap_socket_and_match_hostname(\n sock: socket.socket,\n *,\n cert_reqs: None | str | int,\n ssl_version: None | str | int,\n ssl_minimum_version: int | None,\n ssl_maximum_version: int | None,\n cert_file: str | None,\n key_file: str | None,\n key_password: str | None,\n ca_certs: str | None,\n ca_cert_dir: str | None,\n ca_cert_data: None | str | bytes,\n assert_hostname: None | str | Literal[False],\n assert_fingerprint: str | None,\n server_hostname: str | None,\n ssl_context: ssl.SSLContext | None,\n tls_in_tls: bool = False,\n) -> _WrappedAndVerifiedSocket:\n \"\"\"Logic for constructing an SSLContext from all TLS parameters, passing\n that down into ssl_wrap_socket, and then doing certificate verification\n either via hostname or fingerprint. This function exists to guarantee\n that both proxies and targets have the same behavior when connecting via TLS.\n \"\"\"\n default_ssl_context = False\n if ssl_context is None:\n default_ssl_context = True\n context = create_urllib3_context(\n ssl_version=resolve_ssl_version(ssl_version),\n ssl_minimum_version=ssl_minimum_version,\n ssl_maximum_version=ssl_maximum_version,\n cert_reqs=resolve_cert_reqs(cert_reqs),\n )\n else:\n context = ssl_context\n\n context.verify_mode = resolve_cert_reqs(cert_reqs)\n\n # In some cases, we want to verify hostnames ourselves\n if (\n # `ssl` can't verify fingerprints or alternate hostnames\n assert_fingerprint\n or assert_hostname\n # assert_hostname can be set to False to disable hostname checking\n or assert_hostname is False\n # We still support OpenSSL 1.0.2, which prevents us from verifying\n # hostnames easily: https://github.com/pyca/pyopenssl/pull/933\n"},"all_code":{"kind":"string","value":"from __future__ import annotations\n\n\nif typing.TYPE_CHECKING:\n\n\n\ntry: # Compiled with SSL?\n\n BaseSSLError = ssl.SSLError\nexcept (ImportError, AttributeError):\n ssl = None # type: ignore[assignment]\n\n class BaseSSLError(BaseException): # type: ignore[no-redef]\n pass\n\n\n\n# Not a no-op, we're adding this to the namespace so it can be imported.\nConnectionError = ConnectionError\nBrokenPipeError = BrokenPipeError\n\n\nlog = logging.getLogger(__name__)\n\nport_by_scheme = {\"http\": 80, \"https\": 443}\n\n# When it comes time to update this value as a part of regular maintenance\n# (ie test_recent_date is failing) update it to ~6 months before the current date.\nRECENT_DATE = datetime.date(2022, 1, 1)\n\n_CONTAINS_CONTROL_CHAR_RE = re.compile(r\"[^-!#$%&'*+.^_`|~0-9a-zA-Z]\")\n\n_HAS_SYS_AUDIT = hasattr(sys, \"audit\")\n\n\nclass HTTPConnection(_HTTPConnection):\n \"\"\"\n Based on :class:`http.client.HTTPConnection` but provides an extra constructor\n backwards-compatibility layer between older and newer Pythons.\n\n Additional keyword parameters are used to configure attributes of the connection.\n Accepted parameters include:\n\n - ``source_address``: Set the source address for the current connection.\n - ``socket_options``: Set specific options on the underlying socket. If not specified, then\n defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling\n Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy.\n\n For example, if you wish to enable TCP Keep Alive in addition to the defaults,\n you might pass:\n\n .. code-block:: python\n\n HTTPConnection.default_socket_options + [\n (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),\n ]\n\n Or you may want to disable the defaults by passing an empty list (e.g., ``[]``).\n \"\"\"\n\n default_port: typing.ClassVar[int] = port_by_scheme[\"http\"] # type: ignore[misc]\n\n #: Disable Nagle's algorithm by default.\n #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]``\n default_socket_options: typing.ClassVar[connection._TYPE_SOCKET_OPTIONS] = [\n (socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)\n ]\n\n #: Whether this connection verifies the host's certificate.\n is_verified: bool = False\n\n #: Whether this proxy connection verified the proxy host's certificate.\n # If no proxy is currently connected to the value will be ``None``.\n proxy_is_verified: bool | None = None\n\n blocksize: int\n source_address: tuple[str, int] | None\n socket_options: connection._TYPE_SOCKET_OPTIONS | None\n\n _has_connected_to_proxy: bool\n _response_options: _ResponseOptions | None\n _tunnel_host: str | None\n _tunnel_port: int | None\n _tunnel_scheme: str | None\n\n def __init__(\n self,\n host: str,\n port: int | None = None,\n *,\n timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\n source_address: tuple[str, int] | None = None,\n blocksize: int = 16384,\n socket_options: None\n | (connection._TYPE_SOCKET_OPTIONS) = default_socket_options,\n proxy: Url | None = None,\n proxy_config: ProxyConfig | None = None,\n ) -> None:\n super().__init__(\n host=host,\n port=port,\n timeout=Timeout.resolve_default_timeout(timeout),\n source_address=source_address,\n blocksize=blocksize,\n )\n self.socket_options = socket_options\n self.proxy = proxy\n self.proxy_config = proxy_config\n\n self._has_connected_to_proxy = False\n self._response_options = None\n self._tunnel_host: str | None = None\n self._tunnel_port: int | None = None\n self._tunnel_scheme: str | None = None\n\n # https://github.com/python/mypy/issues/4125\n # Mypy treats this as LSP violation, which is considered a bug.\n # If `host` is made a property it violates LSP, because a writeable attribute is overridden with a read-only one.\n # However, there is also a `host` setter so LSP is not violated.\n # Potentially, a `@host.deleter` might be needed depending on how this issue will be fixed.\n @property\n def host(self) -> str:\n \"\"\"\n Getter method to remove any trailing dots that indicate the hostname is an FQDN.\n\n In general, SSL certificates don't include the trailing dot indicating a\n fully-qualified domain name, and thus, they don't validate properly when\n checked against a domain name that includes the dot. In addition, some\n servers may not expect to receive the trailing dot when provided.\n\n However, the hostname with trailing dot is critical to DNS resolution; doing a\n lookup with the trailing dot will properly only resolve the appropriate FQDN,\n whereas a lookup without a trailing dot will search the system's search domain\n list. Thus, it's important to keep the original host around for use only in\n those cases where it's appropriate (i.e., when doing DNS lookup to establish the\n actual TCP connection across which we're going to send HTTP requests).\n \"\"\"\n return self._dns_host.rstrip(\".\")\n\n @host.setter\n def host(self, value: str) -> None:\n \"\"\"\n Setter for the `host` property.\n\n We assume that only urllib3 uses the _dns_host attribute; httplib itself\n only uses `host`, and it seems reasonable that other libraries follow suit.\n \"\"\"\n self._dns_host = value\n\n def _new_conn(self) -> socket.socket:\n \"\"\"Establish a socket connection and set nodelay settings on it.\n\n :return: New socket connection.\n \"\"\"\n try:\n sock = connection.create_connection(\n (self._dns_host, self.port),\n self.timeout,\n source_address=self.source_address,\n socket_options=self.socket_options,\n )\n except socket.gaierror as e:\n raise NameResolutionError(self.host, self, e) from e\n except SocketTimeout as e:\n raise ConnectTimeoutError(\n self,\n f\"Connection to {self.host} timed out. (connect timeout={self.timeout})\",\n ) from e\n\n except OSError as e:\n raise NewConnectionError(\n self, f\"Failed to establish a new connection: {e}\"\n ) from e\n\n # Audit hooks are only available in Python 3.8+\n if _HAS_SYS_AUDIT:\n sys.audit(\"http.client.connect\", self, self.host, self.port)\n\n return sock\n\n def set_tunnel(\n self,\n host: str,\n port: int | None = None,\n headers: typing.Mapping[str, str] | None = None,\n scheme: str = \"http\",\n ) -> None:\n if scheme not in (\"http\", \"https\"):\n raise ValueError(\n f\"Invalid proxy scheme for tunneling: {scheme!r}, must be either 'http' or 'https'\"\n )\n super().set_tunnel(host, port=port, headers=headers)\n self._tunnel_scheme = scheme\n\n def connect(self) -> None:\n self.sock = self._new_conn()\n if self._tunnel_host:\n # If we're tunneling it means we're connected to our proxy.\n self._has_connected_to_proxy = True\n\n # TODO: Fix tunnel so it doesn't depend on self.sock state.\n self._tunnel() # type: ignore[attr-defined]\n\n # If there's a proxy to be connected to we are fully connected.\n # This is set twice (once above and here) due to forwarding proxies\n # not using tunnelling.\n self._has_connected_to_proxy = bool(self.proxy)\n\n @property\n def is_closed(self) -> bool:\n return self.sock is None\n\n @property\n def is_connected(self) -> bool:\n if self.sock is None:\n return False\n return not wait_for_read(self.sock, timeout=0.0)\n\n @property\n def has_connected_to_proxy(self) -> bool:\n return self._has_connected_to_proxy\n\n def close(self) -> None:\n try:\n super().close()\n finally:\n # Reset all stateful properties so connection\n # can be re-used without leaking prior configs.\n self.sock = None\n self.is_verified = False\n self.proxy_is_verified = None\n self._has_connected_to_proxy = False\n self._response_options = None\n self._tunnel_host = None\n self._tunnel_port = None\n self._tunnel_scheme = None\n\n def putrequest(\n self,\n method: str,\n url: str,\n skip_host: bool = False,\n skip_accept_encoding: bool = False,\n ) -> None:\n \"\"\"\"\"\"\n # Empty docstring because the indentation of CPython's implementation\n # is broken but we don't want this method in our documentation.\n match = _CONTAINS_CONTROL_CHAR_RE.search(method)\n if match:\n raise ValueError(\n f\"Method cannot contain non-token characters {method!r} (found at least {match.group()!r})\"\n )\n\n return super().putrequest(\n method, url, skip_host=skip_host, skip_accept_encoding=skip_accept_encoding\n )\n\n def putheader(self, header: str, *values: str) -> None:\n \"\"\"\"\"\"\n if not any(isinstance(v, str) and v == SKIP_HEADER for v in values):\n super().putheader(header, *values)\n elif to_str(header.lower()) not in SKIPPABLE_HEADERS:\n skippable_headers = \"', '\".join(\n [str.title(header) for header in sorted(SKIPPABLE_HEADERS)]\n )\n raise ValueError(\n f\"urllib3.util.SKIP_HEADER only supports '{skippable_headers}'\"\n )\n\n # `request` method's signature intentionally violates LSP.\n # urllib3's API is different from `http.client.HTTPConnection` and the subclassing is only incidental.\n def request( # type: ignore[override]\n self,\n method: str,\n url: str,\n body: _TYPE_BODY | None = None,\n headers: typing.Mapping[str, str] | None = None,\n *,\n chunked: bool = False,\n preload_content: bool = True,\n decode_content: bool = True,\n enforce_content_length: bool = True,\n ) -> None:\n # Update the inner socket's timeout value to send the request.\n # This only triggers if the connection is re-used.\n if self.sock is not None:\n self.sock.settimeout(self.timeout)\n\n # Store these values to be fed into the HTTPResponse\n # object later. TODO: Remove this in favor of a real\n # HTTP lifecycle mechanism.\n\n # We have to store these before we call .request()\n # because sometimes we can still salvage a response\n # off the wire even if we aren't able to completely\n # send the request body.\n self._response_options = _ResponseOptions(\n request_method=method,\n request_url=url,\n preload_content=preload_content,\n decode_content=decode_content,\n enforce_content_length=enforce_content_length,\n )\n\n if headers is None:\n headers = {}\n header_keys = frozenset(to_str(k.lower()) for k in headers)\n skip_accept_encoding = \"accept-encoding\" in header_keys\n skip_host = \"host\" in header_keys\n self.putrequest(\n method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host\n )\n\n # Transform the body into an iterable of sendall()-able chunks\n # and detect if an explicit Content-Length is doable.\n chunks_and_cl = body_to_chunks(body, method=method, blocksize=self.blocksize)\n chunks = chunks_and_cl.chunks\n content_length = chunks_and_cl.content_length\n\n # When chunked is explicit set to 'True' we respect that.\n if chunked:\n if \"transfer-encoding\" not in header_keys:\n self.putheader(\"Transfer-Encoding\", \"chunked\")\n else:\n # Detect whether a framing mechanism is already in use. If so\n # we respect that value, otherwise we pick chunked vs content-length\n # depending on the type of 'body'.\n if \"content-length\" in header_keys:\n chunked = False\n elif \"transfer-encoding\" in header_keys:\n chunked = True\n\n # Otherwise we go off the recommendation of 'body_to_chunks()'.\n else:\n chunked = False\n if content_length is None:\n if chunks is not None:\n chunked = True\n self.putheader(\"Transfer-Encoding\", \"chunked\")\n else:\n self.putheader(\"Content-Length\", str(content_length))\n\n # Now that framing headers are out of the way we send all the other headers.\n if \"user-agent\" not in header_keys:\n self.putheader(\"User-Agent\", _get_default_user_agent())\n for header, value in headers.items():\n self.putheader(header, value)\n self.endheaders()\n\n # If we're given a body we start sending that in chunks.\n if chunks is not None:\n for chunk in chunks:\n # Sending empty chunks isn't allowed for TE: chunked\n # as it indicates the end of the body.\n if not chunk:\n continue\n if isinstance(chunk, str):\n chunk = chunk.encode(\"utf-8\")\n if chunked:\n self.send(b\"%x\\r\\n%b\\r\\n\" % (len(chunk), chunk))\n else:\n self.send(chunk)\n\n # Regardless of whether we have a body or not, if we're in\n # chunked mode we want to send an explicit empty chunk.\n if chunked:\n self.send(b\"0\\r\\n\\r\\n\")\n\n def request_chunked(\n self,\n method: str,\n url: str,\n body: _TYPE_BODY | None = None,\n headers: typing.Mapping[str, str] | None = None,\n ) -> None:\n \"\"\"\n Alternative to the common request method, which sends the\n body with chunked encoding and not as one block\n \"\"\"\n warnings.warn(\n \"HTTPConnection.request_chunked() is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Instead use HTTPConnection.request(..., chunked=True).\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n self.request(method, url, body=body, headers=headers, chunked=True)\n\n def getresponse( # type: ignore[override]\n self,\n ) -> HTTPResponse:\n \"\"\"\n Get the response from the server.\n\n If the HTTPConnection is in the correct state, returns an instance of HTTPResponse or of whatever object is returned by the response_class variable.\n\n If a request has not been sent or if a previous response has not be handled, ResponseNotReady is raised. If the HTTP response indicates that the connection should be closed, then it will be closed before the response is returned. When the connection is closed, the underlying socket is closed.\n \"\"\"\n # Raise the same error as http.client.HTTPConnection\n if self._response_options is None:\n raise ResponseNotReady()\n\n # Reset this attribute for being used again.\n resp_options = self._response_options\n self._response_options = None\n\n # Since the connection's timeout value may have been updated\n # we need to set the timeout on the socket.\n self.sock.settimeout(self.timeout)\n\n # This is needed here to avoid circular import errors\n\n # Get the response from http.client.HTTPConnection\n httplib_response = super().getresponse()\n\n try:\n assert_header_parsing(httplib_response.msg)\n except (HeaderParsingError, TypeError) as hpe:\n log.warning(\n \"Failed to parse headers (url=%s): %s\",\n _url_from_connection(self, resp_options.request_url),\n hpe,\n exc_info=True,\n )\n\n headers = HTTPHeaderDict(httplib_response.msg.items())\n\n response = HTTPResponse(\n body=httplib_response,\n headers=headers,\n status=httplib_response.status,\n version=httplib_response.version,\n reason=httplib_response.reason,\n preload_content=resp_options.preload_content,\n decode_content=resp_options.decode_content,\n original_response=httplib_response,\n enforce_content_length=resp_options.enforce_content_length,\n request_method=resp_options.request_method,\n request_url=resp_options.request_url,\n )\n return response\n\n\nclass HTTPSConnection(HTTPConnection):\n \"\"\"\n Many of the parameters to this constructor are passed to the underlying SSL\n socket by means of :py:func:`urllib3.util.ssl_wrap_socket`.\n \"\"\"\n\n default_port = port_by_scheme[\"https\"] # type: ignore[misc]\n\n cert_reqs: int | str | None = None\n ca_certs: str | None = None\n ca_cert_dir: str | None = None\n ca_cert_data: None | str | bytes = None\n ssl_version: int | str | None = None\n ssl_minimum_version: int | None = None\n ssl_maximum_version: int | None = None\n assert_fingerprint: str | None = None\n\n def __init__(\n self,\n host: str,\n port: int | None = None,\n *,\n timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,\n source_address: tuple[str, int] | None = None,\n blocksize: int = 16384,\n socket_options: None\n | (connection._TYPE_SOCKET_OPTIONS) = HTTPConnection.default_socket_options,\n proxy: Url | None = None,\n proxy_config: ProxyConfig | None = None,\n cert_reqs: int | str | None = None,\n assert_hostname: None | str | Literal[False] = None,\n assert_fingerprint: str | None = None,\n server_hostname: str | None = None,\n ssl_context: ssl.SSLContext | None = None,\n ca_certs: str | None = None,\n ca_cert_dir: str | None = None,\n ca_cert_data: None | str | bytes = None,\n ssl_minimum_version: int | None = None,\n ssl_maximum_version: int | None = None,\n ssl_version: int | str | None = None, # Deprecated\n cert_file: str | None = None,\n key_file: str | None = None,\n key_password: str | None = None,\n ) -> None:\n super().__init__(\n host,\n port=port,\n timeout=timeout,\n source_address=source_address,\n blocksize=blocksize,\n socket_options=socket_options,\n proxy=proxy,\n proxy_config=proxy_config,\n )\n\n self.key_file = key_file\n self.cert_file = cert_file\n self.key_password = key_password\n self.ssl_context = ssl_context\n self.server_hostname = server_hostname\n self.assert_hostname = assert_hostname\n self.assert_fingerprint = assert_fingerprint\n self.ssl_version = ssl_version\n self.ssl_minimum_version = ssl_minimum_version\n self.ssl_maximum_version = ssl_maximum_version\n self.ca_certs = ca_certs and os.path.expanduser(ca_certs)\n self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)\n self.ca_cert_data = ca_cert_data\n\n # cert_reqs depends on ssl_context so calculate last.\n if cert_reqs is None:\n if self.ssl_context is not None:\n cert_reqs = self.ssl_context.verify_mode\n else:\n cert_reqs = resolve_cert_reqs(None)\n self.cert_reqs = cert_reqs\n\n def set_cert(\n self,\n key_file: str | None = None,\n cert_file: str | None = None,\n cert_reqs: int | str | None = None,\n key_password: str | None = None,\n ca_certs: str | None = None,\n assert_hostname: None | str | Literal[False] = None,\n assert_fingerprint: str | None = None,\n ca_cert_dir: str | None = None,\n ca_cert_data: None | str | bytes = None,\n ) -> None:\n \"\"\"\n This method should only be called once, before the connection is used.\n \"\"\"\n warnings.warn(\n \"HTTPSConnection.set_cert() is deprecated and will be removed \"\n \"in urllib3 v2.1.0. Instead provide the parameters to the \"\n \"HTTPSConnection constructor.\",\n category=DeprecationWarning,\n stacklevel=2,\n )\n\n # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also\n # have an SSLContext object in which case we'll use its verify_mode.\n if cert_reqs is None:\n if self.ssl_context is not None:\n cert_reqs = self.ssl_context.verify_mode\n else:\n cert_reqs = resolve_cert_reqs(None)\n\n self.key_file = key_file\n self.cert_file = cert_file\n self.cert_reqs = cert_reqs\n self.key_password = key_password\n self.assert_hostname = assert_hostname\n self.assert_fingerprint = assert_fingerprint\n self.ca_certs = ca_certs and os.path.expanduser(ca_certs)\n self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)\n self.ca_cert_data = ca_cert_data\n\n def connect(self) -> None:\n sock: socket.socket | ssl.SSLSocket\n self.sock = sock = self._new_conn()\n server_hostname: str = self.host\n tls_in_tls = False\n\n # Do we need to establish a tunnel?\n if self._tunnel_host is not None:\n # We're tunneling to an HTTPS origin so need to do TLS-in-TLS.\n if self._tunnel_scheme == \"https\":\n self.sock = sock = self._connect_tls_proxy(self.host, sock)\n tls_in_tls = True\n\n # If we're tunneling it means we're connected to our proxy.\n self._has_connected_to_proxy = True\n\n self._tunnel() # type: ignore[attr-defined]\n # Override the host with the one we're requesting data from.\n server_hostname = self._tunnel_host\n\n if self.server_hostname is not None:\n server_hostname = self.server_hostname\n\n is_time_off = datetime.date.today() < RECENT_DATE\n if is_time_off:\n warnings.warn(\n (\n f\"System time is way off (before {RECENT_DATE}). This will probably \"\n \"lead to SSL verification errors\"\n ),\n SystemTimeWarning,\n )\n\n sock_and_verified = _ssl_wrap_socket_and_match_hostname(\n sock=sock,\n cert_reqs=self.cert_reqs,\n ssl_version=self.ssl_version,\n ssl_minimum_version=self.ssl_minimum_version,\n ssl_maximum_version=self.ssl_maximum_version,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n ca_cert_data=self.ca_cert_data,\n cert_file=self.cert_file,\n key_file=self.key_file,\n key_password=self.key_password,\n server_hostname=server_hostname,\n ssl_context=self.ssl_context,\n tls_in_tls=tls_in_tls,\n assert_hostname=self.assert_hostname,\n assert_fingerprint=self.assert_fingerprint,\n )\n self.sock = sock_and_verified.socket\n self.is_verified = sock_and_verified.is_verified\n\n # If there's a proxy to be connected to we are fully connected.\n # This is set twice (once above and here) due to forwarding proxies\n # not using tunnelling.\n self._has_connected_to_proxy = bool(self.proxy)\n\n def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:\n \"\"\"\n Establish a TLS connection to the proxy using the provided SSL context.\n \"\"\"\n # `_connect_tls_proxy` is called when self._tunnel_host is truthy.\n proxy_config = typing.cast(ProxyConfig, self.proxy_config)\n ssl_context = proxy_config.ssl_context\n sock_and_verified = _ssl_wrap_socket_and_match_hostname(\n sock,\n cert_reqs=self.cert_reqs,\n ssl_version=self.ssl_version,\n ssl_minimum_version=self.ssl_minimum_version,\n ssl_maximum_version=self.ssl_maximum_version,\n ca_certs=self.ca_certs,\n ca_cert_dir=self.ca_cert_dir,\n ca_cert_data=self.ca_cert_data,\n server_hostname=hostname,\n ssl_context=ssl_context,\n assert_hostname=proxy_config.assert_hostname,\n assert_fingerprint=proxy_config.assert_fingerprint,\n # Features that aren't implemented for proxies yet:\n cert_file=None,\n key_file=None,\n key_password=None,\n tls_in_tls=False,\n )\n self.proxy_is_verified = sock_and_verified.is_verified\n return sock_and_verified.socket # type: ignore[return-value]\n\n\nclass _WrappedAndVerifiedSocket(typing.NamedTuple):\n \"\"\"\n Wrapped socket and whether the connection is\n verified after the TLS handshake\n \"\"\"\n\n socket: ssl.SSLSocket | SSLTransport\n is_verified: bool\n\n\ndef _ssl_wrap_socket_and_match_hostname(\n sock: socket.socket,\n *,\n cert_reqs: None | str | int,\n ssl_version: None | str | int,\n ssl_minimum_version: int | None,\n ssl_maximum_version: int | None,\n cert_file: str | None,\n key_file: str | None,\n key_password: str | None,\n ca_certs: str | None,\n ca_cert_dir: str | None,\n ca_cert_data: None | str | bytes,\n assert_hostname: None | str | Literal[False],\n assert_fingerprint: str | None,\n server_hostname: str | None,\n ssl_context: ssl.SSLContext | None,\n tls_in_tls: bool = False,\n) -> _WrappedAndVerifiedSocket:\n \"\"\"Logic for constructing an SSLContext from all TLS parameters, passing\n that down into ssl_wrap_socket, and then doing certificate verification\n either via hostname or fingerprint. This function exists to guarantee\n that both proxies and targets have the same behavior when connecting via TLS.\n \"\"\"\n default_ssl_context = False\n if ssl_context is None:\n default_ssl_context = True\n context = create_urllib3_context(\n ssl_version=resolve_ssl_version(ssl_version),\n ssl_minimum_version=ssl_minimum_version,\n ssl_maximum_version=ssl_maximum_version,\n cert_reqs=resolve_cert_reqs(cert_reqs),\n )\n else:\n context = ssl_context\n\n context.verify_mode = resolve_cert_reqs(cert_reqs)\n\n # In some cases, we want to verify hostnames ourselves\n if (\n # `ssl` can't verify fingerprints or alternate hostnames\n assert_fingerprint\n or assert_hostname\n # assert_hostname can be set to False to disable hostname checking\n or assert_hostname is False\n # We still support OpenSSL 1.0.2, which prevents us from verifying\n # hostnames easily: https://github.com/pyca/pyopenssl/pull/933"},"next_line":{"kind":"string","value":" or ssl_.IS_PYOPENSSL"},"gold_snippet_index":{"kind":"number","value":18,"string":"18"},"created_at":{"kind":"string","value":"2023-12-16 04:12:01+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5680,"cells":{"repo_name":{"kind":"string","value":"YaoFANGUK/video-subtitle-remover"},"file_path":{"kind":"string","value":"backend/scenedetect/scene_manager.py"},"context":{"kind":"list like","value":[{"identifier":"SimpleTableCell","path":"backend/scenedetect/_thirdparty/simpletable.py","snippet":"class SimpleTableCell(object):\n \"\"\"A table class to create table cells.\n\n Example:\n cell = SimpleTableCell('Hello, world!')\n \"\"\"\n\n def __init__(self, text, header=False):\n \"\"\"Table cell constructor.\n\n Keyword arguments:\n text -- text to be displayed\n header -- flag to indicate this cell is a header cell.\n \"\"\"\n self.text = text\n self.header = header\n\n def __str__(self):\n \"\"\"Return the HTML code for the table cell.\"\"\"\n if self.header:\n return '<th>%s</th>' % (self.text)\n else:\n return '<td>%s</td>' % (self.text)"},{"identifier":"SimpleTableImage","path":"backend/scenedetect/_thirdparty/simpletable.py","snippet":"class SimpleTableImage(object):\n \"\"\"A table class to create table cells with an image.\n\n Example:\n cell = SimpleTableImage('images/image_1.jpg')\n \"\"\"\n\n def __init__(self, image_file, width=None, height=None):\n \"\"\"Table cell constructor.\n\n Keyword arguments:\n image_file -- relative filepath to image file to display.\n width -- (optional) width of the image in pixels\n height -- (optional) height of the image in pixels\n \"\"\"\n self.image_file = image_file\n if width:\n self.width = round(width)\n else:\n self.width = width\n if height:\n self.height = round(height)\n else:\n self.height = height\n\n def __str__(self):\n \"\"\"Return the HTML code for the table cell with the image.\"\"\"\n safe_filename = quote(self.image_file)\n output = '<a href=\"%s\" target=\"_blank\">' % (safe_filename)\n output += '<img src=\"%s\"' % (safe_filename)\n if self.height:\n output += ' height=\"%s\"' % (self.height)\n if self.width:\n output += ' width=\"%s\"' % (self.width)\n output += '></a>'\n\n return output"},{"identifier":"SimpleTableRow","path":"backend/scenedetect/_thirdparty/simpletable.py","snippet":"class SimpleTableRow(object):\n \"\"\"A table class to create table rows, populated by table cells.\n\n Example:\n # Row from list\n row = SimpleTableRow(['Hello,', 'world!'])\n\n # Row from SimpleTableCell\n cell1 = SimpleTableCell('Hello,')\n cell2 = SimpleTableCell('world!')\n row = SimpleTableRow([cell1, cell2])\n \"\"\"\n\n def __init__(self, cells=None, header=False):\n \"\"\"Table row constructor.\n\n Keyword arguments:\n cells -- iterable of SimpleTableCell (default None)\n header -- flag to indicate this row is a header row.\n if the cells are SimpleTableCell, it is the programmer's\n responsibility to verify whether it was created with the\n header flag set to True.\n \"\"\"\n cells = cells or []\n if isinstance(cells[0], SimpleTableCell):\n self.cells = cells\n else:\n self.cells = [SimpleTableCell(cell, header=header) for cell in cells]\n\n self.header = header\n\n def __str__(self):\n \"\"\"Return the HTML code for the table row and its cells as a string.\"\"\"\n row = []\n\n row.append('<tr>')\n\n for cell in self.cells:\n row.append(str(cell))\n\n row.append('</tr>')\n\n return '\\n'.join(row)\n\n def __iter__(self):\n \"\"\"Iterate through row cells\"\"\"\n for cell in self.cells:\n yield cell\n\n def add_cell(self, cell):\n \"\"\"Add a SimpleTableCell object to the list of cells.\"\"\"\n self.cells.append(cell)\n\n def add_cells(self, cells):\n \"\"\"Add a list of SimpleTableCell objects to the list of cells.\"\"\"\n for cell in cells:\n self.cells.append(cell)"},{"identifier":"SimpleTable","path":"backend/scenedetect/_thirdparty/simpletable.py","snippet":"class SimpleTable(object):\n \"\"\"A table class to create HTML tables, populated by HTML table rows.\n\n Example:\n # Table from lists\n table = SimpleTable([['Hello,', 'world!'], ['How', 'are', 'you?']])\n\n # Table with header row\n table = SimpleTable([['Hello,', 'world!'], ['How', 'are', 'you?']],\n header_row=['Header1', 'Header2', 'Header3'])\n\n # Table from SimpleTableRow\n rows = SimpleTableRow(['Hello,', 'world!'])\n table = SimpleTable(rows)\n \"\"\"\n\n def __init__(self, rows=None, header_row=None, css_class=None):\n \"\"\"Table constructor.\n\n Keyword arguments:\n rows -- iterable of SimpleTableRow\n header_row -- row that will be displayed at the beginning of the table.\n if this row is SimpleTableRow, it is the programmer's\n responsibility to verify whether it was created with the\n header flag set to True.\n css_class -- table CSS class\n \"\"\"\n rows = rows or []\n if isinstance(rows[0], SimpleTableRow):\n self.rows = rows\n else:\n self.rows = [SimpleTableRow(row) for row in rows]\n\n if header_row is None:\n self.header_row = None\n elif isinstance(header_row, SimpleTableRow):\n self.header_row = header_row\n else:\n self.header_row = SimpleTableRow(header_row, header=True)\n\n self.css_class = css_class\n\n def __str__(self):\n \"\"\"Return the HTML code for the table as a string.\"\"\"\n table = []\n\n if self.css_class:\n table.append('<table class=%s>' % self.css_class)\n else:\n table.append('<table>')\n\n if self.header_row:\n table.append(str(self.header_row))\n\n for row in self.rows:\n table.append(str(row))\n\n table.append('</table>')\n\n return '\\n'.join(table)\n\n def __iter__(self):\n \"\"\"Iterate through table rows\"\"\"\n for row in self.rows:\n yield row\n\n def add_row(self, row):\n \"\"\"Add a SimpleTableRow object to the list of rows.\"\"\"\n self.rows.append(row)\n\n def add_rows(self, rows):\n \"\"\"Add a list of SimpleTableRow objects to the list of rows.\"\"\"\n for row in rows:\n self.rows.append(row)"},{"identifier":"HTMLPage","path":"backend/scenedetect/_thirdparty/simpletable.py","snippet":"class HTMLPage(object):\n \"\"\"A class to create HTML pages containing CSS and tables.\"\"\"\n\n def __init__(self, tables=None, css=None, encoding=\"utf-8\"):\n \"\"\"HTML page constructor.\n\n Keyword arguments:\n tables -- List of SimpleTable objects\n css -- Cascading Style Sheet specification that is appended before the\n table string\n encoding -- Characters encoding. Default: UTF-8\n \"\"\"\n self.tables = tables or []\n self.css = css\n self.encoding = encoding\n\n def __str__(self):\n \"\"\"Return the HTML page as a string.\"\"\"\n page = []\n\n if self.css:\n page.append('<style type=\"text/css\">\\n%s\\n</style>' % self.css)\n\n # Set encoding\n page.append('<meta http-equiv=\"Content-Type\" content=\"text/html;'\n 'charset=%s\">' % self.encoding)\n\n for table in self.tables:\n page.append(str(table))\n page.append('<br />')\n\n return '\\n'.join(page)\n\n def __iter__(self):\n \"\"\"Iterate through tables\"\"\"\n for table in self.tables:\n yield table\n\n def save(self, filename):\n \"\"\"Save HTML page to a file using the proper encoding\"\"\"\n with codecs.open(filename, 'w', self.encoding) as outfile:\n for line in str(self):\n outfile.write(line)\n\n def add_table(self, table):\n \"\"\"Add a SimpleTable to the page list of tables\"\"\"\n self.tables.append(table)"},{"identifier":"tqdm","path":"backend/scenedetect/platform.py","snippet":"class FakeTqdmObject:\nclass FakeTqdmLoggingRedirect:\nclass CommandTooLong(Exception):\nclass Template(string.Template):\n def __init__(self, **kawrgs):\n def update(self, n=1):\n def close(self):\n def set_description(self, desc=None, refresh=True):\n def __init__(self, **kawrgs):\n def __enter__(self):\n def __exit__(self, type, value, traceback):\ndef get_cv2_imwrite_params() -> Dict[str, Union[int, None]]:\n def _get_cv2_param(param_name: str) -> Union[int, None]:\ndef get_file_name(file_path: AnyStr, include_extension=True) -> AnyStr:\ndef get_and_create_path(file_path: AnyStr, output_directory: Optional[AnyStr] = None) -> AnyStr:\ndef init_logger(log_level: int = logging.INFO,\n show_stdout: bool = False,\n log_file: Optional[str] = None):\ndef invoke_command(args: List[str]) -> int:\ndef get_ffmpeg_path() -> Optional[str]:\ndef get_ffmpeg_version() -> Optional[str]:\ndef get_mkvmerge_version() -> Optional[str]:\ndef get_system_version_info() -> str:\n INFO_TEMPLATE = '[PySceneDetect] %(message)s'\n DEBUG_TEMPLATE = '%(levelname)s: %(module)s.%(funcName)s(): %(message)s'"},{"identifier":"FrameTimecode","path":"backend/scenedetect/frame_timecode.py","snippet":"class FrameTimecode:\n \"\"\"Object for frame-based timecodes, using the video framerate to compute back and\n forth between frame number and seconds/timecode.\n\n A timecode is valid only if it complies with one of the following three types/formats:\n\n 1. Timecode as `str` in the form 'HH:MM:SS[.nnn]' (`'01:23:45'` or `'01:23:45.678'`)\n 2. Number of seconds as `float`, or `str` in form 'Ss' or 'S.SSSs' (`'2s'` or `'2.3456s'`)\n 3. Exact number of frames as `int`, or `str` in form NNNNN (`123` or `'123'`)\n \"\"\"\n\n def __init__(self,\n timecode: Union[int, float, str, 'FrameTimecode'] = None,\n fps: Union[int, float, str, 'FrameTimecode'] = None):\n \"\"\"\n Arguments:\n timecode: A frame number (int), number of seconds (float), or timecode (str in\n the form `'HH:MM:SS'` or `'HH:MM:SS.nnn'`).\n fps: The framerate or FrameTimecode to use as a time base for all arithmetic.\n Raises:\n TypeError: Thrown if either `timecode` or `fps` are unsupported types.\n ValueError: Thrown when specifying a negative timecode or framerate.\n \"\"\"\n # The following two properties are what is used to keep track of time\n # in a frame-specific manner. Note that once the framerate is set,\n # the value should never be modified (only read if required).\n # TODO(v1.0): Make these actual @properties.\n self.framerate = None\n self.frame_num = None\n\n # Copy constructor. Only the timecode argument is used in this case.\n if isinstance(timecode, FrameTimecode):\n self.framerate = timecode.framerate\n self.frame_num = timecode.frame_num\n if fps is not None:\n raise TypeError('Framerate cannot be overwritten when copying a FrameTimecode.')\n else:\n # Ensure other arguments are consistent with API.\n if fps is None:\n raise TypeError('Framerate (fps) is a required argument.')\n if isinstance(fps, FrameTimecode):\n fps = fps.framerate\n\n # Process the given framerate, if it was not already set.\n if not isinstance(fps, (int, float)):\n raise TypeError('Framerate must be of type int/float.')\n if (isinstance(fps, int) and not fps > 0) or (isinstance(fps, float)\n and not fps >= MAX_FPS_DELTA):\n raise ValueError('Framerate must be positive and greater than zero.')\n self.framerate = float(fps)\n\n # Process the timecode value, storing it as an exact number of frames.\n if isinstance(timecode, str):\n self.frame_num = self._parse_timecode_string(timecode)\n else:\n self.frame_num = self._parse_timecode_number(timecode)\n\n # TODO(v1.0): Add a `frame` property to replace the existing one and deprecate this getter.\n def get_frames(self) -> int:\n \"\"\"Get the current time/position in number of frames. This is the\n equivalent of accessing the self.frame_num property (which, along\n with the specified framerate, forms the base for all of the other\n time measurement calculations, e.g. the :meth:`get_seconds` method).\n\n If using to compare a :class:`FrameTimecode` with a frame number,\n you can do so directly against the object (e.g. ``FrameTimecode(10, 10.0) <= 10``).\n\n Returns:\n int: The current time in frames (the current frame number).\n \"\"\"\n return self.frame_num\n\n # TODO(v1.0): Add a `framerate` property to replace the existing one and deprecate this getter.\n def get_framerate(self) -> float:\n \"\"\"Get Framerate: Returns the framerate used by the FrameTimecode object.\n\n Returns:\n float: Framerate of the current FrameTimecode object, in frames per second.\n \"\"\"\n return self.framerate\n\n def equal_framerate(self, fps) -> bool:\n \"\"\"Equal Framerate: Determines if the passed framerate is equal to that of this object.\n\n Arguments:\n fps: Framerate to compare against within the precision constant defined in this module\n (see :data:`MAX_FPS_DELTA`).\n Returns:\n bool: True if passed fps matches the FrameTimecode object's framerate, False otherwise.\n\n \"\"\"\n return math.fabs(self.framerate - fps) < MAX_FPS_DELTA\n\n # TODO(v1.0): Add a `seconds` property to replace this and deprecate the existing one.\n def get_seconds(self) -> float:\n \"\"\"Get the frame's position in number of seconds.\n\n If using to compare a :class:`FrameTimecode` with a frame number,\n you can do so directly against the object (e.g. ``FrameTimecode(10, 10.0) <= 1.0``).\n\n Returns:\n float: The current time/position in seconds.\n \"\"\"\n return float(self.frame_num) / self.framerate\n\n # TODO(v1.0): Add a `timecode` property to replace this and deprecate the existing one.\n def get_timecode(self, precision: int = 3, use_rounding: bool = True) -> str:\n \"\"\"Get a formatted timecode string of the form HH:MM:SS[.nnn].\n\n Args:\n precision: The number of decimal places to include in the output ``[.nnn]``.\n use_rounding: Rounds the output to the desired precision. If False, the value\n will be truncated to the specified precision.\n\n Returns:\n str: The current time in the form ``\"HH:MM:SS[.nnn]\"``.\n \"\"\"\n # Compute hours and minutes based off of seconds, and update seconds.\n secs = self.get_seconds()\n base = 60.0 * 60.0\n hrs = int(secs / base)\n secs -= (hrs * base)\n base = 60.0\n mins = int(secs / base)\n secs -= (mins * base)\n # Convert seconds into string based on required precision.\n if precision > 0:\n if use_rounding:\n secs = round(secs, precision)\n msec = format(secs, '.%df' % precision)[-precision:]\n secs = '%02d.%s' % (int(secs), msec)\n else:\n secs = '%02d' % int(round(secs, 0)) if use_rounding else '%02d' % int(secs)\n # Return hours, minutes, and seconds as a formatted timecode string.\n return '%02d:%02d:%s' % (hrs, mins, secs)\n\n # TODO(v1.0): Add a `previous` property to replace the existing one and deprecate this getter.\n def previous_frame(self) -> 'FrameTimecode':\n \"\"\"Return a new FrameTimecode for the previous frame (or 0 if on frame 0).\"\"\"\n new_timecode = FrameTimecode(self)\n new_timecode.frame_num = max(0, new_timecode.frame_num - 1)\n return new_timecode\n\n def _seconds_to_frames(self, seconds: float) -> int:\n \"\"\"Convert the passed value seconds to the nearest number of frames using\n the current FrameTimecode object's FPS (self.framerate).\n\n Returns:\n Integer number of frames the passed number of seconds represents using\n the current FrameTimecode's framerate property.\n \"\"\"\n return round(seconds * self.framerate)\n\n def _parse_timecode_number(self, timecode: Union[int, float]) -> int:\n \"\"\" Parse a timecode number, storing it as the exact number of frames.\n Can be passed as frame number (int), seconds (float)\n\n Raises:\n TypeError, ValueError\n \"\"\"\n # Process the timecode value, storing it as an exact number of frames.\n # Exact number of frames N\n if isinstance(timecode, int):\n if timecode < 0:\n raise ValueError('Timecode frame number must be positive and greater than zero.')\n return timecode\n # Number of seconds S\n elif isinstance(timecode, float):\n if timecode < 0.0:\n raise ValueError('Timecode value must be positive and greater than zero.')\n return self._seconds_to_frames(timecode)\n # FrameTimecode\n elif isinstance(timecode, FrameTimecode):\n return timecode.frame_num\n elif timecode is None:\n raise TypeError('Timecode/frame number must be specified!')\n else:\n raise TypeError('Timecode format/type unrecognized.')\n\n def _parse_timecode_string(self, timecode_string: str) -> int:\n \"\"\"Parses a string based on the three possible forms (in timecode format,\n as an integer number of frames, or floating-point seconds, ending with 's').\n\n Requires that the `framerate` property is set before calling this method.\n Assuming a framerate of 30.0 FPS, the strings '00:05:00.000', '00:05:00',\n '9000', '300s', and '300.0s' are all possible valid values, all representing\n a period of time equal to 5 minutes, 300 seconds, or 9000 frames (at 30 FPS).\n\n Raises:\n TypeError, ValueError\n \"\"\"\n if self.framerate is None:\n raise TypeError('self.framerate must be set before calling _parse_timecode_string.')\n # Number of seconds S\n if timecode_string.endswith('s'):\n secs = timecode_string[:-1]\n if not secs.replace('.', '').isdigit():\n raise ValueError('All characters in timecode seconds string must be digits.')\n secs = float(secs)\n if secs < 0.0:\n raise ValueError('Timecode seconds value must be positive.')\n return self._seconds_to_frames(secs)\n # Exact number of frames N\n elif timecode_string.isdigit():\n timecode = int(timecode_string)\n if timecode < 0:\n raise ValueError('Timecode frame number must be positive.')\n return timecode\n # Standard timecode in string format 'HH:MM:SS[.nnn]'\n else:\n tc_val = timecode_string.split(':')\n if not (len(tc_val) == 3 and tc_val[0].isdigit() and tc_val[1].isdigit()\n and tc_val[2].replace('.', '').isdigit()):\n raise ValueError('Unrecognized or improperly formatted timecode string.')\n hrs, mins = int(tc_val[0]), int(tc_val[1])\n secs = float(tc_val[2]) if '.' in tc_val[2] else int(tc_val[2])\n if not (hrs >= 0 and mins >= 0 and secs >= 0 and mins < 60 and secs < 60):\n raise ValueError('Invalid timecode range (values outside allowed range).')\n secs += (((hrs * 60.0) + mins) * 60.0)\n return self._seconds_to_frames(secs)\n\n def __iadd__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\n if isinstance(other, int):\n self.frame_num += other\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n self.frame_num += other.frame_num\n else:\n raise ValueError('FrameTimecode instances require equal framerate for addition.')\n # Check if value to add is in number of seconds.\n elif isinstance(other, float):\n self.frame_num += self._seconds_to_frames(other)\n elif isinstance(other, str):\n self.frame_num += self._parse_timecode_string(other)\n else:\n raise TypeError('Unsupported type for performing addition with FrameTimecode.')\n if self.frame_num < 0: # Required to allow adding negative seconds/frames.\n self.frame_num = 0\n return self\n\n def __add__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\n to_return = FrameTimecode(timecode=self)\n to_return += other\n return to_return\n\n def __isub__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\n if isinstance(other, int):\n self.frame_num -= other\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n self.frame_num -= other.frame_num\n else:\n raise ValueError('FrameTimecode instances require equal framerate for subtraction.')\n # Check if value to add is in number of seconds.\n elif isinstance(other, float):\n self.frame_num -= self._seconds_to_frames(other)\n elif isinstance(other, str):\n self.frame_num -= self._parse_timecode_string(other)\n else:\n raise TypeError('Unsupported type for performing subtraction with FrameTimecode: %s' %\n type(other))\n if self.frame_num < 0:\n self.frame_num = 0\n return self\n\n def __sub__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\n to_return = FrameTimecode(timecode=self)\n to_return -= other\n return to_return\n\n def __eq__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\n if isinstance(other, int):\n return self.frame_num == other\n elif isinstance(other, float):\n return self.get_seconds() == other\n elif isinstance(other, str):\n return self.frame_num == self._parse_timecode_string(other)\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n return self.frame_num == other.frame_num\n else:\n raise TypeError(\n 'FrameTimecode objects must have the same framerate to be compared.')\n elif other is None:\n return False\n else:\n raise TypeError('Unsupported type for performing == with FrameTimecode: %s' %\n type(other))\n\n def __ne__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\n return not self == other\n\n def __lt__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\n if isinstance(other, int):\n return self.frame_num < other\n elif isinstance(other, float):\n return self.get_seconds() < other\n elif isinstance(other, str):\n return self.frame_num < self._parse_timecode_string(other)\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n return self.frame_num < other.frame_num\n else:\n raise TypeError(\n 'FrameTimecode objects must have the same framerate to be compared.')\n else:\n raise TypeError('Unsupported type for performing < with FrameTimecode: %s' %\n type(other))\n\n def __le__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\n if isinstance(other, int):\n return self.frame_num <= other\n elif isinstance(other, float):\n return self.get_seconds() <= other\n elif isinstance(other, str):\n return self.frame_num <= self._parse_timecode_string(other)\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n return self.frame_num <= other.frame_num\n else:\n raise TypeError(\n 'FrameTimecode objects must have the same framerate to be compared.')\n else:\n raise TypeError('Unsupported type for performing <= with FrameTimecode: %s' %\n type(other))\n\n def __gt__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\n if isinstance(other, int):\n return self.frame_num > other\n elif isinstance(other, float):\n return self.get_seconds() > other\n elif isinstance(other, str):\n return self.frame_num > self._parse_timecode_string(other)\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n return self.frame_num > other.frame_num\n else:\n raise TypeError(\n 'FrameTimecode objects must have the same framerate to be compared.')\n else:\n raise TypeError('Unsupported type for performing > with FrameTimecode: %s' %\n type(other))\n\n def __ge__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\n if isinstance(other, int):\n return self.frame_num >= other\n elif isinstance(other, float):\n return self.get_seconds() >= other\n elif isinstance(other, str):\n return self.frame_num >= self._parse_timecode_string(other)\n elif isinstance(other, FrameTimecode):\n if self.equal_framerate(other.framerate):\n return self.frame_num >= other.frame_num\n else:\n raise TypeError(\n 'FrameTimecode objects must have the same framerate to be compared.')\n else:\n raise TypeError('Unsupported type for performing >= with FrameTimecode: %s' %\n type(other))\n\n # TODO(v1.0): __int__ and __float__ should be removed. Mark as deprecated, and indicate\n # need to use relevant property instead.\n\n def __int__(self) -> int:\n return self.frame_num\n\n def __float__(self) -> float:\n return self.get_seconds()\n\n def __str__(self) -> str:\n return self.get_timecode()\n\n def __repr__(self) -> str:\n return '%s [frame=%d, fps=%.3f]' % (self.get_timecode(), self.frame_num, self.framerate)\n\n def __hash__(self) -> int:\n return self.frame_num"},{"identifier":"VideoStream","path":"backend/scenedetect/video_stream.py","snippet":"class VideoStream(ABC):\n \"\"\" Interface which all video backends must implement. \"\"\"\n\n #\n # Default Implementations\n #\n\n @property\n def base_timecode(self) -> FrameTimecode:\n \"\"\"FrameTimecode object to use as a time base.\"\"\"\n return FrameTimecode(timecode=0, fps=self.frame_rate)\n\n #\n # Abstract Static Methods\n #\n\n @staticmethod\n @abstractmethod\n def BACKEND_NAME() -> str:\n \"\"\"Unique name used to identify this backend. Should be a static property in derived\n classes (`BACKEND_NAME = 'backend_identifier'`).\"\"\"\n raise NotImplementedError\n\n #\n # Abstract Properties\n #\n\n @property\n @abstractmethod\n def path(self) -> Union[bytes, str]:\n \"\"\"Video or device path.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def name(self) -> Union[bytes, str]:\n \"\"\"Name of the video, without extension, or device.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def is_seekable(self) -> bool:\n \"\"\"True if seek() is allowed, False otherwise.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def frame_rate(self) -> float:\n \"\"\"Frame rate in frames/sec.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def duration(self) -> Optional[FrameTimecode]:\n \"\"\"Duration of the stream as a FrameTimecode, or None if non terminating.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def frame_size(self) -> Tuple[int, int]:\n \"\"\"Size of each video frame in pixels as a tuple of (width, height).\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def aspect_ratio(self) -> float:\n \"\"\"Pixel aspect ratio as a float (1.0 represents square pixels).\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def position(self) -> FrameTimecode:\n \"\"\"Current position within stream as FrameTimecode.\n\n This can be interpreted as presentation time stamp, thus frame 1 corresponds\n to the presentation time 0. Returns 0 even if `frame_number` is 1.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def position_ms(self) -> float:\n \"\"\"Current position within stream as a float of the presentation time in\n milliseconds. The first frame has a PTS of 0.\"\"\"\n raise NotImplementedError\n\n @property\n @abstractmethod\n def frame_number(self) -> int:\n \"\"\"Current position within stream as the frame number.\n\n Will return 0 until the first frame is `read`.\"\"\"\n raise NotImplementedError\n\n #\n # Abstract Methods\n #\n\n @abstractmethod\n def read(self, decode: bool = True, advance: bool = True) -> Union[ndarray, bool]:\n \"\"\"Read and decode the next frame as a numpy.ndarray. Returns False when video ends.\n\n Arguments:\n decode: Decode and return the frame.\n advance: Seek to the next frame. If False, will return the current (last) frame.\n\n Returns:\n If decode = True, the decoded frame (numpy.ndarray), or False (bool) if end of video.\n If decode = False, a bool indicating if advancing to the the next frame succeeded.\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def reset(self) -> None:\n \"\"\" Close and re-open the VideoStream (equivalent to seeking back to beginning). \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def seek(self, target: Union[FrameTimecode, float, int]) -> None:\n \"\"\"Seek to the given timecode. If given as a frame number, represents the current seek\n pointer (e.g. if seeking to 0, the next frame decoded will be the first frame of the video).\n\n For 1-based indices (first frame is frame #1), the target frame number needs to be converted\n to 0-based by subtracting one. For example, if we want to seek to the first frame, we call\n seek(0) followed by read(). If we want to seek to the 5th frame, we call seek(4) followed\n by read(), at which point frame_number will be 5.\n\n May not be supported on all backend types or inputs (e.g. cameras).\n\n Arguments:\n target: Target position in video stream to seek to.\n If float, interpreted as time in seconds.\n If int, interpreted as frame number.\n Raises:\n SeekError: An error occurs while seeking, or seeking is not supported.\n ValueError: `target` is not a valid value (i.e. it is negative).\n \"\"\"\n raise NotImplementedError"},{"identifier":"SceneDetector","path":"backend/scenedetect/scene_detector.py","snippet":"class SceneDetector:\n \"\"\" Base class to inherit from when implementing a scene detection algorithm.\n\n This API is not yet stable and subject to change.\n\n This represents a \"dense\" scene detector, which returns a list of frames where\n the next scene/shot begins in a video.\n\n Also see the implemented scene detectors in the scenedetect.detectors module\n to get an idea of how a particular detector can be created.\n \"\"\"\n # TODO(v0.7): Make this a proper abstract base class.\n\n stats_manager: Optional[StatsManager] = None\n \"\"\"Optional :class:`StatsManager <scenedetect.stats_manager.StatsManager>` to\n use for caching frame metrics to and from.\"\"\"\n\n # TODO(v1.0): Remove - this is a rarely used case for what is now a neglegible performance gain.\n def is_processing_required(self, frame_num: int) -> bool:\n \"\"\"[DEPRECATED] DO NOT USE\n\n Test if all calculations for a given frame are already done.\n\n Returns:\n False if the SceneDetector has assigned _metric_keys, and the\n stats_manager property is set to a valid StatsManager object containing\n the required frame metrics/calculations for the given frame - thus, not\n needing the frame to perform scene detection.\n\n True otherwise (i.e. the frame_img passed to process_frame is required\n to be passed to process_frame for the given frame_num).\n \"\"\"\n metric_keys = self.get_metrics()\n return not metric_keys or not (self.stats_manager is not None\n and self.stats_manager.metrics_exist(frame_num, metric_keys))\n\n def stats_manager_required(self) -> bool:\n \"\"\"Stats Manager Required: Prototype indicating if detector requires stats.\n\n Returns:\n True if a StatsManager is required for the detector, False otherwise.\n \"\"\"\n return False\n\n def get_metrics(self) -> List[str]:\n \"\"\"Get Metrics: Get a list of all metric names/keys used by the detector.\n\n Returns:\n List of strings of frame metric key names that will be used by\n the detector when a StatsManager is passed to process_frame.\n \"\"\"\n return []\n\n def process_frame(self, frame_num: int, frame_img: Optional[numpy.ndarray]) -> List[int]:\n \"\"\"Process Frame: Computes/stores metrics and detects any scene changes.\n\n Prototype method, no actual detection.\n\n Returns:\n List of frame numbers of cuts to be added to the cutting list.\n \"\"\"\n return []\n\n def post_process(self, frame_num: int) -> List[int]:\n \"\"\"Post Process: Performs any processing after the last frame has been read.\n\n Prototype method, no actual detection.\n\n Returns:\n List of frame numbers of cuts to be added to the cutting list.\n \"\"\"\n return []\n\n @property\n def event_buffer_length(self) -> int:\n \"\"\"The amount of frames a given event can be buffered for, in time. Represents maximum\n amount any event can be behind `frame_number` in the result of :meth:`process_frame`.\n \"\"\"\n return 0"},{"identifier":"SparseSceneDetector","path":"backend/scenedetect/scene_detector.py","snippet":"class SparseSceneDetector(SceneDetector):\n \"\"\"Base class to inherit from when implementing a sparse scene detection algorithm.\n\n This class will be removed in v1.0 and should not be used.\n\n Unlike dense detectors, sparse detectors scene_detect \"events\" and return a *pair* of frames,\n as opposed to just a single cut.\n\n An example of a SparseSceneDetector is the MotionDetector.\n \"\"\"\n\n def process_frame(self, frame_num: int, frame_img: numpy.ndarray) -> List[Tuple[int, int]]:\n \"\"\"Process Frame: Computes/stores metrics and detects any scene changes.\n\n Prototype method, no actual detection.\n\n Returns:\n List of frame pairs representing individual scenes\n to be added to the output scene list directly.\n \"\"\"\n return []\n\n def post_process(self, frame_num: int) -> List[Tuple[int, int]]:\n \"\"\"Post Process: Performs any processing after the last frame has been read.\n\n Prototype method, no actual detection.\n\n Returns:\n List of frame pairs representing individual scenes\n to be added to the output scene list directly.\n \"\"\"\n return []"},{"identifier":"StatsManager","path":"backend/scenedetect/stats_manager.py","snippet":"class StatsManager:\n \"\"\"Provides a key-value store for frame metrics/calculations which can be used\n for two-pass detection algorithms, as well as saving stats to a CSV file.\n\n Analyzing a statistics CSV file is also very useful for finding the optimal\n algorithm parameters for certain detection methods. Additionally, the data\n may be plotted by a graphing module (e.g. matplotlib) by obtaining the\n metric of interest for a series of frames by iteratively calling get_metrics(),\n after having called the detect_scenes(...) method on the SceneManager object\n which owns the given StatsManager instance.\n\n Only metrics consisting of `float` or `int` should be used currently.\n \"\"\"\n\n def __init__(self, base_timecode: FrameTimecode = None):\n \"\"\"Initialize a new StatsManager.\n\n Arguments:\n base_timecode: Timecode associated with this object. Must not be None (default value\n will be removed in a future release).\n \"\"\"\n # Frame metrics is a dict of frame (int): metric_dict (Dict[str, float])\n # of each frame metric key and the value it represents (usually float).\n self._frame_metrics: Dict[FrameTimecode, Dict[str, float]] = dict()\n self._registered_metrics: Set[str] = set() # Set of frame metric keys.\n self._loaded_metrics: Set[str] = set() # Metric keys loaded from stats file.\n self._metrics_updated: bool = False # Flag indicating if metrics require saving.\n self._base_timecode: Optional[FrameTimecode] = base_timecode # Used for timing calculations.\n\n def register_metrics(self, metric_keys: Iterable[str]) -> None:\n \"\"\"Register a list of metric keys that will be used by the detector.\n\n Used to ensure that multiple detector keys don't overlap.\n\n Raises:\n FrameMetricRegistered: A particular metric_key has already been registered/added\n to the StatsManager. Only if the StatsManager is being used for read-only\n access (i.e. all frames in the video have already been processed for the given\n metric_key in the exception) is this behavior desirable.\n \"\"\"\n for metric_key in metric_keys:\n if metric_key not in self._registered_metrics:\n self._registered_metrics.add(metric_key)\n else:\n raise FrameMetricRegistered(metric_key)\n\n # TODO(v1.0): Change frame_number to a FrameTimecode now that it is just a hash and will\n # be required for VFR support.\n def get_metrics(self, frame_number: int, metric_keys: Iterable[str]) -> List[Any]:\n \"\"\"Return the requested statistics/metrics for a given frame.\n\n Arguments:\n frame_number (int): Frame number to retrieve metrics for.\n metric_keys (List[str]): A list of metric keys to look up.\n\n Returns:\n A list containing the requested frame metrics for the given frame number\n in the same order as the input list of metric keys. If a metric could\n not be found, None is returned for that particular metric.\n \"\"\"\n return [self._get_metric(frame_number, metric_key) for metric_key in metric_keys]\n\n def set_metrics(self, frame_number: int, metric_kv_dict: Dict[str, Any]) -> None:\n \"\"\" Set Metrics: Sets the provided statistics/metrics for a given frame.\n\n Arguments:\n frame_number: Frame number to retrieve metrics for.\n metric_kv_dict: A dict mapping metric keys to the\n respective integer/floating-point metric values to set.\n \"\"\"\n for metric_key in metric_kv_dict:\n self._set_metric(frame_number, metric_key, metric_kv_dict[metric_key])\n\n def metrics_exist(self, frame_number: int, metric_keys: Iterable[str]) -> bool:\n \"\"\" Metrics Exist: Checks if the given metrics/stats exist for the given frame.\n\n Returns:\n bool: True if the given metric keys exist for the frame, False otherwise.\n \"\"\"\n return all([self._metric_exists(frame_number, metric_key) for metric_key in metric_keys])\n\n def is_save_required(self) -> bool:\n \"\"\" Is Save Required: Checks if the stats have been updated since loading.\n\n Returns:\n bool: True if there are frame metrics/statistics not yet written to disk,\n False otherwise.\n \"\"\"\n return self._metrics_updated\n\n def save_to_csv(self,\n csv_file: Union[str, bytes, TextIO],\n base_timecode: Optional[FrameTimecode] = None,\n force_save=True) -> None:\n \"\"\" Save To CSV: Saves all frame metrics stored in the StatsManager to a CSV file.\n\n Arguments:\n csv_file: A file handle opened in write mode (e.g. open('...', 'w')) or a path as str.\n base_timecode: [DEPRECATED] DO NOT USE. For backwards compatibility.\n force_save: If True, writes metrics out even if an update is not required.\n\n Raises:\n OSError: If `path` cannot be opened or a write failure occurs.\n \"\"\"\n # TODO(v0.7): Replace with DeprecationWarning that `base_timecode` will be removed in v0.8.\n if base_timecode is not None:\n logger.error('base_timecode is deprecated.')\n\n # Ensure we need to write to the file, and that we have data to do so with.\n if not ((self.is_save_required() or force_save) and self._registered_metrics\n and self._frame_metrics):\n logger.info(\"No metrics to save.\")\n return\n\n assert self._base_timecode is not None\n\n # If we get a path instead of an open file handle, recursively call ourselves\n # again but with file handle instead of path.\n if isinstance(csv_file, (str, bytes)):\n with open(csv_file, 'w') as file:\n self.save_to_csv(csv_file=file, force_save=force_save)\n return\n\n csv_writer = csv.writer(csv_file, lineterminator='\\n')\n metric_keys = sorted(list(self._registered_metrics.union(self._loaded_metrics)))\n csv_writer.writerow([COLUMN_NAME_FRAME_NUMBER, COLUMN_NAME_TIMECODE] + metric_keys)\n frame_keys = sorted(self._frame_metrics.keys())\n logger.info(\"Writing %d frames to CSV...\", len(frame_keys))\n for frame_key in frame_keys:\n frame_timecode = self._base_timecode + frame_key\n csv_writer.writerow(\n [frame_timecode.get_frames() +\n 1, frame_timecode.get_timecode()] +\n [str(metric) for metric in self.get_metrics(frame_key, metric_keys)])\n\n @staticmethod\n def valid_header(row: List[str]) -> bool:\n \"\"\"Check that the given CSV row is a valid header for a statsfile.\n\n Arguments:\n row: A row decoded from the CSV reader.\n\n Returns:\n True if `row` is a valid statsfile header, False otherwise.\n \"\"\"\n if not row or not len(row) >= 2:\n return False\n if row[0] != COLUMN_NAME_FRAME_NUMBER or row[1] != COLUMN_NAME_TIMECODE:\n return False\n return True\n\n # TODO(v1.0): Remove.\n def load_from_csv(self, csv_file: Union[str, bytes, TextIO]) -> Optional[int]:\n \"\"\"[DEPRECATED] DO NOT USE\n\n Load all metrics stored in a CSV file into the StatsManager instance. Will be removed in a\n future release after becoming a no-op.\n\n Arguments:\n csv_file: A file handle opened in read mode (e.g. open('...', 'r')) or a path as str.\n\n Returns:\n int or None: Number of frames/rows read from the CSV file, or None if the\n input file was blank or could not be found.\n\n Raises:\n StatsFileCorrupt: Stats file is corrupt and can't be loaded, or wrong file\n was specified.\n \"\"\"\n # TODO: Make this an error, then make load_from_csv() a no-op, and finally, remove it.\n logger.warning(\"load_from_csv() is deprecated and will be removed in a future release.\")\n\n # If we get a path instead of an open file handle, check that it exists, and if so,\n # recursively call ourselves again but with file set instead of path.\n if isinstance(csv_file, (str, bytes)):\n if os.path.exists(csv_file):\n with open(csv_file, 'r') as file:\n return self.load_from_csv(csv_file=file)\n # Path doesn't exist.\n return None\n\n # If we get here, file is a valid file handle in read-only text mode.\n csv_reader = csv.reader(csv_file, lineterminator='\\n')\n num_cols = None\n num_metrics = None\n num_frames = None\n # First Row: Frame Num, Timecode, [metrics...]\n try:\n row = next(csv_reader)\n # Backwards compatibility for previous versions of statsfile\n # which included an additional header row.\n if not self.valid_header(row):\n row = next(csv_reader)\n except StopIteration:\n # If the file is blank or we couldn't decode anything, assume the file was empty.\n return None\n if not self.valid_header(row):\n raise StatsFileCorrupt()\n num_cols = len(row)\n num_metrics = num_cols - 2\n if not num_metrics > 0:\n raise StatsFileCorrupt('No metrics defined in CSV file.')\n self._loaded_metrics = row[2:]\n num_frames = 0\n for row in csv_reader:\n metric_dict = {}\n if not len(row) == num_cols:\n raise StatsFileCorrupt('Wrong number of columns detected in stats file row.')\n for i, metric_str in enumerate(row[2:]):\n if metric_str and metric_str != 'None':\n try:\n metric_dict[self._loaded_metrics[i]] = float(metric_str)\n except ValueError:\n raise StatsFileCorrupt('Corrupted value in stats file: %s' %\n metric_str) from ValueError\n frame_number = int(row[0])\n # Switch from 1-based to 0-based frame numbers.\n if frame_number > 0:\n frame_number -= 1\n self.set_metrics(frame_number, metric_dict)\n num_frames += 1\n logger.info('Loaded %d metrics for %d frames.', num_metrics, num_frames)\n self._metrics_updated = False\n return num_frames\n\n def _get_metric(self, frame_number: int, metric_key: str) -> Optional[Any]:\n if self._metric_exists(frame_number, metric_key):\n return self._frame_metrics[frame_number][metric_key]\n return None\n\n def _set_metric(self, frame_number: int, metric_key: str, metric_value: Any) -> None:\n self._metrics_updated = True\n if not frame_number in self._frame_metrics:\n self._frame_metrics[frame_number] = dict()\n self._frame_metrics[frame_number][metric_key] = metric_value\n\n def _metric_exists(self, frame_number: int, metric_key: str) -> bool:\n return (frame_number in self._frame_metrics\n and metric_key in self._frame_metrics[frame_number])"},{"identifier":"FrameMetricRegistered","path":"backend/scenedetect/stats_manager.py","snippet":"class FrameMetricRegistered(Exception):\n \"\"\" Raised when attempting to register a frame metric key which has\n already been registered. \"\"\"\n\n def __init__(self,\n metric_key: str,\n message: str = \"Attempted to re-register frame metric key.\"):\n super().__init__(message)\n self.metric_key = metric_key"}],"string":"[\n {\n \"identifier\": \"SimpleTableCell\",\n \"path\": \"backend/scenedetect/_thirdparty/simpletable.py\",\n \"snippet\": \"class SimpleTableCell(object):\\n \\\"\\\"\\\"A table class to create table cells.\\n\\n Example:\\n cell = SimpleTableCell('Hello, world!')\\n \\\"\\\"\\\"\\n\\n def __init__(self, text, header=False):\\n \\\"\\\"\\\"Table cell constructor.\\n\\n Keyword arguments:\\n text -- text to be displayed\\n header -- flag to indicate this cell is a header cell.\\n \\\"\\\"\\\"\\n self.text = text\\n self.header = header\\n\\n def __str__(self):\\n \\\"\\\"\\\"Return the HTML code for the table cell.\\\"\\\"\\\"\\n if self.header:\\n return '<th>%s</th>' % (self.text)\\n else:\\n return '<td>%s</td>' % (self.text)\"\n },\n {\n \"identifier\": \"SimpleTableImage\",\n \"path\": \"backend/scenedetect/_thirdparty/simpletable.py\",\n \"snippet\": \"class SimpleTableImage(object):\\n \\\"\\\"\\\"A table class to create table cells with an image.\\n\\n Example:\\n cell = SimpleTableImage('images/image_1.jpg')\\n \\\"\\\"\\\"\\n\\n def __init__(self, image_file, width=None, height=None):\\n \\\"\\\"\\\"Table cell constructor.\\n\\n Keyword arguments:\\n image_file -- relative filepath to image file to display.\\n width -- (optional) width of the image in pixels\\n height -- (optional) height of the image in pixels\\n \\\"\\\"\\\"\\n self.image_file = image_file\\n if width:\\n self.width = round(width)\\n else:\\n self.width = width\\n if height:\\n self.height = round(height)\\n else:\\n self.height = height\\n\\n def __str__(self):\\n \\\"\\\"\\\"Return the HTML code for the table cell with the image.\\\"\\\"\\\"\\n safe_filename = quote(self.image_file)\\n output = '<a href=\\\"%s\\\" target=\\\"_blank\\\">' % (safe_filename)\\n output += '<img src=\\\"%s\\\"' % (safe_filename)\\n if self.height:\\n output += ' height=\\\"%s\\\"' % (self.height)\\n if self.width:\\n output += ' width=\\\"%s\\\"' % (self.width)\\n output += '></a>'\\n\\n return output\"\n },\n {\n \"identifier\": \"SimpleTableRow\",\n \"path\": \"backend/scenedetect/_thirdparty/simpletable.py\",\n \"snippet\": \"class SimpleTableRow(object):\\n \\\"\\\"\\\"A table class to create table rows, populated by table cells.\\n\\n Example:\\n # Row from list\\n row = SimpleTableRow(['Hello,', 'world!'])\\n\\n # Row from SimpleTableCell\\n cell1 = SimpleTableCell('Hello,')\\n cell2 = SimpleTableCell('world!')\\n row = SimpleTableRow([cell1, cell2])\\n \\\"\\\"\\\"\\n\\n def __init__(self, cells=None, header=False):\\n \\\"\\\"\\\"Table row constructor.\\n\\n Keyword arguments:\\n cells -- iterable of SimpleTableCell (default None)\\n header -- flag to indicate this row is a header row.\\n if the cells are SimpleTableCell, it is the programmer's\\n responsibility to verify whether it was created with the\\n header flag set to True.\\n \\\"\\\"\\\"\\n cells = cells or []\\n if isinstance(cells[0], SimpleTableCell):\\n self.cells = cells\\n else:\\n self.cells = [SimpleTableCell(cell, header=header) for cell in cells]\\n\\n self.header = header\\n\\n def __str__(self):\\n \\\"\\\"\\\"Return the HTML code for the table row and its cells as a string.\\\"\\\"\\\"\\n row = []\\n\\n row.append('<tr>')\\n\\n for cell in self.cells:\\n row.append(str(cell))\\n\\n row.append('</tr>')\\n\\n return '\\\\n'.join(row)\\n\\n def __iter__(self):\\n \\\"\\\"\\\"Iterate through row cells\\\"\\\"\\\"\\n for cell in self.cells:\\n yield cell\\n\\n def add_cell(self, cell):\\n \\\"\\\"\\\"Add a SimpleTableCell object to the list of cells.\\\"\\\"\\\"\\n self.cells.append(cell)\\n\\n def add_cells(self, cells):\\n \\\"\\\"\\\"Add a list of SimpleTableCell objects to the list of cells.\\\"\\\"\\\"\\n for cell in cells:\\n self.cells.append(cell)\"\n },\n {\n \"identifier\": \"SimpleTable\",\n \"path\": \"backend/scenedetect/_thirdparty/simpletable.py\",\n \"snippet\": \"class SimpleTable(object):\\n \\\"\\\"\\\"A table class to create HTML tables, populated by HTML table rows.\\n\\n Example:\\n # Table from lists\\n table = SimpleTable([['Hello,', 'world!'], ['How', 'are', 'you?']])\\n\\n # Table with header row\\n table = SimpleTable([['Hello,', 'world!'], ['How', 'are', 'you?']],\\n header_row=['Header1', 'Header2', 'Header3'])\\n\\n # Table from SimpleTableRow\\n rows = SimpleTableRow(['Hello,', 'world!'])\\n table = SimpleTable(rows)\\n \\\"\\\"\\\"\\n\\n def __init__(self, rows=None, header_row=None, css_class=None):\\n \\\"\\\"\\\"Table constructor.\\n\\n Keyword arguments:\\n rows -- iterable of SimpleTableRow\\n header_row -- row that will be displayed at the beginning of the table.\\n if this row is SimpleTableRow, it is the programmer's\\n responsibility to verify whether it was created with the\\n header flag set to True.\\n css_class -- table CSS class\\n \\\"\\\"\\\"\\n rows = rows or []\\n if isinstance(rows[0], SimpleTableRow):\\n self.rows = rows\\n else:\\n self.rows = [SimpleTableRow(row) for row in rows]\\n\\n if header_row is None:\\n self.header_row = None\\n elif isinstance(header_row, SimpleTableRow):\\n self.header_row = header_row\\n else:\\n self.header_row = SimpleTableRow(header_row, header=True)\\n\\n self.css_class = css_class\\n\\n def __str__(self):\\n \\\"\\\"\\\"Return the HTML code for the table as a string.\\\"\\\"\\\"\\n table = []\\n\\n if self.css_class:\\n table.append('<table class=%s>' % self.css_class)\\n else:\\n table.append('<table>')\\n\\n if self.header_row:\\n table.append(str(self.header_row))\\n\\n for row in self.rows:\\n table.append(str(row))\\n\\n table.append('</table>')\\n\\n return '\\\\n'.join(table)\\n\\n def __iter__(self):\\n \\\"\\\"\\\"Iterate through table rows\\\"\\\"\\\"\\n for row in self.rows:\\n yield row\\n\\n def add_row(self, row):\\n \\\"\\\"\\\"Add a SimpleTableRow object to the list of rows.\\\"\\\"\\\"\\n self.rows.append(row)\\n\\n def add_rows(self, rows):\\n \\\"\\\"\\\"Add a list of SimpleTableRow objects to the list of rows.\\\"\\\"\\\"\\n for row in rows:\\n self.rows.append(row)\"\n },\n {\n \"identifier\": \"HTMLPage\",\n \"path\": \"backend/scenedetect/_thirdparty/simpletable.py\",\n \"snippet\": \"class HTMLPage(object):\\n \\\"\\\"\\\"A class to create HTML pages containing CSS and tables.\\\"\\\"\\\"\\n\\n def __init__(self, tables=None, css=None, encoding=\\\"utf-8\\\"):\\n \\\"\\\"\\\"HTML page constructor.\\n\\n Keyword arguments:\\n tables -- List of SimpleTable objects\\n css -- Cascading Style Sheet specification that is appended before the\\n table string\\n encoding -- Characters encoding. Default: UTF-8\\n \\\"\\\"\\\"\\n self.tables = tables or []\\n self.css = css\\n self.encoding = encoding\\n\\n def __str__(self):\\n \\\"\\\"\\\"Return the HTML page as a string.\\\"\\\"\\\"\\n page = []\\n\\n if self.css:\\n page.append('<style type=\\\"text/css\\\">\\\\n%s\\\\n</style>' % self.css)\\n\\n # Set encoding\\n page.append('<meta http-equiv=\\\"Content-Type\\\" content=\\\"text/html;'\\n 'charset=%s\\\">' % self.encoding)\\n\\n for table in self.tables:\\n page.append(str(table))\\n page.append('<br />')\\n\\n return '\\\\n'.join(page)\\n\\n def __iter__(self):\\n \\\"\\\"\\\"Iterate through tables\\\"\\\"\\\"\\n for table in self.tables:\\n yield table\\n\\n def save(self, filename):\\n \\\"\\\"\\\"Save HTML page to a file using the proper encoding\\\"\\\"\\\"\\n with codecs.open(filename, 'w', self.encoding) as outfile:\\n for line in str(self):\\n outfile.write(line)\\n\\n def add_table(self, table):\\n \\\"\\\"\\\"Add a SimpleTable to the page list of tables\\\"\\\"\\\"\\n self.tables.append(table)\"\n },\n {\n \"identifier\": \"tqdm\",\n \"path\": \"backend/scenedetect/platform.py\",\n \"snippet\": \"class FakeTqdmObject:\\nclass FakeTqdmLoggingRedirect:\\nclass CommandTooLong(Exception):\\nclass Template(string.Template):\\n def __init__(self, **kawrgs):\\n def update(self, n=1):\\n def close(self):\\n def set_description(self, desc=None, refresh=True):\\n def __init__(self, **kawrgs):\\n def __enter__(self):\\n def __exit__(self, type, value, traceback):\\ndef get_cv2_imwrite_params() -> Dict[str, Union[int, None]]:\\n def _get_cv2_param(param_name: str) -> Union[int, None]:\\ndef get_file_name(file_path: AnyStr, include_extension=True) -> AnyStr:\\ndef get_and_create_path(file_path: AnyStr, output_directory: Optional[AnyStr] = None) -> AnyStr:\\ndef init_logger(log_level: int = logging.INFO,\\n show_stdout: bool = False,\\n log_file: Optional[str] = None):\\ndef invoke_command(args: List[str]) -> int:\\ndef get_ffmpeg_path() -> Optional[str]:\\ndef get_ffmpeg_version() -> Optional[str]:\\ndef get_mkvmerge_version() -> Optional[str]:\\ndef get_system_version_info() -> str:\\n INFO_TEMPLATE = '[PySceneDetect] %(message)s'\\n DEBUG_TEMPLATE = '%(levelname)s: %(module)s.%(funcName)s(): %(message)s'\"\n },\n {\n \"identifier\": \"FrameTimecode\",\n \"path\": \"backend/scenedetect/frame_timecode.py\",\n \"snippet\": \"class FrameTimecode:\\n \\\"\\\"\\\"Object for frame-based timecodes, using the video framerate to compute back and\\n forth between frame number and seconds/timecode.\\n\\n A timecode is valid only if it complies with one of the following three types/formats:\\n\\n 1. Timecode as `str` in the form 'HH:MM:SS[.nnn]' (`'01:23:45'` or `'01:23:45.678'`)\\n 2. Number of seconds as `float`, or `str` in form 'Ss' or 'S.SSSs' (`'2s'` or `'2.3456s'`)\\n 3. Exact number of frames as `int`, or `str` in form NNNNN (`123` or `'123'`)\\n \\\"\\\"\\\"\\n\\n def __init__(self,\\n timecode: Union[int, float, str, 'FrameTimecode'] = None,\\n fps: Union[int, float, str, 'FrameTimecode'] = None):\\n \\\"\\\"\\\"\\n Arguments:\\n timecode: A frame number (int), number of seconds (float), or timecode (str in\\n the form `'HH:MM:SS'` or `'HH:MM:SS.nnn'`).\\n fps: The framerate or FrameTimecode to use as a time base for all arithmetic.\\n Raises:\\n TypeError: Thrown if either `timecode` or `fps` are unsupported types.\\n ValueError: Thrown when specifying a negative timecode or framerate.\\n \\\"\\\"\\\"\\n # The following two properties are what is used to keep track of time\\n # in a frame-specific manner. Note that once the framerate is set,\\n # the value should never be modified (only read if required).\\n # TODO(v1.0): Make these actual @properties.\\n self.framerate = None\\n self.frame_num = None\\n\\n # Copy constructor. Only the timecode argument is used in this case.\\n if isinstance(timecode, FrameTimecode):\\n self.framerate = timecode.framerate\\n self.frame_num = timecode.frame_num\\n if fps is not None:\\n raise TypeError('Framerate cannot be overwritten when copying a FrameTimecode.')\\n else:\\n # Ensure other arguments are consistent with API.\\n if fps is None:\\n raise TypeError('Framerate (fps) is a required argument.')\\n if isinstance(fps, FrameTimecode):\\n fps = fps.framerate\\n\\n # Process the given framerate, if it was not already set.\\n if not isinstance(fps, (int, float)):\\n raise TypeError('Framerate must be of type int/float.')\\n if (isinstance(fps, int) and not fps > 0) or (isinstance(fps, float)\\n and not fps >= MAX_FPS_DELTA):\\n raise ValueError('Framerate must be positive and greater than zero.')\\n self.framerate = float(fps)\\n\\n # Process the timecode value, storing it as an exact number of frames.\\n if isinstance(timecode, str):\\n self.frame_num = self._parse_timecode_string(timecode)\\n else:\\n self.frame_num = self._parse_timecode_number(timecode)\\n\\n # TODO(v1.0): Add a `frame` property to replace the existing one and deprecate this getter.\\n def get_frames(self) -> int:\\n \\\"\\\"\\\"Get the current time/position in number of frames. This is the\\n equivalent of accessing the self.frame_num property (which, along\\n with the specified framerate, forms the base for all of the other\\n time measurement calculations, e.g. the :meth:`get_seconds` method).\\n\\n If using to compare a :class:`FrameTimecode` with a frame number,\\n you can do so directly against the object (e.g. ``FrameTimecode(10, 10.0) <= 10``).\\n\\n Returns:\\n int: The current time in frames (the current frame number).\\n \\\"\\\"\\\"\\n return self.frame_num\\n\\n # TODO(v1.0): Add a `framerate` property to replace the existing one and deprecate this getter.\\n def get_framerate(self) -> float:\\n \\\"\\\"\\\"Get Framerate: Returns the framerate used by the FrameTimecode object.\\n\\n Returns:\\n float: Framerate of the current FrameTimecode object, in frames per second.\\n \\\"\\\"\\\"\\n return self.framerate\\n\\n def equal_framerate(self, fps) -> bool:\\n \\\"\\\"\\\"Equal Framerate: Determines if the passed framerate is equal to that of this object.\\n\\n Arguments:\\n fps: Framerate to compare against within the precision constant defined in this module\\n (see :data:`MAX_FPS_DELTA`).\\n Returns:\\n bool: True if passed fps matches the FrameTimecode object's framerate, False otherwise.\\n\\n \\\"\\\"\\\"\\n return math.fabs(self.framerate - fps) < MAX_FPS_DELTA\\n\\n # TODO(v1.0): Add a `seconds` property to replace this and deprecate the existing one.\\n def get_seconds(self) -> float:\\n \\\"\\\"\\\"Get the frame's position in number of seconds.\\n\\n If using to compare a :class:`FrameTimecode` with a frame number,\\n you can do so directly against the object (e.g. ``FrameTimecode(10, 10.0) <= 1.0``).\\n\\n Returns:\\n float: The current time/position in seconds.\\n \\\"\\\"\\\"\\n return float(self.frame_num) / self.framerate\\n\\n # TODO(v1.0): Add a `timecode` property to replace this and deprecate the existing one.\\n def get_timecode(self, precision: int = 3, use_rounding: bool = True) -> str:\\n \\\"\\\"\\\"Get a formatted timecode string of the form HH:MM:SS[.nnn].\\n\\n Args:\\n precision: The number of decimal places to include in the output ``[.nnn]``.\\n use_rounding: Rounds the output to the desired precision. If False, the value\\n will be truncated to the specified precision.\\n\\n Returns:\\n str: The current time in the form ``\\\"HH:MM:SS[.nnn]\\\"``.\\n \\\"\\\"\\\"\\n # Compute hours and minutes based off of seconds, and update seconds.\\n secs = self.get_seconds()\\n base = 60.0 * 60.0\\n hrs = int(secs / base)\\n secs -= (hrs * base)\\n base = 60.0\\n mins = int(secs / base)\\n secs -= (mins * base)\\n # Convert seconds into string based on required precision.\\n if precision > 0:\\n if use_rounding:\\n secs = round(secs, precision)\\n msec = format(secs, '.%df' % precision)[-precision:]\\n secs = '%02d.%s' % (int(secs), msec)\\n else:\\n secs = '%02d' % int(round(secs, 0)) if use_rounding else '%02d' % int(secs)\\n # Return hours, minutes, and seconds as a formatted timecode string.\\n return '%02d:%02d:%s' % (hrs, mins, secs)\\n\\n # TODO(v1.0): Add a `previous` property to replace the existing one and deprecate this getter.\\n def previous_frame(self) -> 'FrameTimecode':\\n \\\"\\\"\\\"Return a new FrameTimecode for the previous frame (or 0 if on frame 0).\\\"\\\"\\\"\\n new_timecode = FrameTimecode(self)\\n new_timecode.frame_num = max(0, new_timecode.frame_num - 1)\\n return new_timecode\\n\\n def _seconds_to_frames(self, seconds: float) -> int:\\n \\\"\\\"\\\"Convert the passed value seconds to the nearest number of frames using\\n the current FrameTimecode object's FPS (self.framerate).\\n\\n Returns:\\n Integer number of frames the passed number of seconds represents using\\n the current FrameTimecode's framerate property.\\n \\\"\\\"\\\"\\n return round(seconds * self.framerate)\\n\\n def _parse_timecode_number(self, timecode: Union[int, float]) -> int:\\n \\\"\\\"\\\" Parse a timecode number, storing it as the exact number of frames.\\n Can be passed as frame number (int), seconds (float)\\n\\n Raises:\\n TypeError, ValueError\\n \\\"\\\"\\\"\\n # Process the timecode value, storing it as an exact number of frames.\\n # Exact number of frames N\\n if isinstance(timecode, int):\\n if timecode < 0:\\n raise ValueError('Timecode frame number must be positive and greater than zero.')\\n return timecode\\n # Number of seconds S\\n elif isinstance(timecode, float):\\n if timecode < 0.0:\\n raise ValueError('Timecode value must be positive and greater than zero.')\\n return self._seconds_to_frames(timecode)\\n # FrameTimecode\\n elif isinstance(timecode, FrameTimecode):\\n return timecode.frame_num\\n elif timecode is None:\\n raise TypeError('Timecode/frame number must be specified!')\\n else:\\n raise TypeError('Timecode format/type unrecognized.')\\n\\n def _parse_timecode_string(self, timecode_string: str) -> int:\\n \\\"\\\"\\\"Parses a string based on the three possible forms (in timecode format,\\n as an integer number of frames, or floating-point seconds, ending with 's').\\n\\n Requires that the `framerate` property is set before calling this method.\\n Assuming a framerate of 30.0 FPS, the strings '00:05:00.000', '00:05:00',\\n '9000', '300s', and '300.0s' are all possible valid values, all representing\\n a period of time equal to 5 minutes, 300 seconds, or 9000 frames (at 30 FPS).\\n\\n Raises:\\n TypeError, ValueError\\n \\\"\\\"\\\"\\n if self.framerate is None:\\n raise TypeError('self.framerate must be set before calling _parse_timecode_string.')\\n # Number of seconds S\\n if timecode_string.endswith('s'):\\n secs = timecode_string[:-1]\\n if not secs.replace('.', '').isdigit():\\n raise ValueError('All characters in timecode seconds string must be digits.')\\n secs = float(secs)\\n if secs < 0.0:\\n raise ValueError('Timecode seconds value must be positive.')\\n return self._seconds_to_frames(secs)\\n # Exact number of frames N\\n elif timecode_string.isdigit():\\n timecode = int(timecode_string)\\n if timecode < 0:\\n raise ValueError('Timecode frame number must be positive.')\\n return timecode\\n # Standard timecode in string format 'HH:MM:SS[.nnn]'\\n else:\\n tc_val = timecode_string.split(':')\\n if not (len(tc_val) == 3 and tc_val[0].isdigit() and tc_val[1].isdigit()\\n and tc_val[2].replace('.', '').isdigit()):\\n raise ValueError('Unrecognized or improperly formatted timecode string.')\\n hrs, mins = int(tc_val[0]), int(tc_val[1])\\n secs = float(tc_val[2]) if '.' in tc_val[2] else int(tc_val[2])\\n if not (hrs >= 0 and mins >= 0 and secs >= 0 and mins < 60 and secs < 60):\\n raise ValueError('Invalid timecode range (values outside allowed range).')\\n secs += (((hrs * 60.0) + mins) * 60.0)\\n return self._seconds_to_frames(secs)\\n\\n def __iadd__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\\n if isinstance(other, int):\\n self.frame_num += other\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n self.frame_num += other.frame_num\\n else:\\n raise ValueError('FrameTimecode instances require equal framerate for addition.')\\n # Check if value to add is in number of seconds.\\n elif isinstance(other, float):\\n self.frame_num += self._seconds_to_frames(other)\\n elif isinstance(other, str):\\n self.frame_num += self._parse_timecode_string(other)\\n else:\\n raise TypeError('Unsupported type for performing addition with FrameTimecode.')\\n if self.frame_num < 0: # Required to allow adding negative seconds/frames.\\n self.frame_num = 0\\n return self\\n\\n def __add__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\\n to_return = FrameTimecode(timecode=self)\\n to_return += other\\n return to_return\\n\\n def __isub__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\\n if isinstance(other, int):\\n self.frame_num -= other\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n self.frame_num -= other.frame_num\\n else:\\n raise ValueError('FrameTimecode instances require equal framerate for subtraction.')\\n # Check if value to add is in number of seconds.\\n elif isinstance(other, float):\\n self.frame_num -= self._seconds_to_frames(other)\\n elif isinstance(other, str):\\n self.frame_num -= self._parse_timecode_string(other)\\n else:\\n raise TypeError('Unsupported type for performing subtraction with FrameTimecode: %s' %\\n type(other))\\n if self.frame_num < 0:\\n self.frame_num = 0\\n return self\\n\\n def __sub__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\\n to_return = FrameTimecode(timecode=self)\\n to_return -= other\\n return to_return\\n\\n def __eq__(self, other: Union[int, float, str, 'FrameTimecode']) -> 'FrameTimecode':\\n if isinstance(other, int):\\n return self.frame_num == other\\n elif isinstance(other, float):\\n return self.get_seconds() == other\\n elif isinstance(other, str):\\n return self.frame_num == self._parse_timecode_string(other)\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n return self.frame_num == other.frame_num\\n else:\\n raise TypeError(\\n 'FrameTimecode objects must have the same framerate to be compared.')\\n elif other is None:\\n return False\\n else:\\n raise TypeError('Unsupported type for performing == with FrameTimecode: %s' %\\n type(other))\\n\\n def __ne__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\\n return not self == other\\n\\n def __lt__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\\n if isinstance(other, int):\\n return self.frame_num < other\\n elif isinstance(other, float):\\n return self.get_seconds() < other\\n elif isinstance(other, str):\\n return self.frame_num < self._parse_timecode_string(other)\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n return self.frame_num < other.frame_num\\n else:\\n raise TypeError(\\n 'FrameTimecode objects must have the same framerate to be compared.')\\n else:\\n raise TypeError('Unsupported type for performing < with FrameTimecode: %s' %\\n type(other))\\n\\n def __le__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\\n if isinstance(other, int):\\n return self.frame_num <= other\\n elif isinstance(other, float):\\n return self.get_seconds() <= other\\n elif isinstance(other, str):\\n return self.frame_num <= self._parse_timecode_string(other)\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n return self.frame_num <= other.frame_num\\n else:\\n raise TypeError(\\n 'FrameTimecode objects must have the same framerate to be compared.')\\n else:\\n raise TypeError('Unsupported type for performing <= with FrameTimecode: %s' %\\n type(other))\\n\\n def __gt__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\\n if isinstance(other, int):\\n return self.frame_num > other\\n elif isinstance(other, float):\\n return self.get_seconds() > other\\n elif isinstance(other, str):\\n return self.frame_num > self._parse_timecode_string(other)\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n return self.frame_num > other.frame_num\\n else:\\n raise TypeError(\\n 'FrameTimecode objects must have the same framerate to be compared.')\\n else:\\n raise TypeError('Unsupported type for performing > with FrameTimecode: %s' %\\n type(other))\\n\\n def __ge__(self, other: Union[int, float, str, 'FrameTimecode']) -> bool:\\n if isinstance(other, int):\\n return self.frame_num >= other\\n elif isinstance(other, float):\\n return self.get_seconds() >= other\\n elif isinstance(other, str):\\n return self.frame_num >= self._parse_timecode_string(other)\\n elif isinstance(other, FrameTimecode):\\n if self.equal_framerate(other.framerate):\\n return self.frame_num >= other.frame_num\\n else:\\n raise TypeError(\\n 'FrameTimecode objects must have the same framerate to be compared.')\\n else:\\n raise TypeError('Unsupported type for performing >= with FrameTimecode: %s' %\\n type(other))\\n\\n # TODO(v1.0): __int__ and __float__ should be removed. Mark as deprecated, and indicate\\n # need to use relevant property instead.\\n\\n def __int__(self) -> int:\\n return self.frame_num\\n\\n def __float__(self) -> float:\\n return self.get_seconds()\\n\\n def __str__(self) -> str:\\n return self.get_timecode()\\n\\n def __repr__(self) -> str:\\n return '%s [frame=%d, fps=%.3f]' % (self.get_timecode(), self.frame_num, self.framerate)\\n\\n def __hash__(self) -> int:\\n return self.frame_num\"\n },\n {\n \"identifier\": \"VideoStream\",\n \"path\": \"backend/scenedetect/video_stream.py\",\n \"snippet\": \"class VideoStream(ABC):\\n \\\"\\\"\\\" Interface which all video backends must implement. \\\"\\\"\\\"\\n\\n #\\n # Default Implementations\\n #\\n\\n @property\\n def base_timecode(self) -> FrameTimecode:\\n \\\"\\\"\\\"FrameTimecode object to use as a time base.\\\"\\\"\\\"\\n return FrameTimecode(timecode=0, fps=self.frame_rate)\\n\\n #\\n # Abstract Static Methods\\n #\\n\\n @staticmethod\\n @abstractmethod\\n def BACKEND_NAME() -> str:\\n \\\"\\\"\\\"Unique name used to identify this backend. Should be a static property in derived\\n classes (`BACKEND_NAME = 'backend_identifier'`).\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n #\\n # Abstract Properties\\n #\\n\\n @property\\n @abstractmethod\\n def path(self) -> Union[bytes, str]:\\n \\\"\\\"\\\"Video or device path.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def name(self) -> Union[bytes, str]:\\n \\\"\\\"\\\"Name of the video, without extension, or device.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def is_seekable(self) -> bool:\\n \\\"\\\"\\\"True if seek() is allowed, False otherwise.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def frame_rate(self) -> float:\\n \\\"\\\"\\\"Frame rate in frames/sec.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def duration(self) -> Optional[FrameTimecode]:\\n \\\"\\\"\\\"Duration of the stream as a FrameTimecode, or None if non terminating.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def frame_size(self) -> Tuple[int, int]:\\n \\\"\\\"\\\"Size of each video frame in pixels as a tuple of (width, height).\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def aspect_ratio(self) -> float:\\n \\\"\\\"\\\"Pixel aspect ratio as a float (1.0 represents square pixels).\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def position(self) -> FrameTimecode:\\n \\\"\\\"\\\"Current position within stream as FrameTimecode.\\n\\n This can be interpreted as presentation time stamp, thus frame 1 corresponds\\n to the presentation time 0. Returns 0 even if `frame_number` is 1.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def position_ms(self) -> float:\\n \\\"\\\"\\\"Current position within stream as a float of the presentation time in\\n milliseconds. The first frame has a PTS of 0.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @property\\n @abstractmethod\\n def frame_number(self) -> int:\\n \\\"\\\"\\\"Current position within stream as the frame number.\\n\\n Will return 0 until the first frame is `read`.\\\"\\\"\\\"\\n raise NotImplementedError\\n\\n #\\n # Abstract Methods\\n #\\n\\n @abstractmethod\\n def read(self, decode: bool = True, advance: bool = True) -> Union[ndarray, bool]:\\n \\\"\\\"\\\"Read and decode the next frame as a numpy.ndarray. Returns False when video ends.\\n\\n Arguments:\\n decode: Decode and return the frame.\\n advance: Seek to the next frame. If False, will return the current (last) frame.\\n\\n Returns:\\n If decode = True, the decoded frame (numpy.ndarray), or False (bool) if end of video.\\n If decode = False, a bool indicating if advancing to the the next frame succeeded.\\n \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @abstractmethod\\n def reset(self) -> None:\\n \\\"\\\"\\\" Close and re-open the VideoStream (equivalent to seeking back to beginning). \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @abstractmethod\\n def seek(self, target: Union[FrameTimecode, float, int]) -> None:\\n \\\"\\\"\\\"Seek to the given timecode. If given as a frame number, represents the current seek\\n pointer (e.g. if seeking to 0, the next frame decoded will be the first frame of the video).\\n\\n For 1-based indices (first frame is frame #1), the target frame number needs to be converted\\n to 0-based by subtracting one. For example, if we want to seek to the first frame, we call\\n seek(0) followed by read(). If we want to seek to the 5th frame, we call seek(4) followed\\n by read(), at which point frame_number will be 5.\\n\\n May not be supported on all backend types or inputs (e.g. cameras).\\n\\n Arguments:\\n target: Target position in video stream to seek to.\\n If float, interpreted as time in seconds.\\n If int, interpreted as frame number.\\n Raises:\\n SeekError: An error occurs while seeking, or seeking is not supported.\\n ValueError: `target` is not a valid value (i.e. it is negative).\\n \\\"\\\"\\\"\\n raise NotImplementedError\"\n },\n {\n \"identifier\": \"SceneDetector\",\n \"path\": \"backend/scenedetect/scene_detector.py\",\n \"snippet\": \"class SceneDetector:\\n \\\"\\\"\\\" Base class to inherit from when implementing a scene detection algorithm.\\n\\n This API is not yet stable and subject to change.\\n\\n This represents a \\\"dense\\\" scene detector, which returns a list of frames where\\n the next scene/shot begins in a video.\\n\\n Also see the implemented scene detectors in the scenedetect.detectors module\\n to get an idea of how a particular detector can be created.\\n \\\"\\\"\\\"\\n # TODO(v0.7): Make this a proper abstract base class.\\n\\n stats_manager: Optional[StatsManager] = None\\n \\\"\\\"\\\"Optional :class:`StatsManager <scenedetect.stats_manager.StatsManager>` to\\n use for caching frame metrics to and from.\\\"\\\"\\\"\\n\\n # TODO(v1.0): Remove - this is a rarely used case for what is now a neglegible performance gain.\\n def is_processing_required(self, frame_num: int) -> bool:\\n \\\"\\\"\\\"[DEPRECATED] DO NOT USE\\n\\n Test if all calculations for a given frame are already done.\\n\\n Returns:\\n False if the SceneDetector has assigned _metric_keys, and the\\n stats_manager property is set to a valid StatsManager object containing\\n the required frame metrics/calculations for the given frame - thus, not\\n needing the frame to perform scene detection.\\n\\n True otherwise (i.e. the frame_img passed to process_frame is required\\n to be passed to process_frame for the given frame_num).\\n \\\"\\\"\\\"\\n metric_keys = self.get_metrics()\\n return not metric_keys or not (self.stats_manager is not None\\n and self.stats_manager.metrics_exist(frame_num, metric_keys))\\n\\n def stats_manager_required(self) -> bool:\\n \\\"\\\"\\\"Stats Manager Required: Prototype indicating if detector requires stats.\\n\\n Returns:\\n True if a StatsManager is required for the detector, False otherwise.\\n \\\"\\\"\\\"\\n return False\\n\\n def get_metrics(self) -> List[str]:\\n \\\"\\\"\\\"Get Metrics: Get a list of all metric names/keys used by the detector.\\n\\n Returns:\\n List of strings of frame metric key names that will be used by\\n the detector when a StatsManager is passed to process_frame.\\n \\\"\\\"\\\"\\n return []\\n\\n def process_frame(self, frame_num: int, frame_img: Optional[numpy.ndarray]) -> List[int]:\\n \\\"\\\"\\\"Process Frame: Computes/stores metrics and detects any scene changes.\\n\\n Prototype method, no actual detection.\\n\\n Returns:\\n List of frame numbers of cuts to be added to the cutting list.\\n \\\"\\\"\\\"\\n return []\\n\\n def post_process(self, frame_num: int) -> List[int]:\\n \\\"\\\"\\\"Post Process: Performs any processing after the last frame has been read.\\n\\n Prototype method, no actual detection.\\n\\n Returns:\\n List of frame numbers of cuts to be added to the cutting list.\\n \\\"\\\"\\\"\\n return []\\n\\n @property\\n def event_buffer_length(self) -> int:\\n \\\"\\\"\\\"The amount of frames a given event can be buffered for, in time. Represents maximum\\n amount any event can be behind `frame_number` in the result of :meth:`process_frame`.\\n \\\"\\\"\\\"\\n return 0\"\n },\n {\n \"identifier\": \"SparseSceneDetector\",\n \"path\": \"backend/scenedetect/scene_detector.py\",\n \"snippet\": \"class SparseSceneDetector(SceneDetector):\\n \\\"\\\"\\\"Base class to inherit from when implementing a sparse scene detection algorithm.\\n\\n This class will be removed in v1.0 and should not be used.\\n\\n Unlike dense detectors, sparse detectors scene_detect \\\"events\\\" and return a *pair* of frames,\\n as opposed to just a single cut.\\n\\n An example of a SparseSceneDetector is the MotionDetector.\\n \\\"\\\"\\\"\\n\\n def process_frame(self, frame_num: int, frame_img: numpy.ndarray) -> List[Tuple[int, int]]:\\n \\\"\\\"\\\"Process Frame: Computes/stores metrics and detects any scene changes.\\n\\n Prototype method, no actual detection.\\n\\n Returns:\\n List of frame pairs representing individual scenes\\n to be added to the output scene list directly.\\n \\\"\\\"\\\"\\n return []\\n\\n def post_process(self, frame_num: int) -> List[Tuple[int, int]]:\\n \\\"\\\"\\\"Post Process: Performs any processing after the last frame has been read.\\n\\n Prototype method, no actual detection.\\n\\n Returns:\\n List of frame pairs representing individual scenes\\n to be added to the output scene list directly.\\n \\\"\\\"\\\"\\n return []\"\n },\n {\n \"identifier\": \"StatsManager\",\n \"path\": \"backend/scenedetect/stats_manager.py\",\n \"snippet\": \"class StatsManager:\\n \\\"\\\"\\\"Provides a key-value store for frame metrics/calculations which can be used\\n for two-pass detection algorithms, as well as saving stats to a CSV file.\\n\\n Analyzing a statistics CSV file is also very useful for finding the optimal\\n algorithm parameters for certain detection methods. Additionally, the data\\n may be plotted by a graphing module (e.g. matplotlib) by obtaining the\\n metric of interest for a series of frames by iteratively calling get_metrics(),\\n after having called the detect_scenes(...) method on the SceneManager object\\n which owns the given StatsManager instance.\\n\\n Only metrics consisting of `float` or `int` should be used currently.\\n \\\"\\\"\\\"\\n\\n def __init__(self, base_timecode: FrameTimecode = None):\\n \\\"\\\"\\\"Initialize a new StatsManager.\\n\\n Arguments:\\n base_timecode: Timecode associated with this object. Must not be None (default value\\n will be removed in a future release).\\n \\\"\\\"\\\"\\n # Frame metrics is a dict of frame (int): metric_dict (Dict[str, float])\\n # of each frame metric key and the value it represents (usually float).\\n self._frame_metrics: Dict[FrameTimecode, Dict[str, float]] = dict()\\n self._registered_metrics: Set[str] = set() # Set of frame metric keys.\\n self._loaded_metrics: Set[str] = set() # Metric keys loaded from stats file.\\n self._metrics_updated: bool = False # Flag indicating if metrics require saving.\\n self._base_timecode: Optional[FrameTimecode] = base_timecode # Used for timing calculations.\\n\\n def register_metrics(self, metric_keys: Iterable[str]) -> None:\\n \\\"\\\"\\\"Register a list of metric keys that will be used by the detector.\\n\\n Used to ensure that multiple detector keys don't overlap.\\n\\n Raises:\\n FrameMetricRegistered: A particular metric_key has already been registered/added\\n to the StatsManager. Only if the StatsManager is being used for read-only\\n access (i.e. all frames in the video have already been processed for the given\\n metric_key in the exception) is this behavior desirable.\\n \\\"\\\"\\\"\\n for metric_key in metric_keys:\\n if metric_key not in self._registered_metrics:\\n self._registered_metrics.add(metric_key)\\n else:\\n raise FrameMetricRegistered(metric_key)\\n\\n # TODO(v1.0): Change frame_number to a FrameTimecode now that it is just a hash and will\\n # be required for VFR support.\\n def get_metrics(self, frame_number: int, metric_keys: Iterable[str]) -> List[Any]:\\n \\\"\\\"\\\"Return the requested statistics/metrics for a given frame.\\n\\n Arguments:\\n frame_number (int): Frame number to retrieve metrics for.\\n metric_keys (List[str]): A list of metric keys to look up.\\n\\n Returns:\\n A list containing the requested frame metrics for the given frame number\\n in the same order as the input list of metric keys. If a metric could\\n not be found, None is returned for that particular metric.\\n \\\"\\\"\\\"\\n return [self._get_metric(frame_number, metric_key) for metric_key in metric_keys]\\n\\n def set_metrics(self, frame_number: int, metric_kv_dict: Dict[str, Any]) -> None:\\n \\\"\\\"\\\" Set Metrics: Sets the provided statistics/metrics for a given frame.\\n\\n Arguments:\\n frame_number: Frame number to retrieve metrics for.\\n metric_kv_dict: A dict mapping metric keys to the\\n respective integer/floating-point metric values to set.\\n \\\"\\\"\\\"\\n for metric_key in metric_kv_dict:\\n self._set_metric(frame_number, metric_key, metric_kv_dict[metric_key])\\n\\n def metrics_exist(self, frame_number: int, metric_keys: Iterable[str]) -> bool:\\n \\\"\\\"\\\" Metrics Exist: Checks if the given metrics/stats exist for the given frame.\\n\\n Returns:\\n bool: True if the given metric keys exist for the frame, False otherwise.\\n \\\"\\\"\\\"\\n return all([self._metric_exists(frame_number, metric_key) for metric_key in metric_keys])\\n\\n def is_save_required(self) -> bool:\\n \\\"\\\"\\\" Is Save Required: Checks if the stats have been updated since loading.\\n\\n Returns:\\n bool: True if there are frame metrics/statistics not yet written to disk,\\n False otherwise.\\n \\\"\\\"\\\"\\n return self._metrics_updated\\n\\n def save_to_csv(self,\\n csv_file: Union[str, bytes, TextIO],\\n base_timecode: Optional[FrameTimecode] = None,\\n force_save=True) -> None:\\n \\\"\\\"\\\" Save To CSV: Saves all frame metrics stored in the StatsManager to a CSV file.\\n\\n Arguments:\\n csv_file: A file handle opened in write mode (e.g. open('...', 'w')) or a path as str.\\n base_timecode: [DEPRECATED] DO NOT USE. For backwards compatibility.\\n force_save: If True, writes metrics out even if an update is not required.\\n\\n Raises:\\n OSError: If `path` cannot be opened or a write failure occurs.\\n \\\"\\\"\\\"\\n # TODO(v0.7): Replace with DeprecationWarning that `base_timecode` will be removed in v0.8.\\n if base_timecode is not None:\\n logger.error('base_timecode is deprecated.')\\n\\n # Ensure we need to write to the file, and that we have data to do so with.\\n if not ((self.is_save_required() or force_save) and self._registered_metrics\\n and self._frame_metrics):\\n logger.info(\\\"No metrics to save.\\\")\\n return\\n\\n assert self._base_timecode is not None\\n\\n # If we get a path instead of an open file handle, recursively call ourselves\\n # again but with file handle instead of path.\\n if isinstance(csv_file, (str, bytes)):\\n with open(csv_file, 'w') as file:\\n self.save_to_csv(csv_file=file, force_save=force_save)\\n return\\n\\n csv_writer = csv.writer(csv_file, lineterminator='\\\\n')\\n metric_keys = sorted(list(self._registered_metrics.union(self._loaded_metrics)))\\n csv_writer.writerow([COLUMN_NAME_FRAME_NUMBER, COLUMN_NAME_TIMECODE] + metric_keys)\\n frame_keys = sorted(self._frame_metrics.keys())\\n logger.info(\\\"Writing %d frames to CSV...\\\", len(frame_keys))\\n for frame_key in frame_keys:\\n frame_timecode = self._base_timecode + frame_key\\n csv_writer.writerow(\\n [frame_timecode.get_frames() +\\n 1, frame_timecode.get_timecode()] +\\n [str(metric) for metric in self.get_metrics(frame_key, metric_keys)])\\n\\n @staticmethod\\n def valid_header(row: List[str]) -> bool:\\n \\\"\\\"\\\"Check that the given CSV row is a valid header for a statsfile.\\n\\n Arguments:\\n row: A row decoded from the CSV reader.\\n\\n Returns:\\n True if `row` is a valid statsfile header, False otherwise.\\n \\\"\\\"\\\"\\n if not row or not len(row) >= 2:\\n return False\\n if row[0] != COLUMN_NAME_FRAME_NUMBER or row[1] != COLUMN_NAME_TIMECODE:\\n return False\\n return True\\n\\n # TODO(v1.0): Remove.\\n def load_from_csv(self, csv_file: Union[str, bytes, TextIO]) -> Optional[int]:\\n \\\"\\\"\\\"[DEPRECATED] DO NOT USE\\n\\n Load all metrics stored in a CSV file into the StatsManager instance. Will be removed in a\\n future release after becoming a no-op.\\n\\n Arguments:\\n csv_file: A file handle opened in read mode (e.g. open('...', 'r')) or a path as str.\\n\\n Returns:\\n int or None: Number of frames/rows read from the CSV file, or None if the\\n input file was blank or could not be found.\\n\\n Raises:\\n StatsFileCorrupt: Stats file is corrupt and can't be loaded, or wrong file\\n was specified.\\n \\\"\\\"\\\"\\n # TODO: Make this an error, then make load_from_csv() a no-op, and finally, remove it.\\n logger.warning(\\\"load_from_csv() is deprecated and will be removed in a future release.\\\")\\n\\n # If we get a path instead of an open file handle, check that it exists, and if so,\\n # recursively call ourselves again but with file set instead of path.\\n if isinstance(csv_file, (str, bytes)):\\n if os.path.exists(csv_file):\\n with open(csv_file, 'r') as file:\\n return self.load_from_csv(csv_file=file)\\n # Path doesn't exist.\\n return None\\n\\n # If we get here, file is a valid file handle in read-only text mode.\\n csv_reader = csv.reader(csv_file, lineterminator='\\\\n')\\n num_cols = None\\n num_metrics = None\\n num_frames = None\\n # First Row: Frame Num, Timecode, [metrics...]\\n try:\\n row = next(csv_reader)\\n # Backwards compatibility for previous versions of statsfile\\n # which included an additional header row.\\n if not self.valid_header(row):\\n row = next(csv_reader)\\n except StopIteration:\\n # If the file is blank or we couldn't decode anything, assume the file was empty.\\n return None\\n if not self.valid_header(row):\\n raise StatsFileCorrupt()\\n num_cols = len(row)\\n num_metrics = num_cols - 2\\n if not num_metrics > 0:\\n raise StatsFileCorrupt('No metrics defined in CSV file.')\\n self._loaded_metrics = row[2:]\\n num_frames = 0\\n for row in csv_reader:\\n metric_dict = {}\\n if not len(row) == num_cols:\\n raise StatsFileCorrupt('Wrong number of columns detected in stats file row.')\\n for i, metric_str in enumerate(row[2:]):\\n if metric_str and metric_str != 'None':\\n try:\\n metric_dict[self._loaded_metrics[i]] = float(metric_str)\\n except ValueError:\\n raise StatsFileCorrupt('Corrupted value in stats file: %s' %\\n metric_str) from ValueError\\n frame_number = int(row[0])\\n # Switch from 1-based to 0-based frame numbers.\\n if frame_number > 0:\\n frame_number -= 1\\n self.set_metrics(frame_number, metric_dict)\\n num_frames += 1\\n logger.info('Loaded %d metrics for %d frames.', num_metrics, num_frames)\\n self._metrics_updated = False\\n return num_frames\\n\\n def _get_metric(self, frame_number: int, metric_key: str) -> Optional[Any]:\\n if self._metric_exists(frame_number, metric_key):\\n return self._frame_metrics[frame_number][metric_key]\\n return None\\n\\n def _set_metric(self, frame_number: int, metric_key: str, metric_value: Any) -> None:\\n self._metrics_updated = True\\n if not frame_number in self._frame_metrics:\\n self._frame_metrics[frame_number] = dict()\\n self._frame_metrics[frame_number][metric_key] = metric_value\\n\\n def _metric_exists(self, frame_number: int, metric_key: str) -> bool:\\n return (frame_number in self._frame_metrics\\n and metric_key in self._frame_metrics[frame_number])\"\n },\n {\n \"identifier\": \"FrameMetricRegistered\",\n \"path\": \"backend/scenedetect/stats_manager.py\",\n \"snippet\": \"class FrameMetricRegistered(Exception):\\n \\\"\\\"\\\" Raised when attempting to register a frame metric key which has\\n already been registered. \\\"\\\"\\\"\\n\\n def __init__(self,\\n metric_key: str,\\n message: str = \\\"Attempted to re-register frame metric key.\\\"):\\n super().__init__(message)\\n self.metric_key = metric_key\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import csv\nimport threading\nimport queue\nimport logging\nimport math\nimport sys\nimport cv2\nimport numpy as np\nfrom enum import Enum\nfrom typing import Iterable, List, Tuple, Optional, Dict, Callable, Union, TextIO\nfrom backend.scenedetect._thirdparty.simpletable import (SimpleTableCell, SimpleTableImage, SimpleTableRow,\n SimpleTable, HTMLPage)\nfrom backend.scenedetect.platform import (tqdm, get_and_create_path, get_cv2_imwrite_params, Template)\nfrom backend.scenedetect.frame_timecode import FrameTimecode\nfrom backend.scenedetect.video_stream import VideoStream\nfrom backend.scenedetect.scene_detector import SceneDetector, SparseSceneDetector\nfrom backend.scenedetect.stats_manager import StatsManager, FrameMetricRegistered"},"token_num":{"kind":"number","value":14698,"string":"14,698"},"cropped_code":{"kind":"string","value":" '%d' % (i + 1),\n '%d' % (start.get_frames() + 1),\n start.get_timecode(),\n '%.3f' % start.get_seconds(),\n '%d' % end.get_frames(),\n end.get_timecode(),\n '%.3f' % end.get_seconds(),\n '%d' % duration.get_frames(),\n duration.get_timecode(),\n '%.3f' % duration.get_seconds()\n ])\n\n if image_filenames:\n for image in image_filenames[i]:\n row.add_cell(\n SimpleTableCell(\n SimpleTableImage(image, width=image_width, height=image_height)))\n\n if i == 0:\n scene_table = SimpleTable(rows=[row], header_row=header_row, css_class=css_class)\n else:\n scene_table.add_row(row=row)\n\n # Write html file\n page = HTMLPage()\n page.add_table(timecode_table)\n page.add_table(scene_table)\n page.css = css\n page.save(output_html_filename)\n\n\n#\n# TODO(v1.0): Refactor to take a SceneList object; consider moving this and save scene list\n# to a better spot, or just move them to scene_list.py.\n#\ndef save_images(scene_list: List[Tuple[FrameTimecode, FrameTimecode]],\n video: VideoStream,\n num_images: int = 3,\n frame_margin: int = 1,\n image_extension: str = 'jpg',\n encoder_param: int = 95,\n image_name_template: str = '$VIDEO_NAME-Scene-$SCENE_NUMBER-$IMAGE_NUMBER',\n output_dir: Optional[str] = None,\n show_progress: Optional[bool] = False,\n scale: Optional[float] = None,\n height: Optional[int] = None,\n width: Optional[int] = None,\n interpolation: Interpolation = Interpolation.CUBIC,\n video_manager=None) -> Dict[int, List[str]]:\n \"\"\"Save a set number of images from each scene, given a list of scenes\n and the associated video/frame source.\n\n Arguments:\n scene_list: A list of scenes (pairs of FrameTimecode objects) returned\n from calling a SceneManager's detect_scenes() method.\n video: A VideoStream object corresponding to the scene list.\n Note that the video will be closed/re-opened and seeked through.\n num_images: Number of images to generate for each scene. Minimum is 1.\n frame_margin: Number of frames to pad each scene around the beginning\n and end (e.g. moves the first/last image into the scene by N frames).\n Can set to 0, but will result in some video files failing to extract\n the very last frame.\n image_extension: Type of image to save (must be one of 'jpg', 'png', or 'webp').\n encoder_param: Quality/compression efficiency, based on type of image:\n 'jpg' / 'webp': Quality 0-100, higher is better quality. 100 is lossless for webp.\n 'png': Compression from 1-9, where 9 achieves best filesize but is slower to encode.\n image_name_template: Template to use when creating the images on disk. Can\n use the macros $VIDEO_NAME, $SCENE_NUMBER, and $IMAGE_NUMBER. The image\n extension is applied automatically as per the argument image_extension.\n output_dir: Directory to output the images into. If not set, the output\n is created in the working directory.\n show_progress: If True, shows a progress bar if tqdm is installed.\n scale: Optional factor by which to rescale saved images. A scaling factor of 1 would\n not result in rescaling. A value < 1 results in a smaller saved image, while a\n value > 1 results in an image larger than the original. This value is ignored if\n either the height or width values are specified.\n height: Optional value for the height of the saved images. Specifying both the height\n and width will resize images to an exact size, regardless of aspect ratio.\n Specifying only height will rescale the image to that number of pixels in height\n while preserving the aspect ratio.\n width: Optional value for the width of the saved images. Specifying both the width\n and height will resize images to an exact size, regardless of aspect ratio.\n Specifying only width will rescale the image to that number of pixels wide\n while preserving the aspect ratio.\n interpolation: Type of interpolation to use when resizing images.\n video_manager: [DEPRECATED] DO NOT USE. For backwards compatibility only.\n\n Returns:\n Dictionary of the format { scene_num : [image_paths] }, where scene_num is the\n number of the scene in scene_list (starting from 1), and image_paths is a list of\n the paths to the newly saved/created images.\n\n Raises:\n ValueError: Raised if any arguments are invalid or out of range (e.g.\n if num_images is negative).\n \"\"\"\n # TODO(v0.7): Add DeprecationWarning that `video_manager` will be removed in v0.8.\n if video_manager is not None:\n logger.error('`video_manager` argument is deprecated, use `video` instead.')\n video = video_manager\n\n if not scene_list:\n return {}\n if num_images <= 0 or frame_margin < 0:\n raise ValueError()\n\n # TODO: Validate that encoder_param is within the proper range.\n # Should be between 0 and 100 (inclusive) for jpg/webp, and 1-9 for png.\n imwrite_param = [get_cv2_imwrite_params()[image_extension], encoder_param\n ] if encoder_param is not None else []\n\n video.reset()\n\n # Setup flags and init progress bar if available.\n completed = True\n logger.info('Generating output images (%d per scene)...', num_images)\n progress_bar = None\n if show_progress:\n progress_bar = tqdm(total=len(scene_list) * num_images, unit='images', dynamic_ncols=True)\n\n"},"all_code":{"kind":"string","value":"# -*- coding: utf-8 -*-\n#\n# PySceneDetect: Python-Based Video Scene Detector\n# -------------------------------------------------------------------\n# [ Site: https://scenedetect.com ]\n# [ Docs: https://scenedetect.com/docs/ ]\n# [ Github: https://github.com/Breakthrough/PySceneDetect/ ]\n#\n# Copyright (C) 2014-2023 Brandon Castellano <http://www.bcastell.com>.\n# PySceneDetect is licensed under the BSD 3-Clause License; see the\n# included LICENSE file, or visit one of the above pages for details.\n#\n\"\"\"``scenedetect.scene_manager`` Module\n\nThis module implements :class:`SceneManager`, coordinates running a\n:mod:`SceneDetector <scenedetect.detectors>` over the frames of a video\n(:mod:`VideoStream <scenedetect.video_stream>`). Video decoding is done in a separate thread to\nimprove performance.\n\nThis module also contains other helper functions (e.g. :func:`save_images`) which can be used to\nprocess the resulting scene list.\n\n===============================================================\nUsage\n===============================================================\n\nThe following example shows basic usage of a :class:`SceneManager`:\n\n.. code:: python\n\n from scenedetect import open_video, SceneManager, ContentDetector\n video = open_video(video_path)\n scene_manager = SceneManager()\n scene_manager.add_detector(ContentDetector())\n # Detect all scenes in video from current position to end.\n scene_manager.detect_scenes(video)\n # `get_scene_list` returns a list of start/end timecode pairs\n # for each scene that was found.\n scenes = scene_manager.get_scene_list()\n\nAn optional callback can also be invoked on each detected scene, for example:\n\n.. code:: python\n\n from scenedetect import open_video, SceneManager, ContentDetector\n\n # Callback to invoke on the first frame of every new scene detection.\n def on_new_scene(frame_img: numpy.ndarray, frame_num: int):\n print(\"New scene found at frame %d.\" % frame_num)\n\n video = open_video(test_video_file)\n scene_manager = SceneManager()\n scene_manager.add_detector(ContentDetector())\n scene_manager.detect_scenes(video=video, callback=on_new_scene)\n\nTo use a `SceneManager` with a webcam/device or existing `cv2.VideoCapture` device, use the\n:class:`VideoCaptureAdapter <scenedetect.backends.opencv.VideoCaptureAdapter>` instead of\n`open_video`.\n\n=======================================================================\nStoring Per-Frame Statistics\n=======================================================================\n\n`SceneManager` can use an optional\n:class:`StatsManager <scenedetect.stats_manager.StatsManager>` to save frame statistics to disk:\n\n.. code:: python\n\n from scenedetect import open_video, ContentDetector, SceneManager, StatsManager\n video = open_video(test_video_file)\n scene_manager = SceneManager(stats_manager=StatsManager())\n scene_manager.add_detector(ContentDetector())\n scene_manager.detect_scenes(video=video)\n scene_list = scene_manager.get_scene_list()\n print_scenes(scene_list=scene_list)\n # Save per-frame statistics to disk.\n scene_manager.stats_manager.save_to_csv(csv_file=STATS_FILE_PATH)\n\nThe statsfile can be used to find a better threshold for certain inputs, or perform statistical\nanalysis of the video.\n\"\"\"\n\n\n\n\nlogger = logging.getLogger('pyscenedetect')\n\n# TODO: This value can and should be tuned for performance improvements as much as possible,\n# until accuracy falls, on a large enough dataset. This has yet to be done, but the current\n# value doesn't seem to have caused any issues at least.\nDEFAULT_MIN_WIDTH: int = 256\n\"\"\"The default minimum width a frame will be downscaled to when calculating a downscale factor.\"\"\"\n\nMAX_FRAME_QUEUE_LENGTH: int = 4\n\"\"\"Maximum number of decoded frames which can be buffered while waiting to be processed.\"\"\"\n\nPROGRESS_BAR_DESCRIPTION = 'Detected: %d | Progress'\n\"\"\"Template to use for progress bar.\"\"\"\n\n\nclass Interpolation(Enum):\n \"\"\"Interpolation method used for image resizing. Based on constants defined in OpenCV.\"\"\"\n NEAREST = cv2.INTER_NEAREST\n \"\"\"Nearest neighbor interpolation.\"\"\"\n LINEAR = cv2.INTER_LINEAR\n \"\"\"Bilinear interpolation.\"\"\"\n CUBIC = cv2.INTER_CUBIC\n \"\"\"Bicubic interpolation.\"\"\"\n AREA = cv2.INTER_AREA\n \"\"\"Pixel area relation resampling. Provides moire'-free downscaling.\"\"\"\n LANCZOS4 = cv2.INTER_LANCZOS4\n \"\"\"Lanczos interpolation over 8x8 neighborhood.\"\"\"\n\n\ndef compute_downscale_factor(frame_width: int, effective_width: int = DEFAULT_MIN_WIDTH) -> int:\n \"\"\"Get the optimal default downscale factor based on a video's resolution (currently only\n the width in pixels is considered).\n\n The resulting effective width of the video will be between frame_width and 1.5 * frame_width\n pixels (e.g. if frame_width is 200, the range of effective widths will be between 200 and 300).\n\n Arguments:\n frame_width: Actual width of the video frame in pixels.\n effective_width: Desired minimum width in pixels.\n\n Returns:\n int: The default downscale factor to use to achieve at least the target effective_width.\n \"\"\"\n assert not (frame_width < 1 or effective_width < 1)\n if frame_width < effective_width:\n return 1\n return frame_width // effective_width\n\n\ndef get_scenes_from_cuts(\n cut_list: Iterable[FrameTimecode],\n start_pos: Union[int, FrameTimecode],\n end_pos: Union[int, FrameTimecode],\n base_timecode: Optional[FrameTimecode] = None,\n) -> List[Tuple[FrameTimecode, FrameTimecode]]:\n \"\"\"Returns a list of tuples of start/end FrameTimecodes for each scene based on a\n list of detected scene cuts/breaks.\n\n This function is called when using the :meth:`SceneManager.get_scene_list` method.\n The scene list is generated from a cutting list (:meth:`SceneManager.get_cut_list`),\n noting that each scene is contiguous, starting from the first to last frame of the input.\n If `cut_list` is empty, the resulting scene will span from `start_pos` to `end_pos`.\n\n Arguments:\n cut_list: List of FrameTimecode objects where scene cuts/breaks occur.\n base_timecode: The base_timecode of which all FrameTimecodes in the cut_list are based on.\n num_frames: The number of frames, or FrameTimecode representing duration, of the video that\n was processed (used to generate last scene's end time).\n start_frame: The start frame or FrameTimecode of the cut list. Used to generate the first\n scene's start time.\n base_timecode: [DEPRECATED] DO NOT USE. For backwards compatibility only.\n Returns:\n List of tuples in the form (start_time, end_time), where both start_time and\n end_time are FrameTimecode objects representing the exact time/frame where each\n scene occupies based on the input cut_list.\n \"\"\"\n # TODO(v0.7): Use the warnings module to turn this into a warning.\n if base_timecode is not None:\n logger.error('`base_timecode` argument is deprecated has no effect.')\n\n # Scene list, where scenes are tuples of (Start FrameTimecode, End FrameTimecode).\n scene_list = []\n if not cut_list:\n scene_list.append((start_pos, end_pos))\n return scene_list\n # Initialize last_cut to the first frame we processed,as it will be\n # the start timecode for the first scene in the list.\n last_cut = start_pos\n for cut in cut_list:\n scene_list.append((last_cut, cut))\n last_cut = cut\n # Last scene is from last cut to end of video.\n scene_list.append((last_cut, end_pos))\n\n return scene_list\n\n\ndef write_scene_list(output_csv_file: TextIO,\n scene_list: Iterable[Tuple[FrameTimecode, FrameTimecode]],\n include_cut_list: bool = True,\n cut_list: Optional[Iterable[FrameTimecode]] = None) -> None:\n \"\"\"Writes the given list of scenes to an output file handle in CSV format.\n\n Arguments:\n output_csv_file: Handle to open file in write mode.\n scene_list: List of pairs of FrameTimecodes denoting each scene's start/end FrameTimecode.\n include_cut_list: Bool indicating if the first row should include the timecodes where\n each scene starts. Should be set to False if RFC 4180 compliant CSV output is required.\n cut_list: Optional list of FrameTimecode objects denoting the cut list (i.e. the frames\n in the video that need to be split to generate individual scenes). If not specified,\n the cut list is generated using the start times of each scene following the first one.\n \"\"\"\n csv_writer = csv.writer(output_csv_file, lineterminator='\\n')\n # If required, output the cutting list as the first row (i.e. before the header row).\n if include_cut_list:\n csv_writer.writerow(\n [\"Timecode List:\"] +\n cut_list if cut_list else [start.get_timecode() for start, _ in scene_list[1:]])\n csv_writer.writerow([\n \"Scene Number\", \"Start Frame\", \"Start Timecode\", \"Start Time (seconds)\", \"End Frame\",\n \"End Timecode\", \"End Time (seconds)\", \"Length (frames)\", \"Length (timecode)\",\n \"Length (seconds)\"\n ])\n for i, (start, end) in enumerate(scene_list):\n duration = end - start\n csv_writer.writerow([\n '%d' % (i + 1),\n '%d' % (start.get_frames() + 1),\n start.get_timecode(),\n '%.3f' % start.get_seconds(),\n '%d' % end.get_frames(),\n end.get_timecode(),\n '%.3f' % end.get_seconds(),\n '%d' % duration.get_frames(),\n duration.get_timecode(),\n '%.3f' % duration.get_seconds()\n ])\n\n\ndef write_scene_list_html(output_html_filename,\n scene_list,\n cut_list=None,\n css=None,\n css_class='mytable',\n image_filenames=None,\n image_width=None,\n image_height=None):\n \"\"\"Writes the given list of scenes to an output file handle in html format.\n\n Arguments:\n output_html_filename: filename of output html file\n scene_list: List of pairs of FrameTimecodes denoting each scene's start/end FrameTimecode.\n cut_list: Optional list of FrameTimecode objects denoting the cut list (i.e. the frames\n in the video that need to be split to generate individual scenes). If not passed,\n the start times of each scene (besides the 0th scene) is used instead.\n css: String containing all the css information for the resulting html page.\n css_class: String containing the named css class\n image_filenames: dict where key i contains a list with n elements (filenames of\n the n saved images from that scene)\n image_width: Optional desired width of images in table in pixels\n image_height: Optional desired height of images in table in pixels\n \"\"\"\n if not css:\n css = \"\"\"\n table.mytable {\n font-family: times;\n font-size:12px;\n color:#000000;\n border-width: 1px;\n border-color: #eeeeee;\n border-collapse: collapse;\n background-color: #ffffff;\n width=100%;\n max-width:550px;\n table-layout:fixed;\n }\n table.mytable th {\n border-width: 1px;\n padding: 8px;\n border-style: solid;\n border-color: #eeeeee;\n background-color: #e6eed6;\n color:#000000;\n }\n table.mytable td {\n border-width: 1px;\n padding: 8px;\n border-style: solid;\n border-color: #eeeeee;\n }\n #code {\n display:inline;\n font-family: courier;\n color: #3d9400;\n }\n #string {\n display:inline;\n font-weight: bold;\n }\n \"\"\"\n\n # Output Timecode list\n timecode_table = SimpleTable(\n [[\"Timecode List:\"] +\n (cut_list if cut_list else [start.get_timecode() for start, _ in scene_list[1:]])],\n css_class=css_class)\n\n # Output list of scenes\n header_row = [\n \"Scene Number\", \"Start Frame\", \"Start Timecode\", \"Start Time (seconds)\", \"End Frame\",\n \"End Timecode\", \"End Time (seconds)\", \"Length (frames)\", \"Length (timecode)\",\n \"Length (seconds)\"\n ]\n for i, (start, end) in enumerate(scene_list):\n duration = end - start\n\n row = SimpleTableRow([\n '%d' % (i + 1),\n '%d' % (start.get_frames() + 1),\n start.get_timecode(),\n '%.3f' % start.get_seconds(),\n '%d' % end.get_frames(),\n end.get_timecode(),\n '%.3f' % end.get_seconds(),\n '%d' % duration.get_frames(),\n duration.get_timecode(),\n '%.3f' % duration.get_seconds()\n ])\n\n if image_filenames:\n for image in image_filenames[i]:\n row.add_cell(\n SimpleTableCell(\n SimpleTableImage(image, width=image_width, height=image_height)))\n\n if i == 0:\n scene_table = SimpleTable(rows=[row], header_row=header_row, css_class=css_class)\n else:\n scene_table.add_row(row=row)\n\n # Write html file\n page = HTMLPage()\n page.add_table(timecode_table)\n page.add_table(scene_table)\n page.css = css\n page.save(output_html_filename)\n\n\n#\n# TODO(v1.0): Refactor to take a SceneList object; consider moving this and save scene list\n# to a better spot, or just move them to scene_list.py.\n#\ndef save_images(scene_list: List[Tuple[FrameTimecode, FrameTimecode]],\n video: VideoStream,\n num_images: int = 3,\n frame_margin: int = 1,\n image_extension: str = 'jpg',\n encoder_param: int = 95,\n image_name_template: str = '$VIDEO_NAME-Scene-$SCENE_NUMBER-$IMAGE_NUMBER',\n output_dir: Optional[str] = None,\n show_progress: Optional[bool] = False,\n scale: Optional[float] = None,\n height: Optional[int] = None,\n width: Optional[int] = None,\n interpolation: Interpolation = Interpolation.CUBIC,\n video_manager=None) -> Dict[int, List[str]]:\n \"\"\"Save a set number of images from each scene, given a list of scenes\n and the associated video/frame source.\n\n Arguments:\n scene_list: A list of scenes (pairs of FrameTimecode objects) returned\n from calling a SceneManager's detect_scenes() method.\n video: A VideoStream object corresponding to the scene list.\n Note that the video will be closed/re-opened and seeked through.\n num_images: Number of images to generate for each scene. Minimum is 1.\n frame_margin: Number of frames to pad each scene around the beginning\n and end (e.g. moves the first/last image into the scene by N frames).\n Can set to 0, but will result in some video files failing to extract\n the very last frame.\n image_extension: Type of image to save (must be one of 'jpg', 'png', or 'webp').\n encoder_param: Quality/compression efficiency, based on type of image:\n 'jpg' / 'webp': Quality 0-100, higher is better quality. 100 is lossless for webp.\n 'png': Compression from 1-9, where 9 achieves best filesize but is slower to encode.\n image_name_template: Template to use when creating the images on disk. Can\n use the macros $VIDEO_NAME, $SCENE_NUMBER, and $IMAGE_NUMBER. The image\n extension is applied automatically as per the argument image_extension.\n output_dir: Directory to output the images into. If not set, the output\n is created in the working directory.\n show_progress: If True, shows a progress bar if tqdm is installed.\n scale: Optional factor by which to rescale saved images. A scaling factor of 1 would\n not result in rescaling. A value < 1 results in a smaller saved image, while a\n value > 1 results in an image larger than the original. This value is ignored if\n either the height or width values are specified.\n height: Optional value for the height of the saved images. Specifying both the height\n and width will resize images to an exact size, regardless of aspect ratio.\n Specifying only height will rescale the image to that number of pixels in height\n while preserving the aspect ratio.\n width: Optional value for the width of the saved images. Specifying both the width\n and height will resize images to an exact size, regardless of aspect ratio.\n Specifying only width will rescale the image to that number of pixels wide\n while preserving the aspect ratio.\n interpolation: Type of interpolation to use when resizing images.\n video_manager: [DEPRECATED] DO NOT USE. For backwards compatibility only.\n\n Returns:\n Dictionary of the format { scene_num : [image_paths] }, where scene_num is the\n number of the scene in scene_list (starting from 1), and image_paths is a list of\n the paths to the newly saved/created images.\n\n Raises:\n ValueError: Raised if any arguments are invalid or out of range (e.g.\n if num_images is negative).\n \"\"\"\n # TODO(v0.7): Add DeprecationWarning that `video_manager` will be removed in v0.8.\n if video_manager is not None:\n logger.error('`video_manager` argument is deprecated, use `video` instead.')\n video = video_manager\n\n if not scene_list:\n return {}\n if num_images <= 0 or frame_margin < 0:\n raise ValueError()\n\n # TODO: Validate that encoder_param is within the proper range.\n # Should be between 0 and 100 (inclusive) for jpg/webp, and 1-9 for png.\n imwrite_param = [get_cv2_imwrite_params()[image_extension], encoder_param\n ] if encoder_param is not None else []\n\n video.reset()\n\n # Setup flags and init progress bar if available.\n completed = True\n logger.info('Generating output images (%d per scene)...', num_images)\n progress_bar = None\n if show_progress:\n progress_bar = tqdm(total=len(scene_list) * num_images, unit='images', dynamic_ncols=True)\n"},"next_line":{"kind":"string","value":" filename_template = Template(image_name_template)"},"gold_snippet_index":{"kind":"number","value":5,"string":"5"},"created_at":{"kind":"string","value":"2023-10-25 02:50:01+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5681,"cells":{"repo_name":{"kind":"string","value":"EulerSearch/embedding_studio"},"file_path":{"kind":"string","value":"plugins/default_fine_tuning_method.py"},"context":{"kind":"list like","value":[{"identifier":"settings","path":"embedding_studio/core/config.py","snippet":"class Settings(BaseSettings):\n API_V1_STR: str = \"/api/v1\"\n SECRET_KEY: str = secrets.token_urlsafe(32)\n ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8\n BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = []\n FINETUNING_MONGO_HOST: str = os.getenv(\"FINETUNING_MONGO_HOST\", \"mongo\")\n FINETUNING_MONGO_PORT: int = os.getenv(\"FINETUNING_MONGO_PORT\", 27017)\n FINETUNING_MONGO_DB_NAME: str = os.getenv(\n \"FINETUNING_MONGO_DB_NAME\", \"embedding_studio\"\n )\n FINETUNING_MONGO_USERNAME: str = os.getenv(\n \"FINETUNING_MONGO_USERNAME\", \"root\"\n )\n FINETUNING_MONGO_PASSWORD: str = os.getenv(\n \"FINETUNING_MONGO_PASSWORD\", \"mongopassword\"\n )\n FINETUNING_MONGO_URL: str = (\n f\"mongodb://{FINETUNING_MONGO_USERNAME}:{FINETUNING_MONGO_PASSWORD}@\"\n f\"{FINETUNING_MONGO_HOST}:{FINETUNING_MONGO_PORT}\"\n )\n CLICKSTREAM_MONGO_HOST: str = os.getenv(\"CLICKSTREAM_MONGO_HOST\", \"mongo\")\n CLICKSTREAM_MONGO_PORT: int = os.getenv(\"CLICKSTREAM_MONGO_PORT\", 27017)\n CLICKSTREAM_MONGO_DB_NAME: str = os.getenv(\n \"CLICKSTREAM_MONGO_DB_NAME\", \"embedding_studio\"\n )\n CLICKSTREAM_MONGO_USERNAME: str = os.getenv(\n \"CLICKSTREAM_MONGO_USERNAME\", \"root\"\n )\n CLICKSTREAM_MONGO_PASSWORD: str = os.getenv(\n \"CLICKSTREAM_MONGO_PASSWORD\", \"mongopassword\"\n )\n CLICKSTREAM_MONGO_URL: str = (\n f\"mongodb://{CLICKSTREAM_MONGO_USERNAME}:{CLICKSTREAM_MONGO_PASSWORD}@\"\n f\"{CLICKSTREAM_MONGO_HOST}:{CLICKSTREAM_MONGO_PORT}\"\n )\n REDIS_HOST: str = os.getenv(\"REDIS_HOST\", \"localhost\")\n REDIS_PORT: int = os.getenv(\"REDIS_PORT\", 6379)\n REDIS_PASSWORD: str = os.getenv(\"REDIS_PASSWORD\", \"redispassword\")\n REDIS_URL: str = f\"redis://{REDIS_HOST}:{REDIS_PORT}/0\"\n MINIO_HOST: str = os.getenv(\"MINIO_HOST\", \"localhost\")\n MINIO_PORT: int = os.getenv(\"MINIO_PORT\", 9000)\n MINIO_ROOT_USER: str = os.getenv(\"MINIO_ROOT_USER\", \"root\")\n MINIO_ROOT_PASSWORD: str = os.getenv(\n \"MINIO_ROOT_PASSWORD\", \"miniopassword\"\n )\n MINIO_DEFAULT_BUCKETS: str = os.getenv(\n \"MINIO_DEFAULT_BUCKETS\", \"embeddingstudio\"\n )\n MINIO_ACCESS_KEY: str = os.getenv(\n \"MINIO_ACCESS_KEY\", \"mtGNiEvoTL6C0EXAMPLE\"\n )\n MINIO_SECRET_KEY: str = os.getenv(\n \"MINIO_SECRET_KEY\", \"HY5JserXAaWmphNyCpQPEXAMPLEKEYEXAMPLEKEY\"\n )\n MYSQL_HOST: str = os.getenv(\"MYSQL_HOST\", \"localhost\")\n MYSQL_PORT: int = os.getenv(\"MYSQL_PORT\", 3306)\n MYSQL_DATABASE: str = os.getenv(\"MYSQL_DATABASE\", \"mlflow\")\n MYSQL_USER: str = os.getenv(\"MYSQL_USER\", \"mlflow_user\")\n MYSQL_PASSWORD: str = os.getenv(\"MYSQL_PASSWORD\", \"Baxp3O5rUvpIxiD77BfZ\")\n MYSQL_ROOT_PASSWORD: str = os.getenv(\n \"MYSQL_ROOT_PASSWORD\", \"PrK5qmPTDsm2IYKvHVG8\"\n )\n MLFLOW_HOST: str = os.getenv(\"MLFLOW_HOST\", \"localhost\")\n MLFLOW_PORT: int = os.getenv(\"MLFLOW_PORT\", 5001)\n MLFLOW_TRACKING_URI: str = f\"http://{MLFLOW_HOST}:{MLFLOW_PORT}\"\n ES_PLUGINS_PATH: str = os.getenv(\"ES_PLUGINS_PATH\", \"plugins\")\n FINE_TUNING_WORKER_MAX_RETRIES: int = os.getenv(\n \"FINE_TUNING_WORKER_MAX_RETRIES\", 3\n )\n FINE_TUNING_WORKER_TIME_LIMIT: int = os.getenv(\n \"FINE_TUNING_WORKER_TIME_LIMIT\", 18000000\n )\n DEFAULT_MAX_ATTEMPTS: int = os.getenv(\"DEFAULT_MAX_ATTEMPTS\", 3)\n DEFAULT_WAIT_TIME_SECONDS: float = os.getenv(\n \"DEFAULT_WAIT_TIME_SECONDS\", 3.0\n )\n S3_READ_CREDENTIALS_ATTEMPTS: int = os.getenv(\n \"S3_READ_CREDENTIALS_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n S3_READ_WAIT_TIME_SECONDS: float = os.getenv(\n \"S3_READ_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n S3_DOWNLOAD_DATA_ATTEMPTS: int = os.getenv(\n \"S3_DOWNLOAD_DATA_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n S3_DOWNLOAD_DATA_WAIT_TIME_SECONDS: float = os.getenv(\n \"S3_DOWNLOAD_DATA_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_LOG_METRIC_ATTEMPTS: int = os.getenv(\n \"MLFLOW_LOG_METRIC_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_LOG_METRIC_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_LOG_METRIC_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_LOG_PARAM_ATTEMPTS: int = os.getenv(\n \"MLFLOW_LOG_PARAM_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_LOG_PARAM_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_LOG_PARAM_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_LOG_MODEL_ATTEMPTS: int = os.getenv(\n \"MLFLOW_LOG_MODEL_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_LOG_MODEL_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_LOG_MODEL_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_LOAD_MODEL_ATTEMPTS: int = os.getenv(\n \"MLFLOW_LOAD_MODEL_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_LOAD_MODEL_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_LOAD_MODEL_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_DELETE_MODEL_ATTEMPTS: int = os.getenv(\n \"MLFLOW_DELETE_MODEL_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_DELETE_MODEL_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_DELETE_MODEL_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_SEARCH_RUNS_ATTEMPTS: int = os.getenv(\n \"MLFLOW_SEARCH_RUNS_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_SEARCH_RUNS_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_SEARCH_RUNS_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_END_RUN_ATTEMPTS: int = os.getenv(\n \"MLFLOW_END_RUN_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_END_RUN_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_END_RUN_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_GET_RUN_ATTEMPTS: int = os.getenv(\n \"MLFLOW_GET_RUN_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_GET_RUN_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_GET_RUN_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_SEARCH_EXPERIMENTS_ATTEMPTS: int = os.getenv(\n \"MLFLOW_SEARCH_EXPERIMENTS_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_SEARCH_EXPERIMENTS_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_SEARCH_EXPERIMENTS_WAIT_TIME_SECONDS\",\n DEFAULT_WAIT_TIME_SECONDS,\n )\n MLFLOW_DELETE_EXPERIMENT_ATTEMPTS: int = os.getenv(\n \"MLFLOW_DELETE_EXPERIMENT_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_DELETE_EXPERIMENT_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_DELETE_EXPERIMENT_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_CREATE_EXPERIMENT_ATTEMPTS: int = os.getenv(\n \"MLFLOW_CREATE_EXPERIMENT_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_CREATE_EXPERIMENT_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_CREATE_EXPERIMENT_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n MLFLOW_GET_EXPERIMENT_ATTEMPTS: int = os.getenv(\n \"MLFLOW_GET_EXPERIMENT_ATTEMPTS\", DEFAULT_MAX_ATTEMPTS\n )\n MLFLOW_GET_EXPERIMENT_WAIT_TIME_SECONDS: float = os.getenv(\n \"MLFLOW_GET_EXPERIMENT_WAIT_TIME_SECONDS\", DEFAULT_WAIT_TIME_SECONDS\n )\n CLICKSTREAM_TIME_MAX_DELTA_MINUS_SEC: int = os.getenv(\n \"CLICKSTREAM_TIME_MAX_DELTA_MINUS_SEC\", 12 * 60 * 60\n )\n CLICKSTREAM_TIME_MAX_DELTA_PLUS_SEC: int = os.getenv(\n \"CLICKSTREAM_TIME_MAX_DELTA_PLUS_SEC\", 5 * 60\n )"},{"identifier":"FineTuningMethod","path":"embedding_studio/core/plugin.py","snippet":"class FineTuningMethod(ABC):\n \"\"\"Base class (plugin) for fine-tuning methods.\n\n All fine-tuning methods must inherit from this class.\n \"\"\"\n\n meta: PluginMeta\n\n @abstractmethod\n def upload_initial_model(self) -> None:\n \"\"\"Upload the initial model to the storage.\n\n Method that should be implemented by subclasses to upload the\n initial model to the storage.\n \"\"\"\n raise NotImplementedError(\n \"Subclasses must implement upload_initial_model\"\n )\n\n @abstractmethod\n def get_fine_tuning_builder(\n self, clickstream: List[SessionWithEvents]\n ) -> FineTuningBuilder:\n \"\"\"Return a FineTuningBuilder instance for the fine-tuning process.\n\n Method that should be implemented by subclasses to provide a\n FineTuningBuilder instance.\n\n :param clickstream: Collection of user feedback, used to enhance\n the model.\n :return: An instance of FineTuningBuilder used for\n launching the fine-tuning process.\n \"\"\"\n raise NotImplementedError(\n \"Subclasses must implement get_fine_tuning_builder\"\n )"},{"identifier":"AWSS3ClickstreamParser","path":"embedding_studio/embeddings/data/clickstream/parsers/s3_parser.py","snippet":"class AWSS3ClickstreamParser(ClickstreamParser):\n def __init__(\n self, query_item_type: type, search_result_type: type, event_type: type\n ):\n super(AWSS3ClickstreamParser, self).__init__(\n query_item_type, search_result_type, S3FileMeta, event_type\n )"},{"identifier":"DummyEventType","path":"embedding_studio/embeddings/data/clickstream/search_event.py","snippet":"class DummyEventType(EventType):\n importance: float\n\n @property\n def event_importance(self) -> float:\n return self.importance"},{"identifier":"SearchResult","path":"embedding_studio/embeddings/data/clickstream/search_event.py","snippet":"class SearchResult(BaseModel):\n item: ItemMeta\n is_click: bool\n rank: Optional[float] = None\n event_type: Optional[EventType] = None\n timestamp: Optional[int] = None\n\n @validator(\"event_type\", pre=True, always=True)\n def validate_event_type(cls, value, values):\n if value is not None and not isinstance(value, EventType):\n raise ValueError(\"Invalid event_type instance\")\n return value\n\n class Config:\n arbitrary_types_allowed = True\n\n @classmethod\n def from_mongo(\n cls,\n result: SearchResultItem,\n event_ids: Set[str],\n item_type: type,\n event_type: type,\n ) -> \"SearchResult\":\n event_instance = DummyEventType(importance=1)\n\n return cls(\n item=item_type(**result.meta),\n is_click=result.object_id in event_ids,\n event_type=event_instance,\n timestamp=None,\n )\n\n @classmethod\n def from_dict(\n cls, data: dict, item_type: type, event_type: type\n ) -> \"SearchResult\":\n event_data: Optional[Dict] = data.get(\"event_type\")\n event_instance = None\n\n if event_data is not None:\n event_instance = event_type(**event_data)\n\n return cls(\n item=item_type(**data[\"item\"]),\n is_click=data[\"is_click\"],\n rank=data[\"rank\"],\n event_type=event_instance,\n timestamp=int(data.get(\"timestamp\")),\n )"},{"identifier":"ClickstreamSessionsSplitter","path":"embedding_studio/embeddings/data/clickstream/splitter.py","snippet":"class ClickstreamSessionsSplitter:\n def __init__(\n self,\n test_size_ratio: float = 0.2,\n shuffle: bool = True,\n random_state: Optional[int] = None,\n ):\n \"\"\"Generate train / test clickstream sessions split.\n\n :param test_size_ratio: ratio of test split size (default: 0.2)\n :param shuffle: to shuffle or not paired clickstream sessions (default: True)\n :param random_state: random state to sklearn splitter (default: None)\n \"\"\"\n if (\n not isinstance(test_size_ratio, float)\n or test_size_ratio <= 0\n or test_size_ratio >= 1.0\n ):\n raise ValueError(\n f\"test_size_ration is a numeric value in range (0.0, 1.0)\"\n )\n\n if test_size_ratio >= 0.5:\n logger.warning(\n \"test_size_ration is larger than 0.5. It's unusual for ML to have test size > train size.\"\n )\n\n self._test_size_ratio = test_size_ratio\n\n if not isinstance(shuffle, bool):\n raise ValueError(\"shuffle should be boolean\")\n self._shuffle = shuffle\n self._random_state = random_state\n\n @property\n def shuffle(self) -> bool:\n return self._shuffle\n\n def split(self, sessions: List[ClickstreamSession]) -> DatasetDict:\n \"\"\"Split clickstream sessions.\n\n :param sessions: sessions to be split\n :return: train / test splits accordingly (PairedClickstreamDataset)\n \"\"\"\n # Get all IDs\n all_result_ids: Set[str] = set()\n for session in sessions:\n all_result_ids.update(session.results)\n\n if len(all_result_ids) == 0:\n raise ValueError(\"Sessions list is empty\")\n\n # Ensure a minimum number of unique result IDs in each set\n min_unique_test_sessions: int = int(\n self._test_size_ratio * len(sessions)\n )\n\n # Split the result IDs into train and test sets\n train_result_ids, test_result_ids = train_test_split(\n list(all_result_ids),\n test_size=self._test_size_ratio,\n random_state=self._random_state,\n )\n test_result_ids: Set[str] = set(test_result_ids)\n\n # Split sessions into train and test based on result IDs\n train_sessions: List[ClickstreamSession] = []\n test_sessions: List[ClickstreamSession] = []\n\n for session in sessions:\n if len(session.results) == 0:\n continue\n\n if (\n len(set(session.results) & test_result_ids)\n / len(session.results)\n <= 0.5\n ):\n # If less than 50% of result IDs intersect with the test set, add to the train set\n train_sessions.append(session)\n else:\n test_sessions.append(session)\n\n if len(test_sessions) < min_unique_test_sessions:\n logger.warning(\n f\"Clickstream sessions intersects highly, so they are not split well\"\n )\n random_train_session_indexess: List[int] = random.choices(\n list(range(len(train_sessions))),\n k=min_unique_test_sessions - len(test_sessions),\n )\n for i in reversed(sorted(random_train_session_indexess)):\n test_sessions.append(train_sessions.pop(i))\n\n if len(test_sessions) + len(train_sessions) < len(sessions):\n missed_sessions_count = len(sessions) - (\n len(test_sessions) + len(train_sessions)\n )\n logger.warning(\n f\"Clickstream sessions weren't split correctly, add {missed_sessions_count} more sessions to the train split.\"\n )\n\n for session in sessions:\n if (\n session not in train_sessions\n and session not in test_sessions\n ):\n train_sessions.append(session)\n\n return DatasetDict(\n {\n \"train\": PairedClickstreamDataset(\n train_sessions, self.shuffle\n ),\n \"test\": PairedClickstreamDataset(test_sessions, self.shuffle),\n }\n )"},{"identifier":"TextQueryItem","path":"embedding_studio/embeddings/data/clickstream/text_query_item.py","snippet":"class TextQueryItem(QueryItem):\n text: str\n\n class Config:\n arbitrary_types_allowed = True"},{"identifier":"TextQueryRetriever","path":"embedding_studio/embeddings/data/clickstream/text_query_retriever.py","snippet":"class TextQueryRetriever(QueryRetriever):\n def __call__(self, query: TextQueryItem) -> str:\n if not hasattr(query, \"text\"):\n raise ValueError(f\"Query object does not have text attribute\")\n return query.text"},{"identifier":"AWSS3DataLoader","path":"embedding_studio/embeddings/data/loaders/s3/s3_loader.py","snippet":"class AWSS3DataLoader(DataLoader):\n def __init__(self, retry_config: Optional[RetryConfig] = None, **kwargs):\n \"\"\"Items loader from AWS S3.\n\n :param max_attempts: maximum number of attempts (default: 10)\n :param wait_time_seconds: time to wait between (default: 10)\n :param kwargs: dict data for AWSS3Credentials\n \"\"\"\n super(AWSS3DataLoader, self).__init__(**kwargs)\n self.retry_config = (\n retry_config\n if retry_config\n else AWSS3DataLoader._get_default_retry_config()\n )\n self.credentials = AWSS3Credentials(**kwargs)\n self.attempt_exception_types = [EndpointConnectionError]\n\n @staticmethod\n def _get_default_retry_config() -> RetryConfig:\n default_retry_params = RetryParams(\n max_attempts=settings.DEFAULT_MAX_ATTEMPTS,\n wait_time_seconds=settings.DEFAULT_WAIT_TIME_SECONDS,\n )\n\n config = RetryConfig(default_params=default_retry_params)\n config[\"credentials\"] = RetryParams(\n max_attempts=settings.S3_READ_CREDENTIALS_ATTEMPTS,\n wait_time_seconds=settings.S3_READ_WAIT_TIME_SECONDS,\n )\n config[\"download_data\"] = RetryParams(\n max_attempts=settings.S3_DOWNLOAD_DATA_ATTEMPTS,\n wait_time_seconds=settings.S3_DOWNLOAD_DATA_WAIT_TIME_SECONDS,\n )\n return config\n\n @retry_method(name=\"download_data\")\n def _read_from_s3(self, client, bucket: str, file: str) -> Image:\n return read_from_s3(client, bucket, file)\n\n @retry_method(name=\"credentials\")\n def _get_client(self, task_id: str):\n if (\n self.credentials.aws_access_key_id is None\n or self.credentials.aws_secret_access_key is None\n ) and not self.credentials.use_system_info:\n logger.warning(\n \"No specific AWS credentials, use Anonymous session\"\n )\n s3_client = boto3.client(\n \"s3\", config=Config(signature_version=UNSIGNED)\n )\n else:\n sts_client = boto3.client(\n \"sts\",\n aws_access_key_id=self.credentials.aws_access_key_id,\n aws_secret_access_key=self.credentials.aws_secret_access_key,\n )\n if self.credentials.external_id:\n assumed_role_object = sts_client.assume_role(\n RoleArn=self.credentials.role_arn,\n RoleSessionName=task_id,\n ExternalId=self.credentials.external_id,\n )\n else:\n assumed_role_object = sts_client.assume_role(\n RoleArn=self.credentials.role_arn,\n RoleSessionName=task_id,\n )\n credentials = assumed_role_object[\"Credentials\"]\n s3_client = boto3.client(\n \"s3\",\n aws_access_key_id=credentials[\"AccessKeyId\"],\n aws_secret_access_key=credentials[\"SecretAccessKey\"],\n aws_session_token=credentials[\"SessionToken\"],\n )\n return s3_client\n\n def _generate_dataset_from_s3(\n self, files: List[S3FileMeta]\n ) -> Iterable[Dict]:\n if len(files) == 0:\n logger.warning(\"Nothing to download\")\n else:\n logger.info(\"Connecting to aws s3...\")\n task_id: str = str(uuid.uuid4())\n try:\n s3_client = self._get_client(task_id)\n logger.info(\"Start downloading data from S3...\")\n bad_items_count = 0\n for val in files:\n image = None\n try:\n image: Image = read_from_s3(\n s3_client, val.bucket, val.file\n )\n except Exception as e:\n logger.exception(\n f\"Unable to download an item: {val.bucket}/{val.file} Exception: {str(e)}\"\n )\n\n if image is None:\n logger.error(\n f\"Unable to download {val.file} from {val.bucket}\"\n )\n bad_items_count += 1\n continue\n yield {\"item\": image, \"item_id\": val.id}\n\n if bad_items_count == len(files):\n raise FailedToLoadAnythingFromAWSS3()\n\n except Exception as err:\n logger.error(f\"Failed to load dataset from s3: {err}\")\n raise err\n\n def load(self, items_data: List[S3FileMeta]) -> Dataset:\n return Dataset.from_generator(\n lambda: self._generate_dataset_from_s3(items_data)\n )"},{"identifier":"CLIPItemStorageProducer","path":"embedding_studio/embeddings/data/storages/producers/clip.py","snippet":"class CLIPItemStorageProducer(ItemStorageProducer):\n def __init__(\n self,\n field_normalizer: DatasetFieldsNormalizer,\n id_field_name: Optional[str] = None,\n ):\n super(CLIPItemStorageProducer, self).__init__(\n ImageItemsDatasetDictPreprocessor(field_normalizer, 224),\n id_field_name,\n )"},{"identifier":"DatasetFieldsNormalizer","path":"embedding_studio/embeddings/data/utils/fields_normalizer.py","snippet":"class DatasetFieldsNormalizer:\n ID_FIELD_NAME = \"item_id\"\n ITEM_FIELD_NAME = \"item\"\n\n def __init__(self, item_field_name: str, id_field_name: str):\n \"\"\"Unify column names in DatasetDict, so it can be used in fine-tuning script.\n A dataset should have ID column, related to ID in clickstream.\n\n :param item_field_name: name of column with items.\n :param id_field_name: name of ID column\n \"\"\"\n if not id_field_name:\n raise ValueError(\"id_field_name should be non-empty string\")\n self.id_field_name = id_field_name\n\n if not item_field_name:\n raise ValueError(\"item_field_name should be non-empty string\")\n self.item_field_name = item_field_name\n\n def __call__(self, dataset: DatasetDict) -> DatasetDict:\n id_normalizer = (\n lambda id_value: str(id_value.item())\n if (\n isinstance(id_value, Tensor)\n or isinstance(id_value, FloatTensor)\n )\n else str(id_value)\n )\n for key in dataset.keys():\n if (\n DatasetFieldsNormalizer.ID_FIELD_NAME\n not in dataset.column_names[key]\n ):\n dataset = dataset.rename_column(\n self.id_field_name, DatasetFieldsNormalizer.ID_FIELD_NAME\n )\n else:\n logger.warning(\n f\"Dataset {key} split already has {DatasetFieldsNormalizer.ID_FIELD_NAME} field\"\n )\n\n if (\n DatasetFieldsNormalizer.ITEM_FIELD_NAME\n not in dataset.column_names[key]\n ):\n dataset = dataset.rename_column(\n self.item_field_name,\n DatasetFieldsNormalizer.ITEM_FIELD_NAME,\n )\n else:\n logger.warning(\n f\"Dataset {key} split already has {DatasetFieldsNormalizer.ITEM_FIELD_NAME} field\"\n )\n\n return dataset.map(\n lambda example: {\n DatasetFieldsNormalizer.ID_FIELD_NAME: id_normalizer(\n example[DatasetFieldsNormalizer.ID_FIELD_NAME]\n )\n }\n )"},{"identifier":"CosineProbMarginRankingLoss","path":"embedding_studio/embeddings/losses/prob_cosine_margin_ranking_loss.py","snippet":"class CosineProbMarginRankingLoss(ProbMarginRankingLoss):\n def __init__(self, base_margin: Optional[float] = 1.0):\n \"\"\"Embeddings Fine-tuning Loss (modification of MarginRankingLoss)\n Use sigmoid instead of ReLU + results confidences to ignore noises and mistakes.\n Adapt to cosine similarity / distance\n\n :param base_margin: margin ranking loss margin (default: 1.0)\n \"\"\"\n super(CosineProbMarginRankingLoss, self).__init__(\n base_margin=base_margin\n )\n\n def __adjust(self, adjusted_diff: FloatTensor) -> FloatTensor:\n # The way any wrong difference more than 0.01 is worth to be penaltized\n # Sigmoid with this kind of input return prob > 0.1, for difference between\n # pos and more than 0.001. That's our expected behaviour.\n # TODO: implement calculation of magic numbers\n return -400 * adjusted_diff + 6"},{"identifier":"TextToImageCLIPModel","path":"embedding_studio/embeddings/models/text_to_image/clip.py","snippet":"class TextToImageCLIPModel(EmbeddingsModelInterface):\n def __init__(self, clip_model: SentenceTransformer):\n \"\"\"Wrapper to SentenceTransformer CLIP model.\n Usage: model = TextToImageCLIPModel(SentenceTransformer('clip-ViT-B-32'))\n\n :param clip_model: clip model from SentenceTransformer package\n \"\"\"\n super(TextToImageCLIPModel, self).__init__(same_query_and_items=False)\n self.clip_model = clip_model\n self.text_model = torch.nn.Sequential(\n self.clip_model._modules[\"0\"]\n ._modules[\"model\"]\n ._modules[\"text_model\"],\n PassPoolerOutputLayer(),\n self.clip_model._modules[\"0\"]\n ._modules[\"model\"]\n ._modules[\"text_projection\"],\n )\n\n self.vision_model = torch.nn.Sequential(\n self.clip_model._modules[\"0\"]\n ._modules[\"model\"]\n ._modules[\"vision_model\"],\n PassPoolerOutputLayer(),\n self.clip_model._modules[\"0\"]\n ._modules[\"model\"]\n ._modules[\"visual_projection\"],\n )\n\n def get_query_model_params(self) -> Iterator[Parameter]:\n return self.text_model.parameters()\n\n def get_items_model_params(self) -> Iterator[Parameter]:\n return self.vision_model.parameters()\n\n def fix_query_model(self, num_fixed_layers: int):\n if (\n len(self.text_model._modules[\"0\"].encoder.layers)\n <= num_fixed_layers\n ):\n raise ValueError(\n f\"Number of fixed layers ({num_fixed_layers}) >= number \"\n f'of existing layers ({len(self.text_model._modules[\"0\"].encoder.layers)})'\n )\n\n self.text_model._modules[\"0\"].embeddings.requires_grad = False\n for i, attn in enumerate(self.text_model._modules[\"0\"].encoder.layers):\n if i < num_fixed_layers:\n self.text_model._modules[\"0\"].encoder.layers[\n i\n ].requires_grad = False\n\n def unfix_query_model(self):\n self.text_model._modules[\"0\"].embeddings.requires_grad = True\n for i, attn in enumerate(self.text_model._modules[\"0\"].encoder.layers):\n self.text_model._modules[\"0\"].encoder.layers[\n i\n ].requires_grad = True\n\n def fix_item_model(self, num_fixed_layers: int):\n if (\n len(self.vision_model._modules[\"0\"].encoder.layers)\n <= num_fixed_layers\n ):\n raise ValueError(\n f\"Number of fixed layers ({num_fixed_layers}) >= number \"\n f'of existing layers ({len(self.vision_model._modules[\"0\"].encoder.layers)})'\n )\n\n self.vision_model._modules[\"0\"].embeddings.requires_grad = False\n for i, attn in enumerate(\n self.vision_model._modules[\"0\"].encoder.layers\n ):\n if i < num_fixed_layers:\n self.vision_model._modules[\"0\"].encoder.layers[\n i\n ].requires_grad = False\n\n def unfix_item_model(self):\n self.vision_model._modules[\"0\"].embeddings.requires_grad = True\n for i, attn in enumerate(\n self.vision_model._modules[\"0\"].encoder.layers\n ):\n self.vision_model._modules[\"0\"].encoder.layers[\n i\n ].requires_grad = True\n\n def tokenize(self, query: str) -> List[Dict]:\n return self.clip_model.tokenize([query])\n\n def forward_query(self, query: str) -> FloatTensor:\n if len(query) == 0:\n logger.warning(\"Provided query is empty\")\n\n tokenized = self.tokenize(query)\n return self.text_model.forward(tokenized[\"input_ids\"].to(self.device))\n\n def forward_items(self, items: List[np.array]) -> FloatTensor:\n if len(items) == 0:\n raise ValueError(\"items list must not be empty\")\n\n return self.vision_model.forward(torch.stack(items).to(self.device))"},{"identifier":"SessionWithEvents","path":"embedding_studio/models/clickstream/sessions.py","snippet":"class SessionWithEvents(RegisteredSession):\n events: List[SessionEvent]"},{"identifier":"FineTuningBuilder","path":"embedding_studio/models/plugin.py","snippet":"class FineTuningBuilder:\n data_loader: DataLoader\n query_retriever: QueryRetriever\n clickstream_parser: ClickstreamParser\n clickstream_sessions_splitter: ClickstreamSessionsSplitter\n dataset_fields_normalizer: DatasetFieldsNormalizer\n item_storage_producer: ItemStorageProducer\n accumulators: List[MetricsAccumulator]\n experiments_manager: ExperimentsManager\n fine_tuning_settings: FineTuningSettings\n initial_params: Dict[str, List[Any]]\n ranking_data: RankingData\n initial_max_evals: int = 100"},{"identifier":"PluginMeta","path":"embedding_studio/models/plugin.py","snippet":"class PluginMeta(BaseModel):\n name: str\n version: str = \"1.0.0\"\n description: Optional[str] = None"},{"identifier":"prepare_data","path":"embedding_studio/workers/fine_tuning/data/prepare_data.py","snippet":"def prepare_data(\n clickstream_sessions: List[Union[Dict, SessionWithEvents]],\n parser: ClickstreamParser,\n clickstream_splitter: ClickstreamSessionsSplitter,\n query_retriever: QueryRetriever,\n loader: DataLoader,\n storage_producer: ItemStorageProducer,\n) -> RankingData:\n \"\"\"Prepare fine-tuning data.\n\n :param clickstream_sessions: clickstream sessions\n :param parser: how to parse a clickstream session\n :param clickstream_splitter: how to split clickstream sessions\n :param query_retriever: retrieve query item\n :param loader: load items data\n :param storage_producer: get train/test datasets\n :return: train / test clickstream sessiobs and dataset dict\n \"\"\"\n if len(clickstream_sessions) == 0:\n raise ValueError(\"Empty clickstream sessions list\")\n\n logger.info(\"Parse clickstream sessions data\")\n raw_clickstream_sessions: List[RawClickstreamSession] = [\n (\n parser.parse(session)\n if isinstance(session, dict)\n else parser.parse_from_mongo(session)\n )\n for session in clickstream_sessions\n ]\n\n clickstream_sessions: List[ClickstreamSession] = [\n r.get_session() for r in raw_clickstream_sessions\n ]\n\n logger.info(\"Setup query retriever\")\n query_retriever.setup(clickstream_sessions)\n\n logger.info(\"Split clickstream sessions into train / test\")\n clickstream_dataset = clickstream_splitter.split(clickstream_sessions)\n logger.info(\n f'Splitting is finished, train: {len(clickstream_dataset[\"train\"])} / test: {len(clickstream_dataset[\"test\"])}'\n )\n\n logger.info(\"Get list of files to be loaded\")\n files_to_load: Set[ItemMeta] = set()\n for session in raw_clickstream_sessions:\n files_to_load.update(set([r.item for r in session.results]))\n\n if len(files_to_load) == 0:\n raise ValueError(\"Empty clickstream sessions\")\n\n logger.info(\"Download files and prepare DataDict of ItemStorage values\")\n files_to_load: List[ItemMeta] = list(files_to_load)\n\n dataset: DatasetDict = storage_producer(\n loader.load(files_to_load), clickstream_dataset\n )\n\n return RankingData(clickstream_dataset, dataset)"},{"identifier":"ExperimentsManager","path":"embedding_studio/workers/fine_tuning/experiments/experiments_tracker.py","snippet":"class ExperimentsManager:\n def __init__(\n self,\n tracking_uri: str,\n main_metric: str,\n accumulators: List[MetricsAccumulator],\n is_loss: bool = False,\n n_top_runs: int = 10,\n requirements: Optional[str] = None,\n retry_config: Optional[RetryConfig] = None,\n ):\n \"\"\"Wrapper over mlflow package to manage certain fine-tuning experiments.\n\n :param tracking_uri: url of MLFlow server\n :param main_metric: name of main metric that will be used to find best model\n :param accumulators: accumulators of metrics to be logged\n :param is_loss: is main metric loss (if True, then best quality is minimal) (default: False)\n :param n_top_runs: how many hyper params group consider to be used in following tuning steps (default: 10)\n :param requirements: extra requirements to be passed to mlflow.pytorch.log_model (default: None)\n :param retry_config: retry policy (default: None)\n \"\"\"\n if not isinstance(tracking_uri, str) or len(tracking_uri) == 0:\n raise ValueError(\n f\"MLFlow tracking URI value should be a not empty string\"\n )\n mlflow.set_tracking_uri(tracking_uri)\n self._tracking_uri = tracking_uri\n if self._tracking_uri.endswith(\"/\"):\n self._tracking_uri = self._tracking_uri[:-1]\n\n self.retry_config = (\n retry_config\n if retry_config\n else ExperimentsManager._get_default_retry_config()\n )\n self.attempt_exception_types = [RestException]\n\n if not isinstance(main_metric, str) or len(main_metric) == 0:\n raise ValueError(f\"main_metric value should be a not empty string\")\n self.main_metric = main_metric\n self._metric_field = f\"metrics.{self.main_metric}\"\n\n self._n_top_runs = n_top_runs\n self._is_loss = is_loss\n\n if len(accumulators) == 0:\n logger.warning(\n \"No accumulators were provided, there will be no metrics logged except loss\"\n )\n self._accumulators = accumulators\n\n self._requirements: List[str] = (\n _get_base_requirements() if requirements is None else requirements\n )\n\n self._iteration_experiment = None\n self._tuning_iteration = None\n self._tuning_iteration_id = None\n\n self._run = None\n self._run_params = None\n self._run_id = None\n\n def _check_artifact_exists(self, run_id, artifact_path):\n client = mlflow.MlflowClient()\n artifacts = client.list_artifacts(run_id, path=artifact_path)\n return any(artifact.path == artifact_path for artifact in artifacts)\n\n @staticmethod\n def _get_default_retry_config() -> RetryConfig:\n default_retry_params = RetryParams(\n max_attempts=settings.DEFAULT_MAX_ATTEMPTS,\n wait_time_seconds=settings.DEFAULT_WAIT_TIME_SECONDS,\n )\n\n config = RetryConfig(default_params=default_retry_params)\n config[\"log_metric\"] = RetryParams(\n max_attempts=settings.MLFLOW_LOG_METRIC_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_LOG_METRIC_WAIT_TIME_SECONDS,\n )\n config[\"log_param\"] = RetryParams(\n max_attempts=settings.MLFLOW_LOG_PARAM_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_LOG_PARAM_WAIT_TIME_SECONDS,\n )\n config[\"log_model\"] = RetryParams(\n max_attempts=settings.MLFLOW_LOG_MODEL_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_LOG_MODEL_WAIT_TIME_SECONDS,\n )\n config[\"load_model\"] = RetryParams(\n max_attempts=settings.MLFLOW_LOAD_MODEL_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_LOAD_MODEL_WAIT_TIME_SECONDS,\n )\n config[\"delete_model\"] = RetryParams(\n max_attempts=settings.MLFLOW_DELETE_MODEL_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_DELETE_MODEL_WAIT_TIME_SECONDS,\n )\n config[\"search_runs\"] = RetryParams(\n max_attempts=settings.MLFLOW_SEARCH_RUNS_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_SEARCH_RUNS_WAIT_TIME_SECONDS,\n )\n config[\"end_run\"] = RetryParams(\n max_attempts=settings.MLFLOW_END_RUN_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_END_RUN_WAIT_TIME_SECONDS,\n )\n config[\"get_run\"] = RetryParams(\n max_attempts=settings.MLFLOW_GET_RUN_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_GET_RUN_WAIT_TIME_SECONDS,\n )\n config[\"search_experiments\"] = RetryParams(\n max_attempts=settings.MLFLOW_SEARCH_EXPERIMENTS_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_SEARCH_EXPERIMENTS_WAIT_TIME_SECONDS,\n )\n config[\"delete_experiment\"] = RetryParams(\n max_attempts=settings.MLFLOW_DELETE_EXPERIMENT_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_DELETE_EXPERIMENT_WAIT_TIME_SECONDS,\n )\n config[\"create_experiment\"] = RetryParams(\n max_attempts=settings.MLFLOW_CREATE_EXPERIMENT_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_CREATE_EXPERIMENT_WAIT_TIME_SECONDS,\n )\n config[\"get_experiment\"] = RetryParams(\n max_attempts=settings.MLFLOW_GET_EXPERIMENT_ATTEMPTS,\n wait_time_seconds=settings.MLFLOW_GET_EXPERIMENT_WAIT_TIME_SECONDS,\n )\n\n return config\n\n @property\n def is_loss(self) -> bool:\n return self._is_loss\n\n def __del__(self):\n self.finish_run()\n self.finish_iteration()\n\n def is_retryable_error(self, e: Exception) -> bool:\n return False\n\n def _get_model_exists_filter(self) -> str:\n return \"metrics.model_uploaded = 1\"\n\n def _get_artifact_url(self, run_id: str, artifact_path: str) -> str:\n return (\n f\"{self._tracking_uri}/get-artifact?path=\"\n f'{urllib.parse.quote(artifact_path, safe=\"\")}&run_uuid={run_id}'\n )\n\n @retry_method(name=\"log_model\")\n def upload_initial_model(self, model: EmbeddingsModelInterface):\n \"\"\"Upload the very first, initial model to the mlflow server\n\n :param model: model to be uploaded\n \"\"\"\n self.finish_iteration()\n experiment_id = get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME)\n if experiment_id is None:\n logger.info(\n f\"Can't find any active iteration with name: {INITIAL_EXPERIMENT_NAME}\"\n )\n try:\n logger.info(\"Create initial experiment\")\n mlflow.create_experiment(INITIAL_EXPERIMENT_NAME)\n except MlflowException as e:\n if \"Cannot set a deleted experiment\" in str(e):\n logger.error(\n f\"Creation of initial experiment is failed: experiment with the same name {INITIAL_EXPERIMENT_NAME} is deleted, but not archived\"\n )\n experiments = mlflow.search_experiments(\n view_type=mlflow.entities.ViewType.ALL\n )\n deleted_experiment_id = None\n\n for exp in experiments:\n if exp.name == INITIAL_EXPERIMENT_NAME:\n deleted_experiment_id = exp.experiment_id\n break\n\n logger.info(\n f\"Restore deleted experiment with the same name: {INITIAL_EXPERIMENT_NAME}\"\n )\n mlflow.tracking.MlflowClient().restore_experiment(\n deleted_experiment_id\n )\n logger.info(\n f\"Archive deleted experiment with the same name: {INITIAL_EXPERIMENT_NAME}\"\n )\n mlflow.tracking.MlflowClient().rename_experiment(\n deleted_experiment_id,\n INITIAL_EXPERIMENT_NAME + \"_archive\",\n )\n logger.info(\n f\"Delete archived experiment with the same name: {INITIAL_EXPERIMENT_NAME}\"\n )\n mlflow.delete_experiment(deleted_experiment_id)\n logger.info(f\"Create initial experiment\")\n mlflow.create_experiment(INITIAL_EXPERIMENT_NAME)\n else:\n raise e\n\n with mlflow.start_run(\n experiment_id=get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME),\n run_name=INITIAL_RUN_NAME,\n ) as run:\n logger.info(\n f\"Upload initial model to {INITIAL_EXPERIMENT_NAME} / {INITIAL_RUN_NAME}\"\n )\n if self._check_artifact_exists(\n get_run_id_by_name(\n get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME),\n INITIAL_RUN_NAME,\n ),\n \"model\",\n ):\n logger.info(\"Model is already uploaded\")\n return\n\n mlflow.pytorch.log_model(\n model, \"model\", pip_requirements=self._requirements\n )\n logger.info(\"Uploading is finished\")\n\n @retry_method(name=\"load_model\")\n def download_initial_model(self) -> EmbeddingsModelInterface:\n \"\"\"Download initial model.\n\n :return: initial embeddings model\n \"\"\"\n model_uri: str = f\"runs:/{get_run_id_by_name(get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME), INITIAL_RUN_NAME)}/model\"\n logger.info(f\"Download the model from {model_uri}\")\n model = mlflow.pytorch.load_model(model_uri)\n logger.info(\"Downloading is finished\")\n return model\n\n @retry_method(name=\"search_runs\")\n def get_top_params(self) -> Optional[List[FineTuningParams]]:\n \"\"\"Get top N previous fine-tuning iteration best params\n\n :return: fine-tuning iteration params\n \"\"\"\n initial_id: Optional[str] = get_experiment_id_by_name(\n INITIAL_EXPERIMENT_NAME\n )\n last_session_id: Optional[str] = self.get_previous_iteration_id()\n if initial_id == last_session_id:\n logger.warning(\n \"Can't retrieve top params, no previous iteration in history\"\n )\n return None\n\n else:\n runs: pd.DataFrame = mlflow.search_runs(\n experiment_ids=[last_session_id],\n filter_string=self._get_model_exists_filter(),\n )\n runs = runs[runs.status == \"FINISHED\"] # and only finished ones\n if runs.shape[0] == 0:\n logger.warning(\n \"Can't retrieve top params, no previous iteration's finished runs with uploaded model in history\"\n )\n return None\n\n # Get the indices that would sort the DataFrame based on the specified parameter\n sorted_indices: np.ndarray = np.argsort(\n runs[self._metric_field].values\n )\n if not self.is_loss:\n sorted_indices = sorted_indices[\n ::-1\n ] # Use [::-1] to sort in descending order\n\n # Extract the top N rows based on the sorted indices\n top_n_rows: np.ndarray = runs.iloc[\n sorted_indices[: self._n_top_runs]\n ]\n\n # Define a mapping dictionary to remove the \"params.\" prefix\n column_mapping: Dict[str, str] = {\n col: col.replace(\"params.\", \"\") for col in top_n_rows.columns\n }\n\n # Rename the columns\n top_n_rows: np.ndarray = top_n_rows.rename(\n columns=column_mapping\n ).to_dict(orient=\"records\")\n\n return [FineTuningParams(**row) for row in top_n_rows]\n\n def _get_best_previous_run_id(self) -> Tuple[Optional[str], bool]:\n initial_id: Optional[str] = get_experiment_id_by_name(\n INITIAL_EXPERIMENT_NAME\n )\n last_session_id: Optional[str] = self.get_previous_iteration_id()\n if initial_id == last_session_id or last_session_id is None:\n return None, True\n else:\n run_id, _ = self._get_best_quality(last_session_id)\n return run_id, False\n\n def _get_best_current_run_id(self) -> Tuple[Optional[str], bool]:\n initial_id: Optional[str] = get_experiment_id_by_name(\n INITIAL_EXPERIMENT_NAME\n )\n if (\n initial_id == self._tuning_iteration_id\n or self._tuning_iteration_id is None\n ):\n return None, True\n else:\n run_id, _ = self._get_best_quality(self._tuning_iteration_id)\n return run_id, False\n\n @retry_method(name=\"load_model\")\n def get_last_model_url(self) -> Optional[str]:\n run_id, is_initial = self._get_best_previous_run_id()\n if is_initial:\n logger.warning(\n \"Can't get the best model URL, no previous iteration in history\"\n )\n return None\n else:\n if run_id is None:\n logger.warning(\n \"Can't get the best model URL, no previous iterations \"\n \"finished runs with uploaded model in history\"\n )\n return None\n path = MODEL_ARTIFACT_PATH\n return self._get_artifact_url(run_id, path)\n\n @retry_method(name=\"load_model\")\n def get_current_model_url(self) -> Optional[str]:\n run_id, is_initial = self._get_best_current_run_id()\n if is_initial:\n logger.warning(\n \"Can't get the best model URL, current run is initial\"\n )\n return None\n\n if run_id is None:\n logger.warning(\n \"Can't get the best model URL, no iterations \"\n \"finished runs with uploaded model in history\"\n )\n return None\n path = MODEL_ARTIFACT_PATH\n return self._get_artifact_url(run_id, path)\n\n @retry_method(name=\"load_model\")\n def get_last_model(self) -> EmbeddingsModelInterface:\n \"\"\"Get previous iteration best embedding model.\n\n :return: best embedding model\n \"\"\"\n run_id, is_initial = self._get_best_previous_run_id()\n if is_initial:\n logger.warning(\n \"Download initial model, no previous iteration in history\"\n )\n return self.download_initial_model()\n\n else:\n if run_id is None:\n logger.warning(\n \"Download initial model, no previous iteration's \"\n \"finished runs with uploaded model in history\"\n )\n return self.download_initial_model()\n else:\n model_uri: str = f\"runs:/{run_id}/model\"\n logger.info(f\"Download the model from {model_uri}\")\n model = mlflow.pytorch.load_model(model_uri)\n logger.info(\"Downloading is finished\")\n return model\n\n @retry_method(name=\"load_model\")\n def get_current_model(self) -> Optional[EmbeddingsModelInterface]:\n \"\"\"Get current iteration best embedding model.\n\n :return: best embedding model\n \"\"\"\n if self._tuning_iteration is None:\n logger.error(\"No current iteration, can't get any model\")\n return\n\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\n logger.info(\"Download initial model\")\n return self.download_initial_model()\n\n run_id, is_initial = self._get_best_current_run_id()\n model_uri: str = f\"runs:/{run_id}/model\"\n logger.info(f\"Download the model from {model_uri}\")\n model = mlflow.pytorch.load_model(model_uri)\n logger.info(\"Downloading is finished\")\n return model\n\n @retry_method(name=\"search_experiments\")\n def get_previous_iteration_id(self) -> Optional[str]:\n if (\n self._tuning_iteration == INITIAL_EXPERIMENT_NAME\n or self._tuning_iteration is None\n ):\n logger.warning(\n f\"Can't find previous iteration - no current iteration was setup\"\n )\n return None\n\n plugin_name = f\"{self._tuning_iteration.plugin_name}\"\n experiments: List[Experiment] = [\n e\n for e in mlflow.search_experiments()\n if (\n e.name.startswith(EXPERIMENT_PREFIX)\n and e.name.find(plugin_name) != -1\n and e.name != str(self._tuning_iteration)\n )\n ]\n if len(experiments) == 0:\n logger.warning(\"No iteration found\")\n return None\n else:\n return max(\n experiments, key=lambda exp: exp.creation_time\n ).experiment_id\n\n @retry_method(name=\"delete_experiment\")\n def delete_previous_iteration(self):\n experiment_id: Optional[str] = self.get_previous_iteration_id()\n\n logger.info(\"Delete models of previous iteration.\")\n runs = mlflow.search_runs(\n experiment_ids=[experiment_id],\n filter_string=self._get_model_exists_filter(),\n )\n runs = runs[runs.status == \"FINISHED\"]\n run_ids = runs[\"run_id\"].tolist()\n\n for run_id in run_ids:\n self.delete_model(run_id, experiment_id)\n\n if experiment_id is not None:\n logger.info(\n f\"Iteration with ID {experiment_id} is going to be deleted\"\n )\n mlflow.tracking.MlflowClient().rename_experiment(\n experiment_id, INITIAL_EXPERIMENT_NAME + \"_archive\"\n )\n mlflow.delete_experiment(experiment_id)\n else:\n logger.warning(\n \"Can't delete a previous iteration, no previous iteration in history\"\n )\n\n @retry_method(name=\"create_experiment\")\n def set_iteration(self, iteration: FineTuningIteration):\n \"\"\"Start a new fine-tuning session.\n\n :param iteration: fine-tuning iteration info\n \"\"\"\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\n self.finish_iteration()\n\n logger.info(\"Start a new fine-tuning iterations\")\n\n self._tuning_iteration = iteration\n self._tuning_iteration_id = get_experiment_id_by_name(str(iteration))\n if self._tuning_iteration_id is None:\n self._tuning_iteration_id = mlflow.create_experiment(\n str(iteration)\n )\n\n self._iteration_experiment = mlflow.set_experiment(\n experiment_id=self._tuning_iteration_id\n )\n\n @retry_method(name=\"start_run\")\n def set_run(self, params: FineTuningParams) -> bool:\n \"\"\"Start a new run with provided fine-tuning params\n\n :param params: provided fine-tuning params\n :return: True if it's a finished run (otherwise False)\n \"\"\"\n convert_value = (\n lambda value: \", \".join(map(str, value))\n if isinstance(value, list)\n else value\n )\n\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\n # TODO: implement exception\n raise ValueError(\"You can't start run for initial iteration\")\n\n if self._run is not None:\n self.finish_run()\n\n logger.info(\n f\"Start a new run for iteration {self._tuning_iteration_id} with params:\\n\\t{str(params)}\"\n )\n\n self._run_params = params\n run_name: str = self._run_params.id\n self._run_id = get_run_id_by_name(self._tuning_iteration_id, run_name)\n\n self._run = mlflow.start_run(\n self._run_id, self._tuning_iteration_id, run_name\n )\n if self._run_id is None:\n self._run_id = self._run.info.run_id\n for key, value in dict(self._tuning_iteration).items():\n mlflow.log_param(key, convert_value(value))\n\n for key, value in dict(self._run_params).items():\n mlflow.log_param(key, convert_value(value))\n\n mlflow.log_metric(\"model_uploaded\", 0)\n\n return False\n else:\n return self._run.info.status == \"FINISHED\"\n\n @retry_method(name=\"search_runs\")\n def model_is_uploaded(self) -> bool:\n runs: pd.DataFrame = mlflow.search_runs(\n experiment_ids=[self._tuning_iteration_id],\n filter_string=self._get_model_exists_filter(),\n )\n runs = runs[runs[\"run_id\"] == self._run_id]\n return runs.shape[0] > 0\n\n @retry_method(name=\"get_experiment\")\n def finish_iteration(self):\n logger.info(f\"Finish current iteration {self._tuning_iteration_id}\")\n self._tuning_iteration = INITIAL_EXPERIMENT_NAME\n self._tuning_iteration_id = get_experiment_id_by_name(\n INITIAL_EXPERIMENT_NAME\n )\n\n if self._tuning_iteration_id is None:\n self._iteration_experiment = mlflow.set_experiment(\n experiment_name=INITIAL_EXPERIMENT_NAME\n )\n self._tuning_iteration_id = (\n self._iteration_experiment.experiment_id\n )\n else:\n self._iteration_experiment = mlflow.set_experiment(\n experiment_id=self._tuning_iteration_id\n )\n\n logger.info(f\"Current iteration is finished\")\n\n @retry_method(name=\"end_run\")\n def finish_run(self):\n logger.info(\n f\"Finish current run {self._tuning_iteration_id} / {self._run_id}\"\n )\n for accumulator in self._accumulators:\n accumulator.clear()\n\n mlflow.end_run()\n\n # Set params to default None\n self._run = None\n self._run_params = None\n self._run_id = None\n\n logger.info(f\"Current run is finished\")\n\n @retry_method(name=\"log_param\")\n def _set_model_as_deleted(self, run_id: str, experiment_id: str):\n with mlflow.start_run(\n run_id=run_id, experiment_id=experiment_id\n ) as run:\n mlflow.log_metric(\"model_deleted\", 1)\n mlflow.log_metric(\"model_uploaded\", 0)\n\n @retry_method(name=\"delete_model\")\n def _delete_model(self, run_id: str, experiment_id: str) -> bool:\n logger.warning(\n f\"Unable to delete a model for run {run_id}, MLFlow has no such functionality, please implement on your own.\"\n )\n return False\n\n @retry_method(name=\"get_run\")\n def delete_model(self, run_id: str, experiment_id: Optional[str] = None):\n experiment_id = (\n self._tuning_iteration_id\n if experiment_id is None\n else experiment_id\n )\n if experiment_id is None:\n raise ValueError(\n f\"No iteration was initialized, unable to delete model.\"\n )\n\n if experiment_id == INITIAL_EXPERIMENT_NAME:\n raise ValueError(f\"Initial model can't be deleted.\")\n\n run_info = None\n try:\n run_info = mlflow.get_run(run_id=run_id)\n except RestException as e:\n if e.get_http_status_code() == 404:\n logger.exception(f\"Run with ID {run_id} doesn't exist.\")\n else:\n raise e\n\n if run_info is not None:\n runs: pd.DataFrame = mlflow.search_runs(\n filter_string=self._get_model_exists_filter()\n )\n runs = runs[runs[\"run_id\"] == run_id]\n if runs.shape[0] == 0:\n logger.warning(\n f\"Run {run_id} has no model being uploaded. Nothing to delete\"\n )\n\n else:\n deleted = None\n try:\n deleted = self._delete_model(run_id, experiment_id)\n except MaxAttemptsReachedException:\n pass\n\n if deleted:\n self._set_model_as_deleted(run_id, experiment_id)\n\n @retry_method(name=\"log_model\")\n def save_model(\n self, model: EmbeddingsModelInterface, best_only: bool = True\n ):\n \"\"\"Save fine-tuned embedding model\n\n :param model: model to be saved\n :param best_only: save only if it's the best (default: True)\n \"\"\"\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\n raise ValueError(\n f\"Can't save not initial model for {INITIAL_EXPERIMENT_NAME} experiment\"\n )\n\n if self._run_id is None:\n raise ValueError(\"There is no current Run\")\n\n logger.info(\n f\"Save model for {self._tuning_iteration_id} / {self._run_id}\"\n )\n if not best_only:\n mlflow.pytorch.log_model(\n model, \"model\", pip_requirements=self._requirements\n )\n mlflow.log_metric(\"model_uploaded\", 1)\n logger.info(\"Upload is finished\")\n else:\n current_quality = self.get_quality()\n best_run_id, best_quality = self.get_best_quality()\n\n if best_run_id is None or (\n current_quality <= best_quality\n if self.is_loss\n else current_quality >= best_quality\n ):\n mlflow.pytorch.log_model(\n model, \"model\", pip_requirements=self._requirements\n )\n mlflow.log_metric(\"model_uploaded\", 1)\n logger.info(\"Upload is finished\")\n\n if best_run_id is not None:\n self.delete_model(best_run_id)\n else:\n logger.info(\"Not the best run - ignore saving\")\n\n @retry_method(name=\"log_metric\")\n def save_metric(self, metric_value: MetricValue):\n \"\"\"Accumulate and save metric value\n\n :param metric_value: value to be logged\n \"\"\"\n for accumulator in self._accumulators:\n for name, value in accumulator.accumulate(metric_value):\n mlflow.log_metric(name, value)\n\n @retry_method(name=\"search_runs\")\n def get_quality(self) -> float:\n \"\"\"Current run quality value\n\n :return: quality value\n \"\"\"\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\n raise ValueError(\n f\"No metrics for {INITIAL_EXPERIMENT_NAME} experiment\"\n )\n\n if self._run_id is None:\n raise ValueError(\"There is no current Run\")\n\n runs: pd.DataFrame = mlflow.search_runs(\n experiment_ids=[self._tuning_iteration_id]\n )\n quality: np.ndarray = runs[runs.run_id == self._run_id][\n self._metric_field\n ]\n return float(quality) if quality.shape[0] == 1 else float(quality[0])\n\n @retry_method(name=\"search_runs\")\n def _get_best_quality(\n self, experiment_id: str\n ) -> Tuple[Optional[str], float]:\n runs: pd.DataFrame = mlflow.search_runs(\n experiment_ids=[experiment_id],\n filter_string=self._get_model_exists_filter(),\n )\n runs = runs[runs.status == \"FINISHED\"] # and not finished ones\n if runs.shape[0] == 0:\n logger.warning(\n \"No finished experiments found with model uploaded, except initial\"\n )\n return None, 0.0\n\n else:\n value: float = (\n runs[self._metric_field].min()\n if self.is_loss\n else runs[self._metric_field].max()\n )\n best: pd.DataFrame = runs[runs[self._metric_field] == value][\n [\"run_id\", self._metric_field]\n ]\n return list(best.itertuples(index=False, name=None))[0]\n\n def get_best_quality(self) -> Tuple[str, float]:\n \"\"\"Get current fine-tuning iteration best quality\n\n :return: run_id and best metric value\n \"\"\"\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\n raise ValueError(\n f\"No metrics for {INITIAL_EXPERIMENT_NAME} experiment\"\n )\n\n return self._get_best_quality(self._tuning_iteration_id)"},{"identifier":"FineTuningSettings","path":"embedding_studio/workers/fine_tuning/experiments/finetuning_settings.py","snippet":"class FineTuningSettings(BaseModel):\n \"\"\"\n\n :param loss_func: loss object for a ranking task\n :param metric_calculators: list of trackable metrics calculators (default: None)\n by default only DistanceShift metric\n :param ranker: ranking function (query, items) -> ranks (defult: cosine similarity)\n :param is_similarity: is ranking function similarity like or distance (default: True)\n :param confidence_calculator: function to calculate results confidences (default: dummy_confidences)\n :param step_size: optimizer steps (default: 500)\n :param gamma: optimizers gamma (default: 0.9)\n :param num_epochs: num of training epochs (default: 10)\n :param batch_size: count of sessions in a batch (default: 1)\n :param test_each_n_sessions: frequency of validation, if value in range [0, 1] - used as ratio (default: -1)\n \"\"\"\n\n loss_func: RankingLossInterface\n metric_calculators: Optional[List[MetricCalculator]] = None\n ranker: Optional[\n Callable[[FloatTensor, FloatTensor], FloatTensor]\n ] = COSINE_SIMILARITY\n is_similarity: Optional[bool] = True\n confidence_calculator: Optional[Callable] = dummy_confidences\n step_size: Optional[int] = 500\n gamma: Optional[float] = 0.9\n num_epochs: Optional[int] = 10\n batch_size: Optional[int] = 1\n test_each_n_sessions: Optional[Union[float, int]] = -1\n\n class Config:\n arbitrary_types_allowed = True"},{"identifier":"INITIAL_PARAMS","path":"embedding_studio/workers/fine_tuning/experiments/initial_params/clip.py","snippet":"INITIAL_PARAMS: Dict[str, List[Union[int, float]]] = {\n \"num_fixed_layers\": [5, 6, 7, 8],\n \"query_lr\": [1e-4, 5e-5, 1e-5, 5e-6, 1e-6, 5e-7],\n \"items_lr\": [1e-4, 5e-5, 1e-5, 5e-6, 1e-6, 5e-7],\n \"query_weight_decay\": [0.0, 1e-6, 1e-5, 1e-4],\n \"items_weight_decay\": [0.0, 1e-6, 1e-5, 1e-4],\n \"margin\": [0.01, 0.025, 0.05],\n}"},{"identifier":"MetricsAccumulator","path":"embedding_studio/workers/fine_tuning/experiments/metrics_accumulator.py","snippet":"class MetricsAccumulator:\n def __init__(\n self,\n name: str,\n calc_mean: bool = False,\n calc_sliding: bool = False,\n calc_min: bool = False,\n calc_max: bool = False,\n window_size: int = 10,\n ):\n \"\"\"Accumulator of metric values + calculator of aggregations like mean, max, min, sliding_mean.\n\n :param name: metric name (metrics with other name will be ignored)\n :param calc_mean: should accumulator calculate mean value (default: False)\n :param calc_sliding: should accumulator calculate sliding mean value (default: False)\n :param calc_min: should accumulator calculate min value (default: False)\n :param calc_max: should accumulator calculate max value (default: False)\n :param window_size: size of sliding window (default: 10)\n \"\"\"\n if not isinstance(name, str) or len(name) == 0:\n raise ValueError(\"MetricsAccumulator's name should not be empty\")\n\n self._name = name\n\n if not isinstance(calc_mean, bool):\n raise ValueError(\"calc_mean value should be bool\")\n self._calc_mean = calc_mean\n\n if not isinstance(calc_sliding, bool):\n raise ValueError(\"calc_sliding value should be bool\")\n self._calc_sliding = calc_sliding\n\n if not isinstance(calc_min, bool):\n raise ValueError(\"calc_min value should be bool\")\n self._calc_min = calc_min\n\n if not isinstance(calc_max, bool):\n raise ValueError(\"calc_max value should be bool\")\n self._calc_max = calc_max\n\n if not isinstance(window_size, int) or window_size <= 1:\n raise ValueError(\n \"window_size value should be integer with value more than 1\"\n )\n\n self._window_size = window_size\n self._values = []\n\n @property\n def name(self) -> str:\n return self._name\n\n def clear(self):\n \"\"\"Clear accumulator\"\"\"\n self._values = []\n\n def accumulate(self, value: MetricValue) -> List[Tuple[str, float]]:\n \"\"\"Add metric value to an accumulator.\n\n :param value: metric to be accumulated\n :return: aggregations\n \"\"\"\n if self.name == value.name:\n self._values.append(value.value)\n\n return self.aggregate()\n\n return []\n\n def aggregate(self) -> List[Tuple[str, float]]:\n \"\"\"Aggregate accumulated metrics\n\n :return: metric aggregations (last, mean, sliding, min, max)\n \"\"\"\n aggregations: List[Tuple[str, float]] = []\n if len(self._values) > 0:\n aggregations.append((self.name, self._values[-1]))\n if self._calc_mean:\n aggregations.append(\n (f\"mean_{self.name}\", float(np.mean(self._values)))\n )\n\n if self._calc_sliding:\n slide_value = float(\n np.mean(self._values)\n if len(self._values) < self._window_size\n else np.mean(self._values[-self._window_size :])\n )\n aggregations.append((f\"sliding_{self.name}\", slide_value))\n\n if self._calc_min:\n aggregations.append((f\"min_{self.name}\", np.min(self._values)))\n\n if self._calc_max:\n aggregations.append((f\"max_{self.name}\", np.max(self._values)))\n\n return aggregations"}],"string":"[\n {\n \"identifier\": \"settings\",\n \"path\": \"embedding_studio/core/config.py\",\n \"snippet\": \"class Settings(BaseSettings):\\n API_V1_STR: str = \\\"/api/v1\\\"\\n SECRET_KEY: str = secrets.token_urlsafe(32)\\n ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8\\n BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = []\\n FINETUNING_MONGO_HOST: str = os.getenv(\\\"FINETUNING_MONGO_HOST\\\", \\\"mongo\\\")\\n FINETUNING_MONGO_PORT: int = os.getenv(\\\"FINETUNING_MONGO_PORT\\\", 27017)\\n FINETUNING_MONGO_DB_NAME: str = os.getenv(\\n \\\"FINETUNING_MONGO_DB_NAME\\\", \\\"embedding_studio\\\"\\n )\\n FINETUNING_MONGO_USERNAME: str = os.getenv(\\n \\\"FINETUNING_MONGO_USERNAME\\\", \\\"root\\\"\\n )\\n FINETUNING_MONGO_PASSWORD: str = os.getenv(\\n \\\"FINETUNING_MONGO_PASSWORD\\\", \\\"mongopassword\\\"\\n )\\n FINETUNING_MONGO_URL: str = (\\n f\\\"mongodb://{FINETUNING_MONGO_USERNAME}:{FINETUNING_MONGO_PASSWORD}@\\\"\\n f\\\"{FINETUNING_MONGO_HOST}:{FINETUNING_MONGO_PORT}\\\"\\n )\\n CLICKSTREAM_MONGO_HOST: str = os.getenv(\\\"CLICKSTREAM_MONGO_HOST\\\", \\\"mongo\\\")\\n CLICKSTREAM_MONGO_PORT: int = os.getenv(\\\"CLICKSTREAM_MONGO_PORT\\\", 27017)\\n CLICKSTREAM_MONGO_DB_NAME: str = os.getenv(\\n \\\"CLICKSTREAM_MONGO_DB_NAME\\\", \\\"embedding_studio\\\"\\n )\\n CLICKSTREAM_MONGO_USERNAME: str = os.getenv(\\n \\\"CLICKSTREAM_MONGO_USERNAME\\\", \\\"root\\\"\\n )\\n CLICKSTREAM_MONGO_PASSWORD: str = os.getenv(\\n \\\"CLICKSTREAM_MONGO_PASSWORD\\\", \\\"mongopassword\\\"\\n )\\n CLICKSTREAM_MONGO_URL: str = (\\n f\\\"mongodb://{CLICKSTREAM_MONGO_USERNAME}:{CLICKSTREAM_MONGO_PASSWORD}@\\\"\\n f\\\"{CLICKSTREAM_MONGO_HOST}:{CLICKSTREAM_MONGO_PORT}\\\"\\n )\\n REDIS_HOST: str = os.getenv(\\\"REDIS_HOST\\\", \\\"localhost\\\")\\n REDIS_PORT: int = os.getenv(\\\"REDIS_PORT\\\", 6379)\\n REDIS_PASSWORD: str = os.getenv(\\\"REDIS_PASSWORD\\\", \\\"redispassword\\\")\\n REDIS_URL: str = f\\\"redis://{REDIS_HOST}:{REDIS_PORT}/0\\\"\\n MINIO_HOST: str = os.getenv(\\\"MINIO_HOST\\\", \\\"localhost\\\")\\n MINIO_PORT: int = os.getenv(\\\"MINIO_PORT\\\", 9000)\\n MINIO_ROOT_USER: str = os.getenv(\\\"MINIO_ROOT_USER\\\", \\\"root\\\")\\n MINIO_ROOT_PASSWORD: str = os.getenv(\\n \\\"MINIO_ROOT_PASSWORD\\\", \\\"miniopassword\\\"\\n )\\n MINIO_DEFAULT_BUCKETS: str = os.getenv(\\n \\\"MINIO_DEFAULT_BUCKETS\\\", \\\"embeddingstudio\\\"\\n )\\n MINIO_ACCESS_KEY: str = os.getenv(\\n \\\"MINIO_ACCESS_KEY\\\", \\\"mtGNiEvoTL6C0EXAMPLE\\\"\\n )\\n MINIO_SECRET_KEY: str = os.getenv(\\n \\\"MINIO_SECRET_KEY\\\", \\\"HY5JserXAaWmphNyCpQPEXAMPLEKEYEXAMPLEKEY\\\"\\n )\\n MYSQL_HOST: str = os.getenv(\\\"MYSQL_HOST\\\", \\\"localhost\\\")\\n MYSQL_PORT: int = os.getenv(\\\"MYSQL_PORT\\\", 3306)\\n MYSQL_DATABASE: str = os.getenv(\\\"MYSQL_DATABASE\\\", \\\"mlflow\\\")\\n MYSQL_USER: str = os.getenv(\\\"MYSQL_USER\\\", \\\"mlflow_user\\\")\\n MYSQL_PASSWORD: str = os.getenv(\\\"MYSQL_PASSWORD\\\", \\\"Baxp3O5rUvpIxiD77BfZ\\\")\\n MYSQL_ROOT_PASSWORD: str = os.getenv(\\n \\\"MYSQL_ROOT_PASSWORD\\\", \\\"PrK5qmPTDsm2IYKvHVG8\\\"\\n )\\n MLFLOW_HOST: str = os.getenv(\\\"MLFLOW_HOST\\\", \\\"localhost\\\")\\n MLFLOW_PORT: int = os.getenv(\\\"MLFLOW_PORT\\\", 5001)\\n MLFLOW_TRACKING_URI: str = f\\\"http://{MLFLOW_HOST}:{MLFLOW_PORT}\\\"\\n ES_PLUGINS_PATH: str = os.getenv(\\\"ES_PLUGINS_PATH\\\", \\\"plugins\\\")\\n FINE_TUNING_WORKER_MAX_RETRIES: int = os.getenv(\\n \\\"FINE_TUNING_WORKER_MAX_RETRIES\\\", 3\\n )\\n FINE_TUNING_WORKER_TIME_LIMIT: int = os.getenv(\\n \\\"FINE_TUNING_WORKER_TIME_LIMIT\\\", 18000000\\n )\\n DEFAULT_MAX_ATTEMPTS: int = os.getenv(\\\"DEFAULT_MAX_ATTEMPTS\\\", 3)\\n DEFAULT_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"DEFAULT_WAIT_TIME_SECONDS\\\", 3.0\\n )\\n S3_READ_CREDENTIALS_ATTEMPTS: int = os.getenv(\\n \\\"S3_READ_CREDENTIALS_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n S3_READ_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"S3_READ_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n S3_DOWNLOAD_DATA_ATTEMPTS: int = os.getenv(\\n \\\"S3_DOWNLOAD_DATA_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n S3_DOWNLOAD_DATA_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"S3_DOWNLOAD_DATA_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_LOG_METRIC_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_LOG_METRIC_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_LOG_METRIC_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_LOG_METRIC_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_LOG_PARAM_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_LOG_PARAM_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_LOG_PARAM_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_LOG_PARAM_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_LOG_MODEL_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_LOG_MODEL_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_LOG_MODEL_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_LOG_MODEL_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_LOAD_MODEL_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_LOAD_MODEL_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_LOAD_MODEL_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_LOAD_MODEL_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_DELETE_MODEL_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_DELETE_MODEL_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_DELETE_MODEL_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_DELETE_MODEL_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_SEARCH_RUNS_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_SEARCH_RUNS_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_SEARCH_RUNS_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_SEARCH_RUNS_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_END_RUN_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_END_RUN_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_END_RUN_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_END_RUN_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_GET_RUN_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_GET_RUN_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_GET_RUN_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_GET_RUN_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_SEARCH_EXPERIMENTS_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_SEARCH_EXPERIMENTS_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_SEARCH_EXPERIMENTS_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_SEARCH_EXPERIMENTS_WAIT_TIME_SECONDS\\\",\\n DEFAULT_WAIT_TIME_SECONDS,\\n )\\n MLFLOW_DELETE_EXPERIMENT_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_DELETE_EXPERIMENT_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_DELETE_EXPERIMENT_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_DELETE_EXPERIMENT_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_CREATE_EXPERIMENT_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_CREATE_EXPERIMENT_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_CREATE_EXPERIMENT_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_CREATE_EXPERIMENT_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n MLFLOW_GET_EXPERIMENT_ATTEMPTS: int = os.getenv(\\n \\\"MLFLOW_GET_EXPERIMENT_ATTEMPTS\\\", DEFAULT_MAX_ATTEMPTS\\n )\\n MLFLOW_GET_EXPERIMENT_WAIT_TIME_SECONDS: float = os.getenv(\\n \\\"MLFLOW_GET_EXPERIMENT_WAIT_TIME_SECONDS\\\", DEFAULT_WAIT_TIME_SECONDS\\n )\\n CLICKSTREAM_TIME_MAX_DELTA_MINUS_SEC: int = os.getenv(\\n \\\"CLICKSTREAM_TIME_MAX_DELTA_MINUS_SEC\\\", 12 * 60 * 60\\n )\\n CLICKSTREAM_TIME_MAX_DELTA_PLUS_SEC: int = os.getenv(\\n \\\"CLICKSTREAM_TIME_MAX_DELTA_PLUS_SEC\\\", 5 * 60\\n )\"\n },\n {\n \"identifier\": \"FineTuningMethod\",\n \"path\": \"embedding_studio/core/plugin.py\",\n \"snippet\": \"class FineTuningMethod(ABC):\\n \\\"\\\"\\\"Base class (plugin) for fine-tuning methods.\\n\\n All fine-tuning methods must inherit from this class.\\n \\\"\\\"\\\"\\n\\n meta: PluginMeta\\n\\n @abstractmethod\\n def upload_initial_model(self) -> None:\\n \\\"\\\"\\\"Upload the initial model to the storage.\\n\\n Method that should be implemented by subclasses to upload the\\n initial model to the storage.\\n \\\"\\\"\\\"\\n raise NotImplementedError(\\n \\\"Subclasses must implement upload_initial_model\\\"\\n )\\n\\n @abstractmethod\\n def get_fine_tuning_builder(\\n self, clickstream: List[SessionWithEvents]\\n ) -> FineTuningBuilder:\\n \\\"\\\"\\\"Return a FineTuningBuilder instance for the fine-tuning process.\\n\\n Method that should be implemented by subclasses to provide a\\n FineTuningBuilder instance.\\n\\n :param clickstream: Collection of user feedback, used to enhance\\n the model.\\n :return: An instance of FineTuningBuilder used for\\n launching the fine-tuning process.\\n \\\"\\\"\\\"\\n raise NotImplementedError(\\n \\\"Subclasses must implement get_fine_tuning_builder\\\"\\n )\"\n },\n {\n \"identifier\": \"AWSS3ClickstreamParser\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/parsers/s3_parser.py\",\n \"snippet\": \"class AWSS3ClickstreamParser(ClickstreamParser):\\n def __init__(\\n self, query_item_type: type, search_result_type: type, event_type: type\\n ):\\n super(AWSS3ClickstreamParser, self).__init__(\\n query_item_type, search_result_type, S3FileMeta, event_type\\n )\"\n },\n {\n \"identifier\": \"DummyEventType\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/search_event.py\",\n \"snippet\": \"class DummyEventType(EventType):\\n importance: float\\n\\n @property\\n def event_importance(self) -> float:\\n return self.importance\"\n },\n {\n \"identifier\": \"SearchResult\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/search_event.py\",\n \"snippet\": \"class SearchResult(BaseModel):\\n item: ItemMeta\\n is_click: bool\\n rank: Optional[float] = None\\n event_type: Optional[EventType] = None\\n timestamp: Optional[int] = None\\n\\n @validator(\\\"event_type\\\", pre=True, always=True)\\n def validate_event_type(cls, value, values):\\n if value is not None and not isinstance(value, EventType):\\n raise ValueError(\\\"Invalid event_type instance\\\")\\n return value\\n\\n class Config:\\n arbitrary_types_allowed = True\\n\\n @classmethod\\n def from_mongo(\\n cls,\\n result: SearchResultItem,\\n event_ids: Set[str],\\n item_type: type,\\n event_type: type,\\n ) -> \\\"SearchResult\\\":\\n event_instance = DummyEventType(importance=1)\\n\\n return cls(\\n item=item_type(**result.meta),\\n is_click=result.object_id in event_ids,\\n event_type=event_instance,\\n timestamp=None,\\n )\\n\\n @classmethod\\n def from_dict(\\n cls, data: dict, item_type: type, event_type: type\\n ) -> \\\"SearchResult\\\":\\n event_data: Optional[Dict] = data.get(\\\"event_type\\\")\\n event_instance = None\\n\\n if event_data is not None:\\n event_instance = event_type(**event_data)\\n\\n return cls(\\n item=item_type(**data[\\\"item\\\"]),\\n is_click=data[\\\"is_click\\\"],\\n rank=data[\\\"rank\\\"],\\n event_type=event_instance,\\n timestamp=int(data.get(\\\"timestamp\\\")),\\n )\"\n },\n {\n \"identifier\": \"ClickstreamSessionsSplitter\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/splitter.py\",\n \"snippet\": \"class ClickstreamSessionsSplitter:\\n def __init__(\\n self,\\n test_size_ratio: float = 0.2,\\n shuffle: bool = True,\\n random_state: Optional[int] = None,\\n ):\\n \\\"\\\"\\\"Generate train / test clickstream sessions split.\\n\\n :param test_size_ratio: ratio of test split size (default: 0.2)\\n :param shuffle: to shuffle or not paired clickstream sessions (default: True)\\n :param random_state: random state to sklearn splitter (default: None)\\n \\\"\\\"\\\"\\n if (\\n not isinstance(test_size_ratio, float)\\n or test_size_ratio <= 0\\n or test_size_ratio >= 1.0\\n ):\\n raise ValueError(\\n f\\\"test_size_ration is a numeric value in range (0.0, 1.0)\\\"\\n )\\n\\n if test_size_ratio >= 0.5:\\n logger.warning(\\n \\\"test_size_ration is larger than 0.5. It's unusual for ML to have test size > train size.\\\"\\n )\\n\\n self._test_size_ratio = test_size_ratio\\n\\n if not isinstance(shuffle, bool):\\n raise ValueError(\\\"shuffle should be boolean\\\")\\n self._shuffle = shuffle\\n self._random_state = random_state\\n\\n @property\\n def shuffle(self) -> bool:\\n return self._shuffle\\n\\n def split(self, sessions: List[ClickstreamSession]) -> DatasetDict:\\n \\\"\\\"\\\"Split clickstream sessions.\\n\\n :param sessions: sessions to be split\\n :return: train / test splits accordingly (PairedClickstreamDataset)\\n \\\"\\\"\\\"\\n # Get all IDs\\n all_result_ids: Set[str] = set()\\n for session in sessions:\\n all_result_ids.update(session.results)\\n\\n if len(all_result_ids) == 0:\\n raise ValueError(\\\"Sessions list is empty\\\")\\n\\n # Ensure a minimum number of unique result IDs in each set\\n min_unique_test_sessions: int = int(\\n self._test_size_ratio * len(sessions)\\n )\\n\\n # Split the result IDs into train and test sets\\n train_result_ids, test_result_ids = train_test_split(\\n list(all_result_ids),\\n test_size=self._test_size_ratio,\\n random_state=self._random_state,\\n )\\n test_result_ids: Set[str] = set(test_result_ids)\\n\\n # Split sessions into train and test based on result IDs\\n train_sessions: List[ClickstreamSession] = []\\n test_sessions: List[ClickstreamSession] = []\\n\\n for session in sessions:\\n if len(session.results) == 0:\\n continue\\n\\n if (\\n len(set(session.results) & test_result_ids)\\n / len(session.results)\\n <= 0.5\\n ):\\n # If less than 50% of result IDs intersect with the test set, add to the train set\\n train_sessions.append(session)\\n else:\\n test_sessions.append(session)\\n\\n if len(test_sessions) < min_unique_test_sessions:\\n logger.warning(\\n f\\\"Clickstream sessions intersects highly, so they are not split well\\\"\\n )\\n random_train_session_indexess: List[int] = random.choices(\\n list(range(len(train_sessions))),\\n k=min_unique_test_sessions - len(test_sessions),\\n )\\n for i in reversed(sorted(random_train_session_indexess)):\\n test_sessions.append(train_sessions.pop(i))\\n\\n if len(test_sessions) + len(train_sessions) < len(sessions):\\n missed_sessions_count = len(sessions) - (\\n len(test_sessions) + len(train_sessions)\\n )\\n logger.warning(\\n f\\\"Clickstream sessions weren't split correctly, add {missed_sessions_count} more sessions to the train split.\\\"\\n )\\n\\n for session in sessions:\\n if (\\n session not in train_sessions\\n and session not in test_sessions\\n ):\\n train_sessions.append(session)\\n\\n return DatasetDict(\\n {\\n \\\"train\\\": PairedClickstreamDataset(\\n train_sessions, self.shuffle\\n ),\\n \\\"test\\\": PairedClickstreamDataset(test_sessions, self.shuffle),\\n }\\n )\"\n },\n {\n \"identifier\": \"TextQueryItem\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/text_query_item.py\",\n \"snippet\": \"class TextQueryItem(QueryItem):\\n text: str\\n\\n class Config:\\n arbitrary_types_allowed = True\"\n },\n {\n \"identifier\": \"TextQueryRetriever\",\n \"path\": \"embedding_studio/embeddings/data/clickstream/text_query_retriever.py\",\n \"snippet\": \"class TextQueryRetriever(QueryRetriever):\\n def __call__(self, query: TextQueryItem) -> str:\\n if not hasattr(query, \\\"text\\\"):\\n raise ValueError(f\\\"Query object does not have text attribute\\\")\\n return query.text\"\n },\n {\n \"identifier\": \"AWSS3DataLoader\",\n \"path\": \"embedding_studio/embeddings/data/loaders/s3/s3_loader.py\",\n \"snippet\": \"class AWSS3DataLoader(DataLoader):\\n def __init__(self, retry_config: Optional[RetryConfig] = None, **kwargs):\\n \\\"\\\"\\\"Items loader from AWS S3.\\n\\n :param max_attempts: maximum number of attempts (default: 10)\\n :param wait_time_seconds: time to wait between (default: 10)\\n :param kwargs: dict data for AWSS3Credentials\\n \\\"\\\"\\\"\\n super(AWSS3DataLoader, self).__init__(**kwargs)\\n self.retry_config = (\\n retry_config\\n if retry_config\\n else AWSS3DataLoader._get_default_retry_config()\\n )\\n self.credentials = AWSS3Credentials(**kwargs)\\n self.attempt_exception_types = [EndpointConnectionError]\\n\\n @staticmethod\\n def _get_default_retry_config() -> RetryConfig:\\n default_retry_params = RetryParams(\\n max_attempts=settings.DEFAULT_MAX_ATTEMPTS,\\n wait_time_seconds=settings.DEFAULT_WAIT_TIME_SECONDS,\\n )\\n\\n config = RetryConfig(default_params=default_retry_params)\\n config[\\\"credentials\\\"] = RetryParams(\\n max_attempts=settings.S3_READ_CREDENTIALS_ATTEMPTS,\\n wait_time_seconds=settings.S3_READ_WAIT_TIME_SECONDS,\\n )\\n config[\\\"download_data\\\"] = RetryParams(\\n max_attempts=settings.S3_DOWNLOAD_DATA_ATTEMPTS,\\n wait_time_seconds=settings.S3_DOWNLOAD_DATA_WAIT_TIME_SECONDS,\\n )\\n return config\\n\\n @retry_method(name=\\\"download_data\\\")\\n def _read_from_s3(self, client, bucket: str, file: str) -> Image:\\n return read_from_s3(client, bucket, file)\\n\\n @retry_method(name=\\\"credentials\\\")\\n def _get_client(self, task_id: str):\\n if (\\n self.credentials.aws_access_key_id is None\\n or self.credentials.aws_secret_access_key is None\\n ) and not self.credentials.use_system_info:\\n logger.warning(\\n \\\"No specific AWS credentials, use Anonymous session\\\"\\n )\\n s3_client = boto3.client(\\n \\\"s3\\\", config=Config(signature_version=UNSIGNED)\\n )\\n else:\\n sts_client = boto3.client(\\n \\\"sts\\\",\\n aws_access_key_id=self.credentials.aws_access_key_id,\\n aws_secret_access_key=self.credentials.aws_secret_access_key,\\n )\\n if self.credentials.external_id:\\n assumed_role_object = sts_client.assume_role(\\n RoleArn=self.credentials.role_arn,\\n RoleSessionName=task_id,\\n ExternalId=self.credentials.external_id,\\n )\\n else:\\n assumed_role_object = sts_client.assume_role(\\n RoleArn=self.credentials.role_arn,\\n RoleSessionName=task_id,\\n )\\n credentials = assumed_role_object[\\\"Credentials\\\"]\\n s3_client = boto3.client(\\n \\\"s3\\\",\\n aws_access_key_id=credentials[\\\"AccessKeyId\\\"],\\n aws_secret_access_key=credentials[\\\"SecretAccessKey\\\"],\\n aws_session_token=credentials[\\\"SessionToken\\\"],\\n )\\n return s3_client\\n\\n def _generate_dataset_from_s3(\\n self, files: List[S3FileMeta]\\n ) -> Iterable[Dict]:\\n if len(files) == 0:\\n logger.warning(\\\"Nothing to download\\\")\\n else:\\n logger.info(\\\"Connecting to aws s3...\\\")\\n task_id: str = str(uuid.uuid4())\\n try:\\n s3_client = self._get_client(task_id)\\n logger.info(\\\"Start downloading data from S3...\\\")\\n bad_items_count = 0\\n for val in files:\\n image = None\\n try:\\n image: Image = read_from_s3(\\n s3_client, val.bucket, val.file\\n )\\n except Exception as e:\\n logger.exception(\\n f\\\"Unable to download an item: {val.bucket}/{val.file} Exception: {str(e)}\\\"\\n )\\n\\n if image is None:\\n logger.error(\\n f\\\"Unable to download {val.file} from {val.bucket}\\\"\\n )\\n bad_items_count += 1\\n continue\\n yield {\\\"item\\\": image, \\\"item_id\\\": val.id}\\n\\n if bad_items_count == len(files):\\n raise FailedToLoadAnythingFromAWSS3()\\n\\n except Exception as err:\\n logger.error(f\\\"Failed to load dataset from s3: {err}\\\")\\n raise err\\n\\n def load(self, items_data: List[S3FileMeta]) -> Dataset:\\n return Dataset.from_generator(\\n lambda: self._generate_dataset_from_s3(items_data)\\n )\"\n },\n {\n \"identifier\": \"CLIPItemStorageProducer\",\n \"path\": \"embedding_studio/embeddings/data/storages/producers/clip.py\",\n \"snippet\": \"class CLIPItemStorageProducer(ItemStorageProducer):\\n def __init__(\\n self,\\n field_normalizer: DatasetFieldsNormalizer,\\n id_field_name: Optional[str] = None,\\n ):\\n super(CLIPItemStorageProducer, self).__init__(\\n ImageItemsDatasetDictPreprocessor(field_normalizer, 224),\\n id_field_name,\\n )\"\n },\n {\n \"identifier\": \"DatasetFieldsNormalizer\",\n \"path\": \"embedding_studio/embeddings/data/utils/fields_normalizer.py\",\n \"snippet\": \"class DatasetFieldsNormalizer:\\n ID_FIELD_NAME = \\\"item_id\\\"\\n ITEM_FIELD_NAME = \\\"item\\\"\\n\\n def __init__(self, item_field_name: str, id_field_name: str):\\n \\\"\\\"\\\"Unify column names in DatasetDict, so it can be used in fine-tuning script.\\n A dataset should have ID column, related to ID in clickstream.\\n\\n :param item_field_name: name of column with items.\\n :param id_field_name: name of ID column\\n \\\"\\\"\\\"\\n if not id_field_name:\\n raise ValueError(\\\"id_field_name should be non-empty string\\\")\\n self.id_field_name = id_field_name\\n\\n if not item_field_name:\\n raise ValueError(\\\"item_field_name should be non-empty string\\\")\\n self.item_field_name = item_field_name\\n\\n def __call__(self, dataset: DatasetDict) -> DatasetDict:\\n id_normalizer = (\\n lambda id_value: str(id_value.item())\\n if (\\n isinstance(id_value, Tensor)\\n or isinstance(id_value, FloatTensor)\\n )\\n else str(id_value)\\n )\\n for key in dataset.keys():\\n if (\\n DatasetFieldsNormalizer.ID_FIELD_NAME\\n not in dataset.column_names[key]\\n ):\\n dataset = dataset.rename_column(\\n self.id_field_name, DatasetFieldsNormalizer.ID_FIELD_NAME\\n )\\n else:\\n logger.warning(\\n f\\\"Dataset {key} split already has {DatasetFieldsNormalizer.ID_FIELD_NAME} field\\\"\\n )\\n\\n if (\\n DatasetFieldsNormalizer.ITEM_FIELD_NAME\\n not in dataset.column_names[key]\\n ):\\n dataset = dataset.rename_column(\\n self.item_field_name,\\n DatasetFieldsNormalizer.ITEM_FIELD_NAME,\\n )\\n else:\\n logger.warning(\\n f\\\"Dataset {key} split already has {DatasetFieldsNormalizer.ITEM_FIELD_NAME} field\\\"\\n )\\n\\n return dataset.map(\\n lambda example: {\\n DatasetFieldsNormalizer.ID_FIELD_NAME: id_normalizer(\\n example[DatasetFieldsNormalizer.ID_FIELD_NAME]\\n )\\n }\\n )\"\n },\n {\n \"identifier\": \"CosineProbMarginRankingLoss\",\n \"path\": \"embedding_studio/embeddings/losses/prob_cosine_margin_ranking_loss.py\",\n \"snippet\": \"class CosineProbMarginRankingLoss(ProbMarginRankingLoss):\\n def __init__(self, base_margin: Optional[float] = 1.0):\\n \\\"\\\"\\\"Embeddings Fine-tuning Loss (modification of MarginRankingLoss)\\n Use sigmoid instead of ReLU + results confidences to ignore noises and mistakes.\\n Adapt to cosine similarity / distance\\n\\n :param base_margin: margin ranking loss margin (default: 1.0)\\n \\\"\\\"\\\"\\n super(CosineProbMarginRankingLoss, self).__init__(\\n base_margin=base_margin\\n )\\n\\n def __adjust(self, adjusted_diff: FloatTensor) -> FloatTensor:\\n # The way any wrong difference more than 0.01 is worth to be penaltized\\n # Sigmoid with this kind of input return prob > 0.1, for difference between\\n # pos and more than 0.001. That's our expected behaviour.\\n # TODO: implement calculation of magic numbers\\n return -400 * adjusted_diff + 6\"\n },\n {\n \"identifier\": \"TextToImageCLIPModel\",\n \"path\": \"embedding_studio/embeddings/models/text_to_image/clip.py\",\n \"snippet\": \"class TextToImageCLIPModel(EmbeddingsModelInterface):\\n def __init__(self, clip_model: SentenceTransformer):\\n \\\"\\\"\\\"Wrapper to SentenceTransformer CLIP model.\\n Usage: model = TextToImageCLIPModel(SentenceTransformer('clip-ViT-B-32'))\\n\\n :param clip_model: clip model from SentenceTransformer package\\n \\\"\\\"\\\"\\n super(TextToImageCLIPModel, self).__init__(same_query_and_items=False)\\n self.clip_model = clip_model\\n self.text_model = torch.nn.Sequential(\\n self.clip_model._modules[\\\"0\\\"]\\n ._modules[\\\"model\\\"]\\n ._modules[\\\"text_model\\\"],\\n PassPoolerOutputLayer(),\\n self.clip_model._modules[\\\"0\\\"]\\n ._modules[\\\"model\\\"]\\n ._modules[\\\"text_projection\\\"],\\n )\\n\\n self.vision_model = torch.nn.Sequential(\\n self.clip_model._modules[\\\"0\\\"]\\n ._modules[\\\"model\\\"]\\n ._modules[\\\"vision_model\\\"],\\n PassPoolerOutputLayer(),\\n self.clip_model._modules[\\\"0\\\"]\\n ._modules[\\\"model\\\"]\\n ._modules[\\\"visual_projection\\\"],\\n )\\n\\n def get_query_model_params(self) -> Iterator[Parameter]:\\n return self.text_model.parameters()\\n\\n def get_items_model_params(self) -> Iterator[Parameter]:\\n return self.vision_model.parameters()\\n\\n def fix_query_model(self, num_fixed_layers: int):\\n if (\\n len(self.text_model._modules[\\\"0\\\"].encoder.layers)\\n <= num_fixed_layers\\n ):\\n raise ValueError(\\n f\\\"Number of fixed layers ({num_fixed_layers}) >= number \\\"\\n f'of existing layers ({len(self.text_model._modules[\\\"0\\\"].encoder.layers)})'\\n )\\n\\n self.text_model._modules[\\\"0\\\"].embeddings.requires_grad = False\\n for i, attn in enumerate(self.text_model._modules[\\\"0\\\"].encoder.layers):\\n if i < num_fixed_layers:\\n self.text_model._modules[\\\"0\\\"].encoder.layers[\\n i\\n ].requires_grad = False\\n\\n def unfix_query_model(self):\\n self.text_model._modules[\\\"0\\\"].embeddings.requires_grad = True\\n for i, attn in enumerate(self.text_model._modules[\\\"0\\\"].encoder.layers):\\n self.text_model._modules[\\\"0\\\"].encoder.layers[\\n i\\n ].requires_grad = True\\n\\n def fix_item_model(self, num_fixed_layers: int):\\n if (\\n len(self.vision_model._modules[\\\"0\\\"].encoder.layers)\\n <= num_fixed_layers\\n ):\\n raise ValueError(\\n f\\\"Number of fixed layers ({num_fixed_layers}) >= number \\\"\\n f'of existing layers ({len(self.vision_model._modules[\\\"0\\\"].encoder.layers)})'\\n )\\n\\n self.vision_model._modules[\\\"0\\\"].embeddings.requires_grad = False\\n for i, attn in enumerate(\\n self.vision_model._modules[\\\"0\\\"].encoder.layers\\n ):\\n if i < num_fixed_layers:\\n self.vision_model._modules[\\\"0\\\"].encoder.layers[\\n i\\n ].requires_grad = False\\n\\n def unfix_item_model(self):\\n self.vision_model._modules[\\\"0\\\"].embeddings.requires_grad = True\\n for i, attn in enumerate(\\n self.vision_model._modules[\\\"0\\\"].encoder.layers\\n ):\\n self.vision_model._modules[\\\"0\\\"].encoder.layers[\\n i\\n ].requires_grad = True\\n\\n def tokenize(self, query: str) -> List[Dict]:\\n return self.clip_model.tokenize([query])\\n\\n def forward_query(self, query: str) -> FloatTensor:\\n if len(query) == 0:\\n logger.warning(\\\"Provided query is empty\\\")\\n\\n tokenized = self.tokenize(query)\\n return self.text_model.forward(tokenized[\\\"input_ids\\\"].to(self.device))\\n\\n def forward_items(self, items: List[np.array]) -> FloatTensor:\\n if len(items) == 0:\\n raise ValueError(\\\"items list must not be empty\\\")\\n\\n return self.vision_model.forward(torch.stack(items).to(self.device))\"\n },\n {\n \"identifier\": \"SessionWithEvents\",\n \"path\": \"embedding_studio/models/clickstream/sessions.py\",\n \"snippet\": \"class SessionWithEvents(RegisteredSession):\\n events: List[SessionEvent]\"\n },\n {\n \"identifier\": \"FineTuningBuilder\",\n \"path\": \"embedding_studio/models/plugin.py\",\n \"snippet\": \"class FineTuningBuilder:\\n data_loader: DataLoader\\n query_retriever: QueryRetriever\\n clickstream_parser: ClickstreamParser\\n clickstream_sessions_splitter: ClickstreamSessionsSplitter\\n dataset_fields_normalizer: DatasetFieldsNormalizer\\n item_storage_producer: ItemStorageProducer\\n accumulators: List[MetricsAccumulator]\\n experiments_manager: ExperimentsManager\\n fine_tuning_settings: FineTuningSettings\\n initial_params: Dict[str, List[Any]]\\n ranking_data: RankingData\\n initial_max_evals: int = 100\"\n },\n {\n \"identifier\": \"PluginMeta\",\n \"path\": \"embedding_studio/models/plugin.py\",\n \"snippet\": \"class PluginMeta(BaseModel):\\n name: str\\n version: str = \\\"1.0.0\\\"\\n description: Optional[str] = None\"\n },\n {\n \"identifier\": \"prepare_data\",\n \"path\": \"embedding_studio/workers/fine_tuning/data/prepare_data.py\",\n \"snippet\": \"def prepare_data(\\n clickstream_sessions: List[Union[Dict, SessionWithEvents]],\\n parser: ClickstreamParser,\\n clickstream_splitter: ClickstreamSessionsSplitter,\\n query_retriever: QueryRetriever,\\n loader: DataLoader,\\n storage_producer: ItemStorageProducer,\\n) -> RankingData:\\n \\\"\\\"\\\"Prepare fine-tuning data.\\n\\n :param clickstream_sessions: clickstream sessions\\n :param parser: how to parse a clickstream session\\n :param clickstream_splitter: how to split clickstream sessions\\n :param query_retriever: retrieve query item\\n :param loader: load items data\\n :param storage_producer: get train/test datasets\\n :return: train / test clickstream sessiobs and dataset dict\\n \\\"\\\"\\\"\\n if len(clickstream_sessions) == 0:\\n raise ValueError(\\\"Empty clickstream sessions list\\\")\\n\\n logger.info(\\\"Parse clickstream sessions data\\\")\\n raw_clickstream_sessions: List[RawClickstreamSession] = [\\n (\\n parser.parse(session)\\n if isinstance(session, dict)\\n else parser.parse_from_mongo(session)\\n )\\n for session in clickstream_sessions\\n ]\\n\\n clickstream_sessions: List[ClickstreamSession] = [\\n r.get_session() for r in raw_clickstream_sessions\\n ]\\n\\n logger.info(\\\"Setup query retriever\\\")\\n query_retriever.setup(clickstream_sessions)\\n\\n logger.info(\\\"Split clickstream sessions into train / test\\\")\\n clickstream_dataset = clickstream_splitter.split(clickstream_sessions)\\n logger.info(\\n f'Splitting is finished, train: {len(clickstream_dataset[\\\"train\\\"])} / test: {len(clickstream_dataset[\\\"test\\\"])}'\\n )\\n\\n logger.info(\\\"Get list of files to be loaded\\\")\\n files_to_load: Set[ItemMeta] = set()\\n for session in raw_clickstream_sessions:\\n files_to_load.update(set([r.item for r in session.results]))\\n\\n if len(files_to_load) == 0:\\n raise ValueError(\\\"Empty clickstream sessions\\\")\\n\\n logger.info(\\\"Download files and prepare DataDict of ItemStorage values\\\")\\n files_to_load: List[ItemMeta] = list(files_to_load)\\n\\n dataset: DatasetDict = storage_producer(\\n loader.load(files_to_load), clickstream_dataset\\n )\\n\\n return RankingData(clickstream_dataset, dataset)\"\n },\n {\n \"identifier\": \"ExperimentsManager\",\n \"path\": \"embedding_studio/workers/fine_tuning/experiments/experiments_tracker.py\",\n \"snippet\": \"class ExperimentsManager:\\n def __init__(\\n self,\\n tracking_uri: str,\\n main_metric: str,\\n accumulators: List[MetricsAccumulator],\\n is_loss: bool = False,\\n n_top_runs: int = 10,\\n requirements: Optional[str] = None,\\n retry_config: Optional[RetryConfig] = None,\\n ):\\n \\\"\\\"\\\"Wrapper over mlflow package to manage certain fine-tuning experiments.\\n\\n :param tracking_uri: url of MLFlow server\\n :param main_metric: name of main metric that will be used to find best model\\n :param accumulators: accumulators of metrics to be logged\\n :param is_loss: is main metric loss (if True, then best quality is minimal) (default: False)\\n :param n_top_runs: how many hyper params group consider to be used in following tuning steps (default: 10)\\n :param requirements: extra requirements to be passed to mlflow.pytorch.log_model (default: None)\\n :param retry_config: retry policy (default: None)\\n \\\"\\\"\\\"\\n if not isinstance(tracking_uri, str) or len(tracking_uri) == 0:\\n raise ValueError(\\n f\\\"MLFlow tracking URI value should be a not empty string\\\"\\n )\\n mlflow.set_tracking_uri(tracking_uri)\\n self._tracking_uri = tracking_uri\\n if self._tracking_uri.endswith(\\\"/\\\"):\\n self._tracking_uri = self._tracking_uri[:-1]\\n\\n self.retry_config = (\\n retry_config\\n if retry_config\\n else ExperimentsManager._get_default_retry_config()\\n )\\n self.attempt_exception_types = [RestException]\\n\\n if not isinstance(main_metric, str) or len(main_metric) == 0:\\n raise ValueError(f\\\"main_metric value should be a not empty string\\\")\\n self.main_metric = main_metric\\n self._metric_field = f\\\"metrics.{self.main_metric}\\\"\\n\\n self._n_top_runs = n_top_runs\\n self._is_loss = is_loss\\n\\n if len(accumulators) == 0:\\n logger.warning(\\n \\\"No accumulators were provided, there will be no metrics logged except loss\\\"\\n )\\n self._accumulators = accumulators\\n\\n self._requirements: List[str] = (\\n _get_base_requirements() if requirements is None else requirements\\n )\\n\\n self._iteration_experiment = None\\n self._tuning_iteration = None\\n self._tuning_iteration_id = None\\n\\n self._run = None\\n self._run_params = None\\n self._run_id = None\\n\\n def _check_artifact_exists(self, run_id, artifact_path):\\n client = mlflow.MlflowClient()\\n artifacts = client.list_artifacts(run_id, path=artifact_path)\\n return any(artifact.path == artifact_path for artifact in artifacts)\\n\\n @staticmethod\\n def _get_default_retry_config() -> RetryConfig:\\n default_retry_params = RetryParams(\\n max_attempts=settings.DEFAULT_MAX_ATTEMPTS,\\n wait_time_seconds=settings.DEFAULT_WAIT_TIME_SECONDS,\\n )\\n\\n config = RetryConfig(default_params=default_retry_params)\\n config[\\\"log_metric\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_LOG_METRIC_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_LOG_METRIC_WAIT_TIME_SECONDS,\\n )\\n config[\\\"log_param\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_LOG_PARAM_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_LOG_PARAM_WAIT_TIME_SECONDS,\\n )\\n config[\\\"log_model\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_LOG_MODEL_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_LOG_MODEL_WAIT_TIME_SECONDS,\\n )\\n config[\\\"load_model\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_LOAD_MODEL_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_LOAD_MODEL_WAIT_TIME_SECONDS,\\n )\\n config[\\\"delete_model\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_DELETE_MODEL_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_DELETE_MODEL_WAIT_TIME_SECONDS,\\n )\\n config[\\\"search_runs\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_SEARCH_RUNS_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_SEARCH_RUNS_WAIT_TIME_SECONDS,\\n )\\n config[\\\"end_run\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_END_RUN_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_END_RUN_WAIT_TIME_SECONDS,\\n )\\n config[\\\"get_run\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_GET_RUN_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_GET_RUN_WAIT_TIME_SECONDS,\\n )\\n config[\\\"search_experiments\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_SEARCH_EXPERIMENTS_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_SEARCH_EXPERIMENTS_WAIT_TIME_SECONDS,\\n )\\n config[\\\"delete_experiment\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_DELETE_EXPERIMENT_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_DELETE_EXPERIMENT_WAIT_TIME_SECONDS,\\n )\\n config[\\\"create_experiment\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_CREATE_EXPERIMENT_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_CREATE_EXPERIMENT_WAIT_TIME_SECONDS,\\n )\\n config[\\\"get_experiment\\\"] = RetryParams(\\n max_attempts=settings.MLFLOW_GET_EXPERIMENT_ATTEMPTS,\\n wait_time_seconds=settings.MLFLOW_GET_EXPERIMENT_WAIT_TIME_SECONDS,\\n )\\n\\n return config\\n\\n @property\\n def is_loss(self) -> bool:\\n return self._is_loss\\n\\n def __del__(self):\\n self.finish_run()\\n self.finish_iteration()\\n\\n def is_retryable_error(self, e: Exception) -> bool:\\n return False\\n\\n def _get_model_exists_filter(self) -> str:\\n return \\\"metrics.model_uploaded = 1\\\"\\n\\n def _get_artifact_url(self, run_id: str, artifact_path: str) -> str:\\n return (\\n f\\\"{self._tracking_uri}/get-artifact?path=\\\"\\n f'{urllib.parse.quote(artifact_path, safe=\\\"\\\")}&run_uuid={run_id}'\\n )\\n\\n @retry_method(name=\\\"log_model\\\")\\n def upload_initial_model(self, model: EmbeddingsModelInterface):\\n \\\"\\\"\\\"Upload the very first, initial model to the mlflow server\\n\\n :param model: model to be uploaded\\n \\\"\\\"\\\"\\n self.finish_iteration()\\n experiment_id = get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME)\\n if experiment_id is None:\\n logger.info(\\n f\\\"Can't find any active iteration with name: {INITIAL_EXPERIMENT_NAME}\\\"\\n )\\n try:\\n logger.info(\\\"Create initial experiment\\\")\\n mlflow.create_experiment(INITIAL_EXPERIMENT_NAME)\\n except MlflowException as e:\\n if \\\"Cannot set a deleted experiment\\\" in str(e):\\n logger.error(\\n f\\\"Creation of initial experiment is failed: experiment with the same name {INITIAL_EXPERIMENT_NAME} is deleted, but not archived\\\"\\n )\\n experiments = mlflow.search_experiments(\\n view_type=mlflow.entities.ViewType.ALL\\n )\\n deleted_experiment_id = None\\n\\n for exp in experiments:\\n if exp.name == INITIAL_EXPERIMENT_NAME:\\n deleted_experiment_id = exp.experiment_id\\n break\\n\\n logger.info(\\n f\\\"Restore deleted experiment with the same name: {INITIAL_EXPERIMENT_NAME}\\\"\\n )\\n mlflow.tracking.MlflowClient().restore_experiment(\\n deleted_experiment_id\\n )\\n logger.info(\\n f\\\"Archive deleted experiment with the same name: {INITIAL_EXPERIMENT_NAME}\\\"\\n )\\n mlflow.tracking.MlflowClient().rename_experiment(\\n deleted_experiment_id,\\n INITIAL_EXPERIMENT_NAME + \\\"_archive\\\",\\n )\\n logger.info(\\n f\\\"Delete archived experiment with the same name: {INITIAL_EXPERIMENT_NAME}\\\"\\n )\\n mlflow.delete_experiment(deleted_experiment_id)\\n logger.info(f\\\"Create initial experiment\\\")\\n mlflow.create_experiment(INITIAL_EXPERIMENT_NAME)\\n else:\\n raise e\\n\\n with mlflow.start_run(\\n experiment_id=get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME),\\n run_name=INITIAL_RUN_NAME,\\n ) as run:\\n logger.info(\\n f\\\"Upload initial model to {INITIAL_EXPERIMENT_NAME} / {INITIAL_RUN_NAME}\\\"\\n )\\n if self._check_artifact_exists(\\n get_run_id_by_name(\\n get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME),\\n INITIAL_RUN_NAME,\\n ),\\n \\\"model\\\",\\n ):\\n logger.info(\\\"Model is already uploaded\\\")\\n return\\n\\n mlflow.pytorch.log_model(\\n model, \\\"model\\\", pip_requirements=self._requirements\\n )\\n logger.info(\\\"Uploading is finished\\\")\\n\\n @retry_method(name=\\\"load_model\\\")\\n def download_initial_model(self) -> EmbeddingsModelInterface:\\n \\\"\\\"\\\"Download initial model.\\n\\n :return: initial embeddings model\\n \\\"\\\"\\\"\\n model_uri: str = f\\\"runs:/{get_run_id_by_name(get_experiment_id_by_name(INITIAL_EXPERIMENT_NAME), INITIAL_RUN_NAME)}/model\\\"\\n logger.info(f\\\"Download the model from {model_uri}\\\")\\n model = mlflow.pytorch.load_model(model_uri)\\n logger.info(\\\"Downloading is finished\\\")\\n return model\\n\\n @retry_method(name=\\\"search_runs\\\")\\n def get_top_params(self) -> Optional[List[FineTuningParams]]:\\n \\\"\\\"\\\"Get top N previous fine-tuning iteration best params\\n\\n :return: fine-tuning iteration params\\n \\\"\\\"\\\"\\n initial_id: Optional[str] = get_experiment_id_by_name(\\n INITIAL_EXPERIMENT_NAME\\n )\\n last_session_id: Optional[str] = self.get_previous_iteration_id()\\n if initial_id == last_session_id:\\n logger.warning(\\n \\\"Can't retrieve top params, no previous iteration in history\\\"\\n )\\n return None\\n\\n else:\\n runs: pd.DataFrame = mlflow.search_runs(\\n experiment_ids=[last_session_id],\\n filter_string=self._get_model_exists_filter(),\\n )\\n runs = runs[runs.status == \\\"FINISHED\\\"] # and only finished ones\\n if runs.shape[0] == 0:\\n logger.warning(\\n \\\"Can't retrieve top params, no previous iteration's finished runs with uploaded model in history\\\"\\n )\\n return None\\n\\n # Get the indices that would sort the DataFrame based on the specified parameter\\n sorted_indices: np.ndarray = np.argsort(\\n runs[self._metric_field].values\\n )\\n if not self.is_loss:\\n sorted_indices = sorted_indices[\\n ::-1\\n ] # Use [::-1] to sort in descending order\\n\\n # Extract the top N rows based on the sorted indices\\n top_n_rows: np.ndarray = runs.iloc[\\n sorted_indices[: self._n_top_runs]\\n ]\\n\\n # Define a mapping dictionary to remove the \\\"params.\\\" prefix\\n column_mapping: Dict[str, str] = {\\n col: col.replace(\\\"params.\\\", \\\"\\\") for col in top_n_rows.columns\\n }\\n\\n # Rename the columns\\n top_n_rows: np.ndarray = top_n_rows.rename(\\n columns=column_mapping\\n ).to_dict(orient=\\\"records\\\")\\n\\n return [FineTuningParams(**row) for row in top_n_rows]\\n\\n def _get_best_previous_run_id(self) -> Tuple[Optional[str], bool]:\\n initial_id: Optional[str] = get_experiment_id_by_name(\\n INITIAL_EXPERIMENT_NAME\\n )\\n last_session_id: Optional[str] = self.get_previous_iteration_id()\\n if initial_id == last_session_id or last_session_id is None:\\n return None, True\\n else:\\n run_id, _ = self._get_best_quality(last_session_id)\\n return run_id, False\\n\\n def _get_best_current_run_id(self) -> Tuple[Optional[str], bool]:\\n initial_id: Optional[str] = get_experiment_id_by_name(\\n INITIAL_EXPERIMENT_NAME\\n )\\n if (\\n initial_id == self._tuning_iteration_id\\n or self._tuning_iteration_id is None\\n ):\\n return None, True\\n else:\\n run_id, _ = self._get_best_quality(self._tuning_iteration_id)\\n return run_id, False\\n\\n @retry_method(name=\\\"load_model\\\")\\n def get_last_model_url(self) -> Optional[str]:\\n run_id, is_initial = self._get_best_previous_run_id()\\n if is_initial:\\n logger.warning(\\n \\\"Can't get the best model URL, no previous iteration in history\\\"\\n )\\n return None\\n else:\\n if run_id is None:\\n logger.warning(\\n \\\"Can't get the best model URL, no previous iterations \\\"\\n \\\"finished runs with uploaded model in history\\\"\\n )\\n return None\\n path = MODEL_ARTIFACT_PATH\\n return self._get_artifact_url(run_id, path)\\n\\n @retry_method(name=\\\"load_model\\\")\\n def get_current_model_url(self) -> Optional[str]:\\n run_id, is_initial = self._get_best_current_run_id()\\n if is_initial:\\n logger.warning(\\n \\\"Can't get the best model URL, current run is initial\\\"\\n )\\n return None\\n\\n if run_id is None:\\n logger.warning(\\n \\\"Can't get the best model URL, no iterations \\\"\\n \\\"finished runs with uploaded model in history\\\"\\n )\\n return None\\n path = MODEL_ARTIFACT_PATH\\n return self._get_artifact_url(run_id, path)\\n\\n @retry_method(name=\\\"load_model\\\")\\n def get_last_model(self) -> EmbeddingsModelInterface:\\n \\\"\\\"\\\"Get previous iteration best embedding model.\\n\\n :return: best embedding model\\n \\\"\\\"\\\"\\n run_id, is_initial = self._get_best_previous_run_id()\\n if is_initial:\\n logger.warning(\\n \\\"Download initial model, no previous iteration in history\\\"\\n )\\n return self.download_initial_model()\\n\\n else:\\n if run_id is None:\\n logger.warning(\\n \\\"Download initial model, no previous iteration's \\\"\\n \\\"finished runs with uploaded model in history\\\"\\n )\\n return self.download_initial_model()\\n else:\\n model_uri: str = f\\\"runs:/{run_id}/model\\\"\\n logger.info(f\\\"Download the model from {model_uri}\\\")\\n model = mlflow.pytorch.load_model(model_uri)\\n logger.info(\\\"Downloading is finished\\\")\\n return model\\n\\n @retry_method(name=\\\"load_model\\\")\\n def get_current_model(self) -> Optional[EmbeddingsModelInterface]:\\n \\\"\\\"\\\"Get current iteration best embedding model.\\n\\n :return: best embedding model\\n \\\"\\\"\\\"\\n if self._tuning_iteration is None:\\n logger.error(\\\"No current iteration, can't get any model\\\")\\n return\\n\\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\\n logger.info(\\\"Download initial model\\\")\\n return self.download_initial_model()\\n\\n run_id, is_initial = self._get_best_current_run_id()\\n model_uri: str = f\\\"runs:/{run_id}/model\\\"\\n logger.info(f\\\"Download the model from {model_uri}\\\")\\n model = mlflow.pytorch.load_model(model_uri)\\n logger.info(\\\"Downloading is finished\\\")\\n return model\\n\\n @retry_method(name=\\\"search_experiments\\\")\\n def get_previous_iteration_id(self) -> Optional[str]:\\n if (\\n self._tuning_iteration == INITIAL_EXPERIMENT_NAME\\n or self._tuning_iteration is None\\n ):\\n logger.warning(\\n f\\\"Can't find previous iteration - no current iteration was setup\\\"\\n )\\n return None\\n\\n plugin_name = f\\\"{self._tuning_iteration.plugin_name}\\\"\\n experiments: List[Experiment] = [\\n e\\n for e in mlflow.search_experiments()\\n if (\\n e.name.startswith(EXPERIMENT_PREFIX)\\n and e.name.find(plugin_name) != -1\\n and e.name != str(self._tuning_iteration)\\n )\\n ]\\n if len(experiments) == 0:\\n logger.warning(\\\"No iteration found\\\")\\n return None\\n else:\\n return max(\\n experiments, key=lambda exp: exp.creation_time\\n ).experiment_id\\n\\n @retry_method(name=\\\"delete_experiment\\\")\\n def delete_previous_iteration(self):\\n experiment_id: Optional[str] = self.get_previous_iteration_id()\\n\\n logger.info(\\\"Delete models of previous iteration.\\\")\\n runs = mlflow.search_runs(\\n experiment_ids=[experiment_id],\\n filter_string=self._get_model_exists_filter(),\\n )\\n runs = runs[runs.status == \\\"FINISHED\\\"]\\n run_ids = runs[\\\"run_id\\\"].tolist()\\n\\n for run_id in run_ids:\\n self.delete_model(run_id, experiment_id)\\n\\n if experiment_id is not None:\\n logger.info(\\n f\\\"Iteration with ID {experiment_id} is going to be deleted\\\"\\n )\\n mlflow.tracking.MlflowClient().rename_experiment(\\n experiment_id, INITIAL_EXPERIMENT_NAME + \\\"_archive\\\"\\n )\\n mlflow.delete_experiment(experiment_id)\\n else:\\n logger.warning(\\n \\\"Can't delete a previous iteration, no previous iteration in history\\\"\\n )\\n\\n @retry_method(name=\\\"create_experiment\\\")\\n def set_iteration(self, iteration: FineTuningIteration):\\n \\\"\\\"\\\"Start a new fine-tuning session.\\n\\n :param iteration: fine-tuning iteration info\\n \\\"\\\"\\\"\\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\\n self.finish_iteration()\\n\\n logger.info(\\\"Start a new fine-tuning iterations\\\")\\n\\n self._tuning_iteration = iteration\\n self._tuning_iteration_id = get_experiment_id_by_name(str(iteration))\\n if self._tuning_iteration_id is None:\\n self._tuning_iteration_id = mlflow.create_experiment(\\n str(iteration)\\n )\\n\\n self._iteration_experiment = mlflow.set_experiment(\\n experiment_id=self._tuning_iteration_id\\n )\\n\\n @retry_method(name=\\\"start_run\\\")\\n def set_run(self, params: FineTuningParams) -> bool:\\n \\\"\\\"\\\"Start a new run with provided fine-tuning params\\n\\n :param params: provided fine-tuning params\\n :return: True if it's a finished run (otherwise False)\\n \\\"\\\"\\\"\\n convert_value = (\\n lambda value: \\\", \\\".join(map(str, value))\\n if isinstance(value, list)\\n else value\\n )\\n\\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\\n # TODO: implement exception\\n raise ValueError(\\\"You can't start run for initial iteration\\\")\\n\\n if self._run is not None:\\n self.finish_run()\\n\\n logger.info(\\n f\\\"Start a new run for iteration {self._tuning_iteration_id} with params:\\\\n\\\\t{str(params)}\\\"\\n )\\n\\n self._run_params = params\\n run_name: str = self._run_params.id\\n self._run_id = get_run_id_by_name(self._tuning_iteration_id, run_name)\\n\\n self._run = mlflow.start_run(\\n self._run_id, self._tuning_iteration_id, run_name\\n )\\n if self._run_id is None:\\n self._run_id = self._run.info.run_id\\n for key, value in dict(self._tuning_iteration).items():\\n mlflow.log_param(key, convert_value(value))\\n\\n for key, value in dict(self._run_params).items():\\n mlflow.log_param(key, convert_value(value))\\n\\n mlflow.log_metric(\\\"model_uploaded\\\", 0)\\n\\n return False\\n else:\\n return self._run.info.status == \\\"FINISHED\\\"\\n\\n @retry_method(name=\\\"search_runs\\\")\\n def model_is_uploaded(self) -> bool:\\n runs: pd.DataFrame = mlflow.search_runs(\\n experiment_ids=[self._tuning_iteration_id],\\n filter_string=self._get_model_exists_filter(),\\n )\\n runs = runs[runs[\\\"run_id\\\"] == self._run_id]\\n return runs.shape[0] > 0\\n\\n @retry_method(name=\\\"get_experiment\\\")\\n def finish_iteration(self):\\n logger.info(f\\\"Finish current iteration {self._tuning_iteration_id}\\\")\\n self._tuning_iteration = INITIAL_EXPERIMENT_NAME\\n self._tuning_iteration_id = get_experiment_id_by_name(\\n INITIAL_EXPERIMENT_NAME\\n )\\n\\n if self._tuning_iteration_id is None:\\n self._iteration_experiment = mlflow.set_experiment(\\n experiment_name=INITIAL_EXPERIMENT_NAME\\n )\\n self._tuning_iteration_id = (\\n self._iteration_experiment.experiment_id\\n )\\n else:\\n self._iteration_experiment = mlflow.set_experiment(\\n experiment_id=self._tuning_iteration_id\\n )\\n\\n logger.info(f\\\"Current iteration is finished\\\")\\n\\n @retry_method(name=\\\"end_run\\\")\\n def finish_run(self):\\n logger.info(\\n f\\\"Finish current run {self._tuning_iteration_id} / {self._run_id}\\\"\\n )\\n for accumulator in self._accumulators:\\n accumulator.clear()\\n\\n mlflow.end_run()\\n\\n # Set params to default None\\n self._run = None\\n self._run_params = None\\n self._run_id = None\\n\\n logger.info(f\\\"Current run is finished\\\")\\n\\n @retry_method(name=\\\"log_param\\\")\\n def _set_model_as_deleted(self, run_id: str, experiment_id: str):\\n with mlflow.start_run(\\n run_id=run_id, experiment_id=experiment_id\\n ) as run:\\n mlflow.log_metric(\\\"model_deleted\\\", 1)\\n mlflow.log_metric(\\\"model_uploaded\\\", 0)\\n\\n @retry_method(name=\\\"delete_model\\\")\\n def _delete_model(self, run_id: str, experiment_id: str) -> bool:\\n logger.warning(\\n f\\\"Unable to delete a model for run {run_id}, MLFlow has no such functionality, please implement on your own.\\\"\\n )\\n return False\\n\\n @retry_method(name=\\\"get_run\\\")\\n def delete_model(self, run_id: str, experiment_id: Optional[str] = None):\\n experiment_id = (\\n self._tuning_iteration_id\\n if experiment_id is None\\n else experiment_id\\n )\\n if experiment_id is None:\\n raise ValueError(\\n f\\\"No iteration was initialized, unable to delete model.\\\"\\n )\\n\\n if experiment_id == INITIAL_EXPERIMENT_NAME:\\n raise ValueError(f\\\"Initial model can't be deleted.\\\")\\n\\n run_info = None\\n try:\\n run_info = mlflow.get_run(run_id=run_id)\\n except RestException as e:\\n if e.get_http_status_code() == 404:\\n logger.exception(f\\\"Run with ID {run_id} doesn't exist.\\\")\\n else:\\n raise e\\n\\n if run_info is not None:\\n runs: pd.DataFrame = mlflow.search_runs(\\n filter_string=self._get_model_exists_filter()\\n )\\n runs = runs[runs[\\\"run_id\\\"] == run_id]\\n if runs.shape[0] == 0:\\n logger.warning(\\n f\\\"Run {run_id} has no model being uploaded. Nothing to delete\\\"\\n )\\n\\n else:\\n deleted = None\\n try:\\n deleted = self._delete_model(run_id, experiment_id)\\n except MaxAttemptsReachedException:\\n pass\\n\\n if deleted:\\n self._set_model_as_deleted(run_id, experiment_id)\\n\\n @retry_method(name=\\\"log_model\\\")\\n def save_model(\\n self, model: EmbeddingsModelInterface, best_only: bool = True\\n ):\\n \\\"\\\"\\\"Save fine-tuned embedding model\\n\\n :param model: model to be saved\\n :param best_only: save only if it's the best (default: True)\\n \\\"\\\"\\\"\\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\\n raise ValueError(\\n f\\\"Can't save not initial model for {INITIAL_EXPERIMENT_NAME} experiment\\\"\\n )\\n\\n if self._run_id is None:\\n raise ValueError(\\\"There is no current Run\\\")\\n\\n logger.info(\\n f\\\"Save model for {self._tuning_iteration_id} / {self._run_id}\\\"\\n )\\n if not best_only:\\n mlflow.pytorch.log_model(\\n model, \\\"model\\\", pip_requirements=self._requirements\\n )\\n mlflow.log_metric(\\\"model_uploaded\\\", 1)\\n logger.info(\\\"Upload is finished\\\")\\n else:\\n current_quality = self.get_quality()\\n best_run_id, best_quality = self.get_best_quality()\\n\\n if best_run_id is None or (\\n current_quality <= best_quality\\n if self.is_loss\\n else current_quality >= best_quality\\n ):\\n mlflow.pytorch.log_model(\\n model, \\\"model\\\", pip_requirements=self._requirements\\n )\\n mlflow.log_metric(\\\"model_uploaded\\\", 1)\\n logger.info(\\\"Upload is finished\\\")\\n\\n if best_run_id is not None:\\n self.delete_model(best_run_id)\\n else:\\n logger.info(\\\"Not the best run - ignore saving\\\")\\n\\n @retry_method(name=\\\"log_metric\\\")\\n def save_metric(self, metric_value: MetricValue):\\n \\\"\\\"\\\"Accumulate and save metric value\\n\\n :param metric_value: value to be logged\\n \\\"\\\"\\\"\\n for accumulator in self._accumulators:\\n for name, value in accumulator.accumulate(metric_value):\\n mlflow.log_metric(name, value)\\n\\n @retry_method(name=\\\"search_runs\\\")\\n def get_quality(self) -> float:\\n \\\"\\\"\\\"Current run quality value\\n\\n :return: quality value\\n \\\"\\\"\\\"\\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\\n raise ValueError(\\n f\\\"No metrics for {INITIAL_EXPERIMENT_NAME} experiment\\\"\\n )\\n\\n if self._run_id is None:\\n raise ValueError(\\\"There is no current Run\\\")\\n\\n runs: pd.DataFrame = mlflow.search_runs(\\n experiment_ids=[self._tuning_iteration_id]\\n )\\n quality: np.ndarray = runs[runs.run_id == self._run_id][\\n self._metric_field\\n ]\\n return float(quality) if quality.shape[0] == 1 else float(quality[0])\\n\\n @retry_method(name=\\\"search_runs\\\")\\n def _get_best_quality(\\n self, experiment_id: str\\n ) -> Tuple[Optional[str], float]:\\n runs: pd.DataFrame = mlflow.search_runs(\\n experiment_ids=[experiment_id],\\n filter_string=self._get_model_exists_filter(),\\n )\\n runs = runs[runs.status == \\\"FINISHED\\\"] # and not finished ones\\n if runs.shape[0] == 0:\\n logger.warning(\\n \\\"No finished experiments found with model uploaded, except initial\\\"\\n )\\n return None, 0.0\\n\\n else:\\n value: float = (\\n runs[self._metric_field].min()\\n if self.is_loss\\n else runs[self._metric_field].max()\\n )\\n best: pd.DataFrame = runs[runs[self._metric_field] == value][\\n [\\\"run_id\\\", self._metric_field]\\n ]\\n return list(best.itertuples(index=False, name=None))[0]\\n\\n def get_best_quality(self) -> Tuple[str, float]:\\n \\\"\\\"\\\"Get current fine-tuning iteration best quality\\n\\n :return: run_id and best metric value\\n \\\"\\\"\\\"\\n if self._tuning_iteration == INITIAL_EXPERIMENT_NAME:\\n raise ValueError(\\n f\\\"No metrics for {INITIAL_EXPERIMENT_NAME} experiment\\\"\\n )\\n\\n return self._get_best_quality(self._tuning_iteration_id)\"\n },\n {\n \"identifier\": \"FineTuningSettings\",\n \"path\": \"embedding_studio/workers/fine_tuning/experiments/finetuning_settings.py\",\n \"snippet\": \"class FineTuningSettings(BaseModel):\\n \\\"\\\"\\\"\\n\\n :param loss_func: loss object for a ranking task\\n :param metric_calculators: list of trackable metrics calculators (default: None)\\n by default only DistanceShift metric\\n :param ranker: ranking function (query, items) -> ranks (defult: cosine similarity)\\n :param is_similarity: is ranking function similarity like or distance (default: True)\\n :param confidence_calculator: function to calculate results confidences (default: dummy_confidences)\\n :param step_size: optimizer steps (default: 500)\\n :param gamma: optimizers gamma (default: 0.9)\\n :param num_epochs: num of training epochs (default: 10)\\n :param batch_size: count of sessions in a batch (default: 1)\\n :param test_each_n_sessions: frequency of validation, if value in range [0, 1] - used as ratio (default: -1)\\n \\\"\\\"\\\"\\n\\n loss_func: RankingLossInterface\\n metric_calculators: Optional[List[MetricCalculator]] = None\\n ranker: Optional[\\n Callable[[FloatTensor, FloatTensor], FloatTensor]\\n ] = COSINE_SIMILARITY\\n is_similarity: Optional[bool] = True\\n confidence_calculator: Optional[Callable] = dummy_confidences\\n step_size: Optional[int] = 500\\n gamma: Optional[float] = 0.9\\n num_epochs: Optional[int] = 10\\n batch_size: Optional[int] = 1\\n test_each_n_sessions: Optional[Union[float, int]] = -1\\n\\n class Config:\\n arbitrary_types_allowed = True\"\n },\n {\n \"identifier\": \"INITIAL_PARAMS\",\n \"path\": \"embedding_studio/workers/fine_tuning/experiments/initial_params/clip.py\",\n \"snippet\": \"INITIAL_PARAMS: Dict[str, List[Union[int, float]]] = {\\n \\\"num_fixed_layers\\\": [5, 6, 7, 8],\\n \\\"query_lr\\\": [1e-4, 5e-5, 1e-5, 5e-6, 1e-6, 5e-7],\\n \\\"items_lr\\\": [1e-4, 5e-5, 1e-5, 5e-6, 1e-6, 5e-7],\\n \\\"query_weight_decay\\\": [0.0, 1e-6, 1e-5, 1e-4],\\n \\\"items_weight_decay\\\": [0.0, 1e-6, 1e-5, 1e-4],\\n \\\"margin\\\": [0.01, 0.025, 0.05],\\n}\"\n },\n {\n \"identifier\": \"MetricsAccumulator\",\n \"path\": \"embedding_studio/workers/fine_tuning/experiments/metrics_accumulator.py\",\n \"snippet\": \"class MetricsAccumulator:\\n def __init__(\\n self,\\n name: str,\\n calc_mean: bool = False,\\n calc_sliding: bool = False,\\n calc_min: bool = False,\\n calc_max: bool = False,\\n window_size: int = 10,\\n ):\\n \\\"\\\"\\\"Accumulator of metric values + calculator of aggregations like mean, max, min, sliding_mean.\\n\\n :param name: metric name (metrics with other name will be ignored)\\n :param calc_mean: should accumulator calculate mean value (default: False)\\n :param calc_sliding: should accumulator calculate sliding mean value (default: False)\\n :param calc_min: should accumulator calculate min value (default: False)\\n :param calc_max: should accumulator calculate max value (default: False)\\n :param window_size: size of sliding window (default: 10)\\n \\\"\\\"\\\"\\n if not isinstance(name, str) or len(name) == 0:\\n raise ValueError(\\\"MetricsAccumulator's name should not be empty\\\")\\n\\n self._name = name\\n\\n if not isinstance(calc_mean, bool):\\n raise ValueError(\\\"calc_mean value should be bool\\\")\\n self._calc_mean = calc_mean\\n\\n if not isinstance(calc_sliding, bool):\\n raise ValueError(\\\"calc_sliding value should be bool\\\")\\n self._calc_sliding = calc_sliding\\n\\n if not isinstance(calc_min, bool):\\n raise ValueError(\\\"calc_min value should be bool\\\")\\n self._calc_min = calc_min\\n\\n if not isinstance(calc_max, bool):\\n raise ValueError(\\\"calc_max value should be bool\\\")\\n self._calc_max = calc_max\\n\\n if not isinstance(window_size, int) or window_size <= 1:\\n raise ValueError(\\n \\\"window_size value should be integer with value more than 1\\\"\\n )\\n\\n self._window_size = window_size\\n self._values = []\\n\\n @property\\n def name(self) -> str:\\n return self._name\\n\\n def clear(self):\\n \\\"\\\"\\\"Clear accumulator\\\"\\\"\\\"\\n self._values = []\\n\\n def accumulate(self, value: MetricValue) -> List[Tuple[str, float]]:\\n \\\"\\\"\\\"Add metric value to an accumulator.\\n\\n :param value: metric to be accumulated\\n :return: aggregations\\n \\\"\\\"\\\"\\n if self.name == value.name:\\n self._values.append(value.value)\\n\\n return self.aggregate()\\n\\n return []\\n\\n def aggregate(self) -> List[Tuple[str, float]]:\\n \\\"\\\"\\\"Aggregate accumulated metrics\\n\\n :return: metric aggregations (last, mean, sliding, min, max)\\n \\\"\\\"\\\"\\n aggregations: List[Tuple[str, float]] = []\\n if len(self._values) > 0:\\n aggregations.append((self.name, self._values[-1]))\\n if self._calc_mean:\\n aggregations.append(\\n (f\\\"mean_{self.name}\\\", float(np.mean(self._values)))\\n )\\n\\n if self._calc_sliding:\\n slide_value = float(\\n np.mean(self._values)\\n if len(self._values) < self._window_size\\n else np.mean(self._values[-self._window_size :])\\n )\\n aggregations.append((f\\\"sliding_{self.name}\\\", slide_value))\\n\\n if self._calc_min:\\n aggregations.append((f\\\"min_{self.name}\\\", np.min(self._values)))\\n\\n if self._calc_max:\\n aggregations.append((f\\\"max_{self.name}\\\", np.max(self._values)))\\n\\n return aggregations\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from typing import List\nfrom sentence_transformers import SentenceTransformer\nfrom embedding_studio.core.config import settings\nfrom embedding_studio.core.plugin import FineTuningMethod\nfrom embedding_studio.embeddings.data.clickstream.parsers.s3_parser import (\n AWSS3ClickstreamParser,\n)\nfrom embedding_studio.embeddings.data.clickstream.search_event import (\n DummyEventType,\n SearchResult,\n)\nfrom embedding_studio.embeddings.data.clickstream.splitter import (\n ClickstreamSessionsSplitter,\n)\nfrom embedding_studio.embeddings.data.clickstream.text_query_item import (\n TextQueryItem,\n)\nfrom embedding_studio.embeddings.data.clickstream.text_query_retriever import (\n TextQueryRetriever,\n)\nfrom embedding_studio.embeddings.data.loaders.s3.s3_loader import (\n AWSS3DataLoader,\n)\nfrom embedding_studio.embeddings.data.storages.producers.clip import (\n CLIPItemStorageProducer,\n)\nfrom embedding_studio.embeddings.data.utils.fields_normalizer import (\n DatasetFieldsNormalizer,\n)\nfrom embedding_studio.embeddings.losses.prob_cosine_margin_ranking_loss import (\n CosineProbMarginRankingLoss,\n)\nfrom embedding_studio.embeddings.models.text_to_image.clip import (\n TextToImageCLIPModel,\n)\nfrom embedding_studio.models.clickstream.sessions import SessionWithEvents\nfrom embedding_studio.models.plugin import FineTuningBuilder, PluginMeta\nfrom embedding_studio.workers.fine_tuning.data.prepare_data import prepare_data\nfrom embedding_studio.workers.fine_tuning.experiments.experiments_tracker import (\n ExperimentsManager,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.finetuning_settings import (\n FineTuningSettings,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.initial_params.clip import (\n INITIAL_PARAMS,\n)\nfrom embedding_studio.workers.fine_tuning.experiments.metrics_accumulator import (\n MetricsAccumulator,\n)"},"token_num":{"kind":"number","value":16533,"string":"16,533"},"cropped_code":{"kind":"string","value":"\n\n\n\nclass DefaultFineTuningMethod(FineTuningMethod):\n meta = PluginMeta(\n name=\"Default Fine Tuning Method\",\n version=\"0.0.1\",\n description=\"A default fine-tuning plugin\",\n )\n\n def __init__(self):\n # uncomment and pass your credentials to use your own s3 bucket\n # creds = {\n # \"role_arn\": \"arn:aws:iam::123456789012:role/some_data\"\n # \"aws_access_key_id\": \"TESTACCESSKEIDTEST11\",\n # \"aws_secret_access_key\": \"QWERTY1232qdsadfasfg5349BBdf30ekp23odk03\",\n # }\n # self.data_loader = AWSS3DataLoader(**creds)\n\n # with empty creds, use anonymous session\n creds = {\n }\n self.data_loader = AWSS3DataLoader(**creds)\n\n self.retriever = TextQueryRetriever()\n self.parser = AWSS3ClickstreamParser(\n"},"all_code":{"kind":"string","value":"\n\n\n\nclass DefaultFineTuningMethod(FineTuningMethod):\n meta = PluginMeta(\n name=\"Default Fine Tuning Method\",\n version=\"0.0.1\",\n description=\"A default fine-tuning plugin\",\n )\n\n def __init__(self):\n # uncomment and pass your credentials to use your own s3 bucket\n # creds = {\n # \"role_arn\": \"arn:aws:iam::123456789012:role/some_data\"\n # \"aws_access_key_id\": \"TESTACCESSKEIDTEST11\",\n # \"aws_secret_access_key\": \"QWERTY1232qdsadfasfg5349BBdf30ekp23odk03\",\n # }\n # self.data_loader = AWSS3DataLoader(**creds)\n\n # with empty creds, use anonymous session\n creds = {\n }\n self.data_loader = AWSS3DataLoader(**creds)\n\n self.retriever = TextQueryRetriever()\n self.parser = AWSS3ClickstreamParser("},"next_line":{"kind":"string","value":" TextQueryItem, SearchResult, DummyEventType"},"gold_snippet_index":{"kind":"number","value":4,"string":"4"},"created_at":{"kind":"string","value":"2023-10-31 00:33:13+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5682,"cells":{"repo_name":{"kind":"string","value":"facebookresearch/minimax"},"file_path":{"kind":"string","value":"src/minimax/runners/xp_runner.py"},"context":{"kind":"list like","value":[{"identifier":"EvalRunner","path":"src/minimax/runners/eval_runner.py","snippet":"class EvalRunner:\n def __init__(\n self,\n pop,\n env_names,\n env_kwargs=None,\n n_episodes=10,\n agent_idxs='*',\n render_mode=None):\n\n self.pop = pop\n\n if isinstance(agent_idxs, str):\n if \"*\" in agent_idxs:\n self.agent_idxs = np.arange(pop.n_agents)\n else:\n self.agent_idxs = \\\n np.array([int(x) for x in agent_idxs.split(',')])\n else:\n self.agent_idxs = agent_idxs # assume array\n\n assert np.max(self.agent_idxs) < pop.n_agents, \\\n 'Agent index is out of bounds.'\n\n if isinstance(env_names, str):\n env_names = [\n x.strip() for x in env_names.split(',')\n ]\n\n self.n_episodes = n_episodes\n env_infos = create_envs_for_kwargs(env_names, env_kwargs)\n env_names = []\n self.ext_env_names = []\n env_kwargs = []\n for (name, ext_name, kwargs) in env_infos:\n env_names.append(name)\n self.ext_env_names.append(ext_name)\n env_kwargs.append(kwargs)\n self.n_envs = len(env_names)\n\n self.benvs = []\n self.env_params = []\n self.env_has_solved_rate = []\n for env_name, kwargs in zip(env_names, env_kwargs):\n benv = envs.BatchEnv(\n env_name=env_name,\n n_parallel=n_episodes,\n n_eval=1,\n env_kwargs=kwargs,\n wrappers=['monitor_return', 'monitor_ep_metrics']\n )\n self.benvs.append(benv)\n self.env_params.append(benv.env.params)\n self.env_has_solved_rate.append(benv.env.eval_solved_rate is not None)\n\n self.action_dtype = self.benvs[0].env.action_space().dtype\n\n monitored_metrics = self.benvs[0].env.get_monitored_metrics()\n self.rolling_stats = RollingStats(names=monitored_metrics, window=1)\n self._update_ep_stats = jax.vmap(\n jax.vmap(\n self.rolling_stats.update_stats, in_axes=(0,0,0,None)),\n in_axes=(0,0,0,None))\n\n self.test_return_pre = 'test_return'\n self.test_solved_rate_pre = 'test_solved_rate'\n\n self.render_mode = render_mode\n if render_mode:\n from minimax.envs.viz.grid_viz import GridVisualizer\n self.viz = GridVisualizer()\n self.viz.show()\n\n if render_mode == 'ipython':\n from IPython import display\n self.ipython_display = display\n\n def load_checkpoint_state(self, runner_state, state):\n runner_state = list(runner_state)\n runner_state[1] = runner_state[1].load_state_dict(state[1])\n\n return tuple(runner_state)\n\n @partial(jax.jit, static_argnums=(0,2))\n def _get_transition(\n self,\n rng,\n benv,\n params,\n state,\n obs,\n carry,\n zero_carry,\n extra):\n value, pi_params, next_carry = self.pop.act(params, obs, carry)\n pi = self.pop.get_action_dist(pi_params, dtype=self.action_dtype)\n rng, subrng = jax.random.split(rng)\n action = pi.sample(seed=subrng)\n log_pi = pi.log_prob(action)\n\n rng, *vrngs = jax.random.split(rng, self.pop.n_agents+1)\n\n step_args = (jnp.array(vrngs), state, action, extra)\n (next_obs, \n next_state, \n reward, \n done, \n info, \n extra) = benv.step(*step_args)\n\n # Add transition to storage\n step = (obs, action, reward, done, log_pi, value)\n if carry is not None:\n step += (carry,)\n\n # Zero carry if needed\n if carry is not None:\n next_carry = jax.vmap(_tree_util.pytree_select)(\n done, zero_carry, next_carry)\n\n if self.render_mode:\n self.viz.render(\n benv.env.params, \n jax.tree_util.tree_map(lambda x: x[0][0], state))\n if self.render_mode == 'ipython':\n self.ipython_display.display(self.viz.window.fig)\n self.ipython_display.clear_output(wait=True)\n\n return next_state, next_obs, next_carry, done, info, extra\n\n @partial(jax.jit, static_argnums=(0, 2))\n def _rollout_benv(\n self, \n rng, \n benv,\n params,\n env_params,\n state,\n obs,\n carry,\n zero_carry,\n extra,\n ep_stats):\n\n def _scan_rollout(scan_carry, rng):\n (state, \n obs, \n carry,\n extra, \n ep_stats) = scan_carry\n \n step = \\\n self._get_transition(\n rng,\n benv,\n params, \n state, \n obs, \n carry, \n zero_carry,\n extra)\n\n (next_state, \n next_obs, \n next_carry, \n done, \n info, \n extra) = step\n\n ep_stats = self._update_ep_stats(ep_stats, done, info, 1)\n\n return (next_state, next_obs, next_carry, extra, ep_stats), None\n\n n_steps = benv.env.max_episode_steps()\n rngs = jax.random.split(rng, n_steps)\n (state, \n obs, \n carry, \n extra,\n ep_stats),_ = jax.lax.scan(\n _scan_rollout,\n (state, obs, carry, extra, ep_stats),\n rngs,\n length=n_steps)\n\n return ep_stats\n\n @partial(jax.jit, static_argnums=(0,))\n def run(self, rng, params):\n \"\"\"\n Rollout agents on each env. \n\n For each env, run n_eval episodes in parallel, \n where each is indexed to return in order.\n \"\"\"\n eval_stats = self.fake_run(rng, params)\n rng, *rollout_rngs = jax.random.split(rng, self.n_envs+1)\n for i, (benv, env_param) in enumerate(zip(self.benvs, self.env_params)):\n rng, *reset_rngs = jax.random.split(rng, self.pop.n_agents+1)\n obs, state, extra = benv.reset(jnp.array(reset_rngs))\n\n if self.pop.agent.is_recurrent:\n rng, subrng = jax.random.split(rng)\n zero_carry = self.pop.init_carry(subrng, obs)\n else:\n zero_carry = None\n\n # Reset episodic stats\n ep_stats = self.rolling_stats.reset_stats(\n batch_shape=(self.pop.n_agents, self.n_episodes))\n\n ep_stats = self._rollout_benv(\n rollout_rngs[i],\n benv,\n jax.lax.stop_gradient(params), \n env_param, \n state, \n obs,\n zero_carry,\n zero_carry,\n extra,\n ep_stats)\n \n env_name = self.ext_env_names[i]\n mean_return = ep_stats['return'].mean(1)\n\n if self.env_has_solved_rate[i]:\n mean_solved_rate = jax.vmap(jax.vmap(benv.env.eval_solved_rate))(ep_stats).mean(1)\n\n for idx in self.agent_idxs:\n eval_stats[f'eval/a{idx}:{self.test_return_pre}:{env_name}'] = mean_return[idx].squeeze()\n if self.env_has_solved_rate[i]:\n eval_stats[f'eval/a{idx}:{self.test_solved_rate_pre}:{env_name}'] = mean_solved_rate[idx].squeeze()\n\n return eval_stats\n\n def fake_run(self, rng, params):\n eval_stats = {}\n for i, env_name in enumerate(self.ext_env_names):\n for idx in self.agent_idxs:\n eval_stats.update({\n f'eval/a{idx}:{self.test_return_pre}:{env_name}':0.\n })\n if self.env_has_solved_rate[i]:\n eval_stats.update({\n f'eval/a{idx}:{self.test_solved_rate_pre}:{env_name}':0.,\n })\n\n return eval_stats"},{"identifier":"DRRunner","path":"src/minimax/runners/dr_runner.py","snippet":"class DRRunner:\n\t\"\"\"\n\tOrchestrates rollouts across one or more students. \n\tThe main components at play:\n\t- AgentPop: Manages train state and batched inference logic \n\t\tfor a population of agents.\n\t- BatchEnv: Manages environment step and reset logic, using a \n\t\tpopulaton of agents.\n\t- RolloutStorage: Manages the storing and sampling of collected txns.\n\t- PPO: Handles PPO updates, which take a train state + batch of txns.\n\t\"\"\"\n\tdef __init__(\n\t\tself, \n\t\tenv_name,\n\t\tenv_kwargs,\n\t\tstudent_agents,\n\t\tn_students=1,\n\t\tn_parallel=1,\n\t\tn_eval=1,\n\t\tn_rollout_steps=256,\n\t\tlr=1e-4,\n\t\tlr_final=None,\n\t\tlr_anneal_steps=0,\n\t\tmax_grad_norm=0.5,\n\t\tdiscount=0.99,\n\t\tgae_lambda=0.95,\n\t\tadam_eps=1e-5,\n\t\tnormalize_return=False,\n\t\ttrack_env_metrics=False,\n\t\tn_unroll_rollout=1,\n\t\tn_devices=1,\n\t\trender=False):\n\n\t\tassert len(student_agents) == 1, 'Only one type of student supported.'\n\t\tassert n_parallel % n_devices == 0, 'Num envs must be divisible by num devices.'\n\n\t\tself.n_students = n_students\n\t\tself.n_parallel = n_parallel // n_devices\n\t\tself.n_eval = n_eval\n\t\tself.n_devices = n_devices\n\t\tself.step_batch_size = n_students*n_eval*n_parallel\n\t\tself.n_rollout_steps = n_rollout_steps\n\t\tself.n_updates = 0\n\t\tself.lr = lr\n\t\tself.lr_final = lr if lr_final is None else lr_final\n\t\tself.lr_anneal_steps = lr_anneal_steps\n\t\tself.max_grad_norm = max_grad_norm\n\t\tself.adam_eps = adam_eps\n\t\tself.normalize_return = normalize_return\n\t\tself.track_env_metrics = track_env_metrics\n\t\tself.n_unroll_rollout = n_unroll_rollout\n\t\tself.render = render\n\n\t\tself.student_pop = AgentPop(student_agents[0], n_agents=n_students)\n\n\t\tself.env, self.env_params = envs.make(\n\t\t\tenv_name, \n\t\t\tenv_kwargs=env_kwargs\n\t\t)\n\t\tself._action_shape = self.env.action_space().shape\n\n\t\tself.benv = envs.BatchEnv(\n\t\t\tenv_name=env_name,\n\t\t\tn_parallel=self.n_parallel,\n\t\t\tn_eval=self.n_eval,\n\t\t\tenv_kwargs=env_kwargs,\n\t\t\twrappers=['monitor_return', 'monitor_ep_metrics']\n\t\t)\n\t\tself.action_dtype = self.benv.env.action_space().dtype\n\n\t\tself.student_rollout = RolloutStorage(\n\t\t\tdiscount=discount,\n\t\t\tgae_lambda=gae_lambda,\n\t\t\tn_steps=n_rollout_steps,\n\t\t\tn_agents=n_students,\n\t\t\tn_envs=self.n_parallel,\n\t\t\tn_eval=self.n_eval,\n\t\t\taction_space=self.env.action_space(),\n\t\t\tobs_space=self.env.observation_space(),\n\t\t\tagent=self.student_pop.agent,\n\t\t)\n\n\t\tmonitored_metrics = self.benv.env.get_monitored_metrics()\n\t\tself.rolling_stats = RollingStats(\n\t\t\tnames=monitored_metrics,\n\t\t\twindow=10,\n\t\t)\n\t\tself._update_ep_stats = jax.vmap(jax.vmap(self.rolling_stats.update_stats))\n\n\t\tif self.render:\n\t\t\tfrom envs.viz.grid_viz import GridVisualizer\n\t\t\tself.viz = GridVisualizer()\n\t\t\tself.viz.show()\n\n\tdef reset(self, rng):\n\t\tself.n_updates = 0\n\n\t\tn_parallel = self.n_parallel*self.n_devices\n\n\t\trngs, *vrngs = jax.random.split(rng, self.n_students+1)\n\t\tobs, state, extra = self.benv.reset(jnp.array(vrngs), n_parallel=n_parallel)\n\t\tdummy_obs = jax.tree_util.tree_map(lambda x: x[0], obs) # for one agent only\n\n\t\trng, subrng = jax.random.split(rng)\n\t\tif self.student_pop.agent.is_recurrent:\n\t\t\tcarry = self.student_pop.init_carry(subrng, obs)\n\t\t\tself.zero_carry = jax.tree_map(lambda x: x.at[:,:self.n_parallel].get(), carry)\n\t\telse:\n\t\t\tcarry = None\n\n\t\trng, subrng = jax.random.split(rng)\n\t\tparams = self.student_pop.init_params(subrng, dummy_obs)\n\n\t\tschedule_fn = optax.linear_schedule(\n\t\t\tinit_value=-float(self.lr),\n\t\t\tend_value=-float(self.lr_final),\n\t\t\ttransition_steps=self.lr_anneal_steps,\n\t\t)\n\n\t\ttx = optax.chain(\n\t\t\toptax.clip_by_global_norm(self.max_grad_norm),\n\t\t\toptax.adam(learning_rate=float(self.lr), eps=self.adam_eps)\n\t\t)\n\n\t\ttrain_state = VmapTrainState.create(\n\t\t\tapply_fn=self.student_pop.agent.evaluate,\n\t\t\tparams=params,\n\t\t\ttx=tx\n\t\t)\n\n\t\tep_stats = self.rolling_stats.reset_stats(\n\t\t\tbatch_shape=(self.n_students, n_parallel*self.n_eval))\n\n\t\tstart_state = state\n\n\t\treturn (\n\t\t\trng, \n\t\t\ttrain_state, \n\t\t\tstate,\n\t\t\tstart_state, # Used to track metrics from starting state\n\t\t\tobs, \n\t\t\tcarry, \n\t\t\textra, \n\t\t\tep_stats\n\t\t)\n\n\tdef get_checkpoint_state(self, state):\n\t\t_state = list(state)\n\t\t_state[1] = state[1].state_dict\n\n\t\treturn _state\n\n\tdef load_checkpoint_state(self, runner_state, state):\n\t\trunner_state = list(runner_state)\n\t\trunner_state[1] = runner_state[1].load_state_dict(state[1])\n\n\t\treturn tuple(runner_state)\n\n\t@partial(jax.jit, static_argnums=(0,2))\n\tdef _get_transition(\n\t\tself, \n\t\trng, \n\t\tpop, \n\t\tparams, \n\t\trollout, \n\t\tstate, \n\t\tstart_state, \n\t\tobs, \n\t\tcarry, \n\t\tdone,\n\t\textra=None):\n\t\t# Sample action\n\t\tvalue, pi_params, next_carry = pop.act(params, obs, carry, done)\n\n\t\tpi = pop.get_action_dist(pi_params, dtype=self.action_dtype)\n\t\trng, subrng = jax.random.split(rng)\n\t\taction = pi.sample(seed=subrng)\n\t\tlog_pi = pi.log_prob(action)\n\n\t\trng, *vrngs = jax.random.split(rng, self.n_students+1)\n\t\t(next_obs, \n\t\t next_state, \n\t\t reward, \n\t\t done, \n\t\t info, \n\t\t extra) = self.benv.step(jnp.array(vrngs), state, action, extra)\n\n\t\tnext_start_state = jax.vmap(_tree_util.pytree_select)(\n\t\t\tdone, next_state, start_state\n\t\t)\n\n\t\t# Add transition to storage\n\t\tstep = (obs, action, reward, done, log_pi, value)\n\t\tif carry is not None:\n\t\t\tstep += (carry,)\n\n\t\trollout = self.student_rollout.append(rollout, *step)\n\n\t\tif self.render:\n\t\t\tself.viz.render(\n\t\t\t\tself.benv.env.params, \n\t\t\t\tjax.tree_util.tree_map(lambda x: x[0][0], state))\n\n\t\treturn (\n\t\t\trollout, \n\t\t\tnext_state,\n\t\t\tnext_start_state, \n\t\t\tnext_obs, \n\t\t\tnext_carry, \n\t\t\tdone, \n\t\t\tinfo, \n\t\t\textra\n\t\t)\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef _rollout_students(\n\t\tself, \n\t\trng, \n\t\ttrain_state, \n\t\tstate, \n\t\tstart_state, \n\t\tobs, \n\t\tcarry, \n\t\tdone,\n\t\textra=None, \n\t\tep_stats=None):\n\t\trollout = self.student_rollout.reset()\n\n\t\trngs = jax.random.split(rng, self.n_rollout_steps)\n\n\t\tdef _scan_rollout(scan_carry, rng):\n\t\t\trollout, state, start_state, obs, carry, done, extra, ep_stats, train_state = scan_carry \n\n\t\t\tnext_scan_carry = \\\n\t\t\t\tself._get_transition(\n\t\t\t\t\trng, \n\t\t\t\t\tself.student_pop, \n\t\t\t\t\tjax.lax.stop_gradient(train_state.params), \n\t\t\t\t\trollout, \n\t\t\t\t\tstate,\n\t\t\t\t\tstart_state, \n\t\t\t\t\tobs, \n\t\t\t\t\tcarry,\n\t\t\t\t\tdone, \n\t\t\t\t\textra)\n\t\t\t(rollout, \n\t\t\t next_state,\n\t\t\t next_start_state, \n\t\t\t next_obs, \n\t\t\t next_carry, \n\t\t\t done, \n\t\t\t info, \n\t\t\t extra) = next_scan_carry\n\n\t\t\tep_stats = self._update_ep_stats(ep_stats, done, info)\n\n\t\t\treturn (\n\t\t\t\trollout, \n\t\t\t\tnext_state,\n\t\t\t\tnext_start_state,\n\t\t\t\tnext_obs, \n\t\t\t\tnext_carry,\n\t\t\t\tdone,\n\t\t\t\textra, \n\t\t\t\tep_stats,\n\t\t\t\ttrain_state), None\n\n\t\t(rollout, \n\t\t state, \n\t\t start_state, \n\t\t obs, \n\t\t carry, \n\t\t done,\n\t\t extra, \n\t\t ep_stats,\n\t\t train_state), _ = jax.lax.scan(\n\t\t\t_scan_rollout,\n\t\t\t(rollout, \n\t\t\t state, \n\t\t\t start_state,\n\t\t\t obs, \n\t\t\t carry, \n\t\t\t done,\n\t\t\t extra, \n\t\t\t ep_stats,\n\t\t\t train_state),\n\t\t\trngs,\n\t\t\tlength=self.n_rollout_steps,\n\t\t)\n\n\t\treturn rollout, state, start_state, obs, carry, extra, ep_stats, train_state\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef _compile_stats(self, update_stats, ep_stats, env_metrics=None):\n\t\tstats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(\n\t\t\t{k:ep_stats[k] for k in self.rolling_stats.names}\n\t\t)\n\t\tstats.update(update_stats)\n\n\t\tif self.n_students > 1:\n\t\t\t_stats = {}\n\t\t\tfor i in range(self.n_students):\n\t\t\t\t_student_stats = jax.tree_util.tree_map(lambda x: x[i], stats) # for agent0\n\t\t\t\t_stats.update({f'a{i}/{k}':v for k,v in _student_stats.items()})\n\t\t\tstats = _stats\n\n\t\tif self.track_env_metrics:\n\t\t\tmean_env_metrics = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(env_metrics)\n\t\t\tmean_env_metrics = {f'env/{k}':v for k,v in mean_env_metrics.items()}\n\n\t\t\tif self.n_students > 1:\n\t\t\t\t_env_metrics = {}\n\t\t\t\tfor i in range(self.n_students):\n\t\t\t\t\t_student_env_metrics = jax.tree_util.tree_map(lambda x: x[i], mean_env_metrics) # for agent0\n\t\t\t\t\t_env_metrics.update({f'{k}_a{i}':v for k,v in _student_env_metrics.items()})\n\t\t\t\tmean_env_metrics = _env_metrics\n\n\t\t\tstats.update(mean_env_metrics)\n\n\t\tif self.n_students == 1:\n\t\t\tstats = jax.tree_map(lambda x: x[0], stats)\n\n\t\tif self.n_devices > 1:\n\t\t\tstats = jax.tree_map(lambda x: jax.lax.pmean(x, 'device'), stats)\n\n\t\treturn stats\n\n\tdef get_shmap_spec(self):\n\t\trunner_state_size = len(inspect.signature(self.run).parameters)\n\t\tin_spec = [P(None,'device'),]*(runner_state_size)\n\t\tout_spec = [P(None,'device'),]*(runner_state_size)\n\n\t\tin_spec[:2] = [P(None),]*2\n\t\tin_spec = tuple(in_spec)\n\t\tout_spec = (P(None),) + in_spec\n\n\t\treturn in_spec, out_spec\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef run(\n\t\tself, \n\t\trng, \n\t\ttrain_state, \n\t\tstate, \n\t\tstart_state,\n\t\tobs, \n\t\tcarry=None, \n\t\textra=None, \n\t\tep_stats=None):\n\t\t\"\"\"\n\t\tPerform one update step: rollout all students and teachers + update with PPO\n\t\t\"\"\"\n\t\tif self.n_devices > 1:\n\t\t\trng = jax.random.fold_in(rng, jax.lax.axis_index('device'))\n\n\t\trng, *vrngs = jax.random.split(rng, self.n_students+1)\n\t\trollout_batch_shape = (self.n_students, self.n_parallel*self.n_eval)\n\n\t\tobs, state, extra = self.benv.reset(jnp.array(vrngs))\n\t\tep_stats = self.rolling_stats.reset_stats(\n\t\t\tbatch_shape=rollout_batch_shape)\n\n\t\trollout_start_state = state\n\n\t\tdone = jnp.zeros(rollout_batch_shape, dtype=jnp.bool_)\n\t\trng, subrng = jax.random.split(rng)\n\t\trollout, state, start_state, obs, carry, extra, ep_stats, train_state = \\\n\t\t\tself._rollout_students(\n\t\t\t\tsubrng, \n\t\t\t\ttrain_state, \n\t\t\t\tstate, \n\t\t\t\tstart_state,\n\t\t\t\tobs, \n\t\t\t\tcarry, \n\t\t\t\tdone,\n\t\t\t\textra, \n\t\t\t\tep_stats\n\t\t\t)\n\n\t\ttrain_batch = self.student_rollout.get_batch(\n\t\t\trollout, \n\t\t\tself.student_pop.get_value(\n\t\t\t\tjax.lax.stop_gradient(train_state.params), \n\t\t\t\tobs, \n\t\t\t\tcarry,\n\t\t\t)\n\t\t)\n\n\t\t# PPOAgent vmaps over the train state and batch. Batch must be N x EM\n\t\trng, subrng = jax.random.split(rng)\n\t\ttrain_state, update_stats = self.student_pop.update(subrng, train_state, train_batch)\n\n\t\t# Collect env metrics\n\t\tif self.track_env_metrics:\n\t\t\tenv_metrics = self.benv.get_env_metrics(rollout_start_state)\n\t\telse:\n\t\t\tenv_metrics = None\n\n\t\tstats = self._compile_stats(update_stats, ep_stats, env_metrics)\n\t\tstats.update(dict(n_updates=train_state.n_updates[0]))\n\n\t\ttrain_state = train_state.increment()\n\t\tself.n_updates += 1\n\n\t\treturn (\n\t\t\tstats, \n\t\t\trng, \n\t\t\ttrain_state, \n\t\t\tstate, \n\t\t\tstart_state, \n\t\t\tobs, \n\t\t\tcarry, \n\t\t\textra, \n\t\t\tep_stats\n\t\t)"},{"identifier":"PAIREDRunner","path":"src/minimax/runners/paired_runner.py","snippet":"class PAIREDRunner:\n\t\"\"\"\n\tOrchestrates rollouts across one or more students and teachers. \n\tThe main components at play:\n\t- AgentPop: Manages train state and batched inference logic \n\t\tfor a population of agents.\n\t- BatchUEDEnv: Manages environment step and reset logic for a \n\t\tpopulation of agents batched over a pair of student and \n\t\tteacher MDPs.\n\t- RolloutStorage: Manages the storing and sampling of collected txns.\n\t- PPO: Handles PPO updates, which take a train state + batch of txns.\n\t\"\"\"\n\tdef __init__(\n\t\tself, \n\t\tenv_name,\n\t\tenv_kwargs,\n\t\tued_env_kwargs,\n\t\tstudent_agents,\n\t\tn_students=2,\n\t\tn_parallel=1,\n\t\tn_eval=1,\n\t\tn_rollout_steps=250,\n\t\tlr=1e-4,\n\t\tlr_final=None,\n\t\tlr_anneal_steps=0,\n\t\tmax_grad_norm=0.5,\n\t\tdiscount=0.99,\n\t\tgae_lambda=0.95,\n\t\tadam_eps=1e-5,\n\t\tteacher_lr=None,\n\t\tteacher_lr_final=None,\n\t\tteacher_lr_anneal_steps=None,\n\t\tteacher_discount=0.99,\n\t\tteacher_gae_lambda=0.95,\n\t\tteacher_agents=None,\n\t\tued_score='relative_regret',\n\t\ttrack_env_metrics=False,\n\t\tn_unroll_rollout=1,\n\t\trender=False,\n\t\tn_devices=1):\n\t\tassert n_parallel % n_devices == 0, 'Num envs must be divisible by num devices.'\n\n\t\tued_score = UEDScore[ued_score.upper()]\n\n\t\tassert len(student_agents) == 1, \\\n\t\t\t'Only one type of student supported.'\n\t\tassert not (n_students > 2 and ued_score in [UEDScore.RELATIVE_REGRET, UEDScore.MEAN_RELATIVE_REGRET]), \\\n\t\t\t'Standard PAIRED uses only 2 students.'\n\t\tassert teacher_agents is None or len(teacher_agents) == 1, \\\n\t\t\t'Only one type of teacher supported.'\n\n\t\tself.n_students = n_students\n\t\tself.n_parallel = n_parallel // n_devices\n\t\tself.n_eval = n_eval\n\t\tself.n_devices = n_devices\n\t\tself.step_batch_size = n_students*n_eval*n_parallel\n\t\tself.n_rollout_steps = n_rollout_steps\n\t\tself.n_updates = 0\n\t\tself.lr = lr\n\t\tself.lr_final = lr if lr_final is None else lr_final\n\t\tself.lr_anneal_steps = lr_anneal_steps\n\t\tself.teacher_lr = \\\n\t\t\tlr if teacher_lr is None else lr\n\t\tself.teacher_lr_final = \\\n\t\t\tself.lr_final if teacher_lr_final is None else teacher_lr_final\n\t\tself.teacher_lr_anneal_steps = \\\n\t\t\tlr_anneal_steps if teacher_lr_anneal_steps is None else teacher_lr_anneal_steps\n\t\tself.max_grad_norm = max_grad_norm\n\t\tself.adam_eps = adam_eps\n\t\tself.ued_score = ued_score\n\t\tself.track_env_metrics = track_env_metrics\n\n\t\tself.n_unroll_rollout = n_unroll_rollout\n\t\tself.render = render\n\n\t\tself.student_pop = AgentPop(student_agents[0], n_agents=n_students)\n\n\t\tif teacher_agents is not None:\n\t\t\tself.teacher_pop = AgentPop(teacher_agents[0], n_agents=1)\n\n\t\t# This ensures correct partial-episodic bootstrapping by avoiding\n\t\t# any termination purely due to timeouts.\n\t\t# env_kwargs.max_episode_steps = self.n_rollout_steps + 1\n\t\tself.benv = envs.BatchUEDEnv(\n\t\t\tenv_name=env_name,\n\t\t\tn_parallel=self.n_parallel,\n\t\t\tn_eval=n_eval,\n\t\t\tenv_kwargs=env_kwargs,\n\t\t\tued_env_kwargs=ued_env_kwargs,\n\t\t\twrappers=['monitor_return', 'monitor_ep_metrics'],\n\t\t\tued_wrappers=[]\n\t\t)\n\t\tself.teacher_n_rollout_steps = \\\n\t\t\tself.benv.env.ued_max_episode_steps()\n\n\t\tself.student_rollout = RolloutStorage(\n\t\t\tdiscount=discount,\n\t\t\tgae_lambda=gae_lambda,\n\t\t\tn_steps=n_rollout_steps,\n\t\t\tn_agents=n_students,\n\t\t\tn_envs=self.n_parallel,\n\t\t\tn_eval=self.n_eval,\n\t\t\taction_space=self.benv.env.action_space(),\n\t\t\tobs_space=self.benv.env.observation_space(),\n\t\t\tagent=self.student_pop.agent\n\t\t)\n\n\t\tself.teacher_rollout = RolloutStorage(\n\t\t\tdiscount=teacher_discount,\n\t\t\tgae_lambda=teacher_gae_lambda,\n\t\t\tn_steps=self.teacher_n_rollout_steps,\n\t\t\tn_agents=1,\n\t\t\tn_envs=self.n_parallel,\n\t\t\tn_eval=1,\n\t\t\taction_space=self.benv.env.ued_action_space(),\n\t\t\tobs_space=self.benv.env.ued_observation_space(),\n\t\t\tagent=self.teacher_pop.agent,\n\t\t)\n\n\t\tued_monitored_metrics = ('return',)\n\t\tself.ued_rolling_stats = RollingStats(\t\n\t\t\tnames=ued_monitored_metrics,\n\t\t\twindow=10,\n\t\t)\n\t\t\n\t\tmonitored_metrics = self.benv.env.get_monitored_metrics()\n\t\tself.rolling_stats = RollingStats(\n\t\t\tnames=monitored_metrics,\n\t\t\twindow=10,\n\t\t)\n\n\t\tself._update_ep_stats = jax.vmap(jax.vmap(self.rolling_stats.update_stats))\n\t\tself._update_ued_ep_stats = jax.vmap(jax.vmap(self.ued_rolling_stats.update_stats))\n\n\t\tif self.render:\n\t\t\tfrom envs.viz.grid_viz import GridVisualizer\n\t\t\tself.viz = GridVisualizer()\n\t\t\tself.viz.show()\n\n\tdef reset(self, rng):\n\t\tself.n_updates = 0\n\n\t\tn_parallel = self.n_parallel*self.n_devices\n\n\t\trng, student_rng, teacher_rng = jax.random.split(rng,3)\n\t\tstudent_info = self._reset_pop(\n\t\t\t\tstudent_rng, \n\t\t\t\tself.student_pop, \n\t\t\t\tpartial(self.benv.reset, sub_batch_size=n_parallel*self.n_eval),\n\t\t\t\tn_parallel_ep=n_parallel*self.n_eval,\n\t\t\t\tlr_init=self.lr,\n\t\t\t\tlr_final=self.lr_final,\n\t\t\t\tlr_anneal_steps=self.lr_anneal_steps)\n\n\t\tteacher_info = self._reset_pop(\n\t\t\tteacher_rng, \n\t\t\tself.teacher_pop, \n\t\t\tpartial(self.benv.reset_teacher, n_parallel=n_parallel),\n\t\t\tn_parallel_ep=n_parallel,\n\t\t\tlr_init=self.teacher_lr,\n\t\t\tlr_final=self.teacher_lr_final,\n\t\t\tlr_anneal_steps=self.teacher_lr_anneal_steps)\n\n\t\treturn (\n\t\t\trng,\n\t\t\t*student_info,\n\t\t\t*teacher_info\n\t\t)\n\n\tdef _reset_pop(\n\t\tself, \n\t\trng, \n\t\tpop, \n\t\tenv_reset_fn, \n\t\tn_parallel_ep=1,\n\t\tlr_init=3e-4,\n\t\tlr_final=3e-4,\n\t\tlr_anneal_steps=0):\n\t\trng, *vrngs = jax.random.split(rng, pop.n_agents+1)\n\t\treset_out = env_reset_fn(jnp.array(vrngs))\n\t\tif len(reset_out) == 2:\n\t\t\tobs, state = reset_out\n\t\telse:\n\t\t\tobs, state, extra = reset_out\n\t\tdummy_obs = jax.tree_util.tree_map(lambda x: x[0], obs) # for one agent only\n\n\t\trng, subrng = jax.random.split(rng)\n\t\tif pop.agent.is_recurrent:\n\t\t\tcarry = pop.init_carry(subrng, obs)\n\t\telse:\n\t\t\tcarry = None\n\n\t\trng, subrng = jax.random.split(rng)\n\t\tparams = pop.init_params(subrng, dummy_obs)\n\n\t\tschedule_fn = optax.linear_schedule(\n\t\t\tinit_value=-float(lr_init),\n\t\t\tend_value=-float(lr_final),\n\t\t\ttransition_steps=lr_anneal_steps,\n\t\t)\n\n\t\ttx = optax.chain(\n\t\t\toptax.clip_by_global_norm(self.max_grad_norm),\n\t\t\toptax.scale_by_adam(eps=self.adam_eps),\n\t\t\toptax.scale_by_schedule(schedule_fn),\n\t\t)\n\n\t\ttrain_state = VmapTrainState.create(\n\t\t\tapply_fn=pop.agent.evaluate,\n\t\t\tparams=params,\n\t\t\ttx=tx\n\t\t)\n\t\t\n\t\tep_stats = self.rolling_stats.reset_stats(\n\t\t\tbatch_shape=(pop.n_agents,n_parallel_ep))\n\n\t\treturn train_state, state, obs, carry, ep_stats\n\n\tdef get_checkpoint_state(self, state):\n\t\t_state = list(state)\n\t\t_state[1] = state[1].state_dict\n\t\t_state[6] = state[6].state_dict\n\n\t\treturn _state\n\n\tdef load_checkpoint_state(self, runner_state, state):\n\t\trunner_state = list(runner_state)\n\t\trunner_state[1] = runner_state[1].load_state_dict(state[1])\n\t\trunner_state[6] = runner_state[6].load_state_dict(state[6])\n\n\t\treturn tuple(runner_state)\n\n\t@partial(jax.jit, static_argnums=(0,2,3))\n\tdef _get_transition(\n\t\tself,\n\t\trng, \n\t\tpop, \n\t\trollout_mgr, \n\t\trollout, \n\t\tparams, \n\t\tstate, \n\t\tobs, \n\t\tcarry, \n\t\tdone,\n\t\treset_state=None,\n\t\textra=None):\n\t\t# Sample action\n\t\tvalue, pi_params, next_carry = pop.act(params, obs, carry, done)\n\t\tpi = pop.get_action_dist(pi_params)\n\t\trng, subrng = jax.random.split(rng)\n\t\taction = pi.sample(seed=subrng)\n\t\tlog_pi = pi.log_prob(action)\n\n\t\trng, *vrngs = jax.random.split(rng, pop.n_agents+1)\n\n\t\tif pop is self.student_pop:\n\t\t\tstep_fn = self.benv.step_student\n\t\telse:\n\t\t\tstep_fn = self.benv.step_teacher\n\t\tstep_args = (jnp.array(vrngs), state, action)\n\n\t\tif reset_state is not None: # Needed for student to reset to same instance\n\t\t\tstep_args += (reset_state,)\n\n\t\tif extra is not None:\n\t\t\tstep_args += (extra,)\n\t\t\tnext_obs, next_state, reward, done, info, extra = step_fn(*step_args)\n\t\telse:\n\t\t\tnext_obs, next_state, reward, done, info = step_fn(*step_args)\n\n\t\t# Add transition to storage\n\t\tstep = (obs, action, reward, done, log_pi, value)\n\t\tif carry is not None:\n\t\t\tstep += (carry,)\n\n\t\trollout = rollout_mgr.append(rollout, *step)\n\n\t\tif self.render and pop is self.student_pop:\n\t\t\tself.viz.render(\n\t\t\t\tself.benv.env.env.params, \n\t\t\t\tjax.tree_util.tree_map(lambda x: x[0][0], state))\n\n\t\treturn rollout, next_state, next_obs, next_carry, done, info, extra\n\n\t@partial(jax.jit, static_argnums=(0,2,3,4))\n\tdef _rollout(\n\t\tself, \n\t\trng, \n\t\tpop, \n\t\trollout_mgr,\n\t\tn_steps,\n\t\tparams, \n\t\tstate, \n\t\tobs, \n\t\tcarry, \n\t\tdone,\n\t\treset_state=None, \n\t\textra=None, \n\t\tep_stats=None):\n\t\trngs = jax.random.split(rng, n_steps)\n\n\t\trollout = rollout_mgr.reset()\n\n\t\tdef _scan_rollout(scan_carry, rng):\n\t\t\t(rollout, \n\t\t\t state, \n\t\t\t obs, \n\t\t\t carry,\n\t\t\t done, \n\t\t\t extra, \n\t\t\t ep_stats) = scan_carry\n\t\t\t\n\t\t\tnext_scan_carry = \\\n\t\t\t\tself._get_transition(\n\t\t\t\t\trng,\n\t\t\t\t\tpop, \n\t\t\t\t\trollout_mgr,\n\t\t\t\t\trollout,\n\t\t\t\t\tparams, \n\t\t\t\t\tstate, \n\t\t\t\t\tobs, \n\t\t\t\t\tcarry, \n\t\t\t\t\tdone,\n\t\t\t\t\treset_state, \n\t\t\t\t\textra)\n\n\t\t\t(rollout, \n\t\t\t next_state, \n\t\t\t next_obs, \n\t\t\t next_carry, \n\t\t\t done, \n\t\t\t info, \n\t\t\t extra) = next_scan_carry\n\n\t\t\tif ep_stats is not None:\n\t\t\t\t_ep_stats_update_fn = self._update_ep_stats \\\n\t\t\t\t\tif pop is self.student_pop else self._update_ued_ep_stats\n\n\t\t\t\tep_stats = _ep_stats_update_fn(ep_stats, done, info)\n\n\t\t\treturn (rollout, next_state, next_obs, next_carry, done, extra, ep_stats), None\n\n\t\t(rollout, state, obs, carry, done, extra, ep_stats), _ = jax.lax.scan(\n\t\t\t_scan_rollout,\n\t\t\t(rollout, state, obs, carry, done, extra, ep_stats),\n\t\t\trngs,\n\t\t\tlength=n_steps,\n\t\t\tunroll=self.n_unroll_rollout\n\t\t)\n\n\t\treturn rollout, state, obs, carry, extra, ep_stats\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef _compile_stats(self, \n\t\tupdate_stats, ep_stats, \n\t\tued_update_stats, ued_ep_stats,\n\t\tenv_metrics=None,\n\t\tgrad_stats=None, ued_grad_stats=None):\n\t\tmean_returns_by_student = jax.vmap(lambda x: x.mean())(ep_stats['return'])\n\t\tmean_returns_by_teacher = jax.vmap(lambda x: x.mean())(ued_ep_stats['return'])\n\n\t\tmean_ep_stats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(\n\t\t\t{k:ep_stats[k] for k in self.rolling_stats.names}\n\t\t)\n\t\tued_mean_ep_stats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(\n\t\t\t{k:ued_ep_stats[k] for k in self.ued_rolling_stats.names}\n\t\t)\n\n\t\tstudent_stats = {\n\t\t\tf'mean_{k}':v for k,v in mean_ep_stats.items()\n\t\t}\n\t\tstudent_stats.update(update_stats)\n\n\t\tstats = {}\n\t\tfor i in range(self.n_students):\n\t\t\t_student_stats = jax.tree_util.tree_map(lambda x: x[i], student_stats) # for agent0\n\t\t\tstats.update({f'{k}_a{i}':v for k,v in _student_stats.items()})\n\n\t\tteacher_stats = {\n\t\t\tf'mean_{k}_tch':v for k,v in ued_mean_ep_stats.items()\n\t\t}\n\t\tteacher_stats.update({\n\t\t\tf'{k}_tch':v[0] for k,v in ued_update_stats.items()\n\t\t})\n\t\tstats.update(teacher_stats)\n\n\t\tif self.track_env_metrics:\n\t\t\tpassable_mask = env_metrics.pop('passable')\n\t\t\tmean_env_metrics = jax.tree_util.tree_map(\n\t\t\t\tlambda x: (x*passable_mask).sum()/passable_mask.sum(), \n\t\t\t\tenv_metrics\n\t\t\t)\n\t\t\tmean_env_metrics.update({'passable_ratio': passable_mask.mean()})\n\t\t\tstats.update({\n\t\t\t\tf'env/{k}':v for k,v in mean_env_metrics.items()\n\t\t\t})\n\n\t\tif self.n_devices > 1:\n\t\t\tstats = jax.tree_map(lambda x: jax.lax.pmean(x, 'device'), stats)\n\n\t\treturn stats\n\n\tdef get_shmap_spec(self):\n\t\trunner_state_size = len(inspect.signature(self.run).parameters)\n\t\tin_spec = [P(None,'device'),]*(runner_state_size)\n\t\tout_spec = [P(None,'device'),]*(runner_state_size)\n\n\t\tin_spec[:2] = [P(None),]*2\n\t\tin_spec[6] = P(None)\n\t\tin_spec = tuple(in_spec)\n\t\tout_spec = (P(None),) + in_spec\n\n\t\treturn in_spec, out_spec\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef run(\n\t\tself, \n\t\trng, \n\t\ttrain_state, \n\t\tstate,\n\t\tobs,\n\t\tcarry,\n\t\tep_stats,\n\t\tued_train_state,\n\t\tued_state,\n\t\tued_obs,\n\t\tued_carry,\n\t\tued_ep_stats):\n\t\t\"\"\"\n\t\tPerform one update step: rollout teacher + students\n\t\t\"\"\"\n\t\tif self.n_devices > 1:\n\t\t\trng = jax.random.fold_in(rng, jax.lax.axis_index('device'))\n\n\t\t# === Reset teacher env + rollout teacher\n\t\trng, *vrngs = jax.random.split(rng, self.teacher_pop.n_agents+1)\n\t\tued_reset_out = self.benv.reset_teacher(jnp.array(vrngs))\n\t\tif len(ued_reset_out) > 2:\n\t\t\tued_obs, ued_state, ued_extra = ued_reset_out\n\t\telse:\n\t\t\tued_obs, ued_state = ued_reset_out\n\t\t\tued_extra = None\n\n\t\t# Reset UED ep_stats\n\t\tif self.ued_rolling_stats is not None:\n\t\t\tued_ep_stats = self.ued_rolling_stats.reset_stats(\n\t\t\t\tbatch_shape=(1,self.n_parallel))\n\t\telse:\n\t\t\tued_ep_stats = None\n\n\t\ttch_rollout_batch_shape = (1,self.n_parallel*self.n_eval)\n\t\tdone = jnp.zeros(tch_rollout_batch_shape, dtype=jnp.bool_)\n\t\trng, subrng = jax.random.split(rng)\n\t\tued_rollout, ued_state, ued_obs, ued_carry, _, ued_ep_stats = \\\n\t\t\tself._rollout(\n\t\t\t\tsubrng,\n\t\t\t\tself.teacher_pop,\n\t\t\t\tself.teacher_rollout,\n\t\t\t\tself.teacher_n_rollout_steps,\n\t\t\t\tjax.lax.stop_gradient(ued_train_state.params), \n\t\t\t\tued_state, \n\t\t\t\tued_obs, \n\t\t\t\tued_carry,\n\t\t\t\tdone, \n\t\t\t\textra=ued_extra, \n\t\t\t\tep_stats=ued_ep_stats\n\t\t\t)\n\n\t\t# === Reset student to new envs + rollout students\n\t\trng, *vrngs = jax.random.split(rng, self.teacher_pop.n_agents+1)\n\t\tobs, state, extra = jax.tree_util.tree_map(\n\t\t\tlambda x:x.squeeze(0), self.benv.reset_student(\n\t\t\t\tjnp.array(vrngs),\n\t\t\t\tued_state, \n\t\t\t\tself.student_pop.n_agents))\n\t\treset_state = state\n\n\t\t# Reset student ep_stats\n\t\tst_rollout_batch_shape = (self.n_students,self.n_parallel*self.n_eval)\n\t\tep_stats = self.rolling_stats.reset_stats(\n\t\t\tbatch_shape=st_rollout_batch_shape)\n\n\t\tdone = jnp.zeros(st_rollout_batch_shape, dtype=jnp.bool_)\n\t\trng, subrng = jax.random.split(rng)\n\t\trollout, state, obs, carry, extra, ep_stats = \\\n\t\t\tself._rollout(\n\t\t\t\tsubrng, \n\t\t\t\tself.student_pop,\n\t\t\t\tself.student_rollout,\n\t\t\t\tself.n_rollout_steps,\n\t\t\t\tjax.lax.stop_gradient(train_state.params),\n\t\t\t\tstate, \n\t\t\t\tobs, \n\t\t\t\tcarry, \n\t\t\t\tdone,\n\t\t\t\treset_state=reset_state, \n\t\t\t\textra=extra, \n\t\t\t\tep_stats=ep_stats)\n\n\t\t# === Update student with PPO\n\t\t# PPOAgent vmaps over the train state and batch. Batch must be N x EM\n\t\tstudent_rollout_last_value = self.student_pop.get_value(\n\t\t\tjax.lax.stop_gradient(train_state.params), obs, carry\n\t\t)\n\t\ttrain_batch = self.student_rollout.get_batch(\n\t\t\trollout, \n\t\t\tstudent_rollout_last_value\n\t\t)\n\n\t\trng, subrng = jax.random.split(rng)\n\t\ttrain_state, update_stats = self.student_pop.update(subrng, train_state, train_batch)\n\n\t\t# === Update teacher with PPO\n\t\t# - Compute returns per env per agent\n\t\t# - Compute batched returns based on returns per env per agent\n\t\tued_score, _ = compute_ued_scores(self.ued_score, train_batch, self.n_eval)\n\t\tued_rollout = self.teacher_rollout.set_final_reward(ued_rollout, ued_score)\n\t\tued_train_batch = self.teacher_rollout.get_batch(\n\t\t\tued_rollout, \n\t\t\tjnp.zeros((1, self.n_parallel)) # Last step terminates episode\n\t\t)\n\n\t\tued_ep_stats = self._update_ued_ep_stats(\n\t\t\tued_ep_stats, \n\t\t\tjnp.ones((1,len(ued_score),1), dtype=jnp.bool_),\n\t\t\t{'return': jnp.expand_dims(ued_score, (0,-1))}\n\t\t)\n\n\t\t# Update teacher, batch must be 1 x Ex1\n\t\trng, subrng = jax.random.split(rng)\n\t\tued_train_state, ued_update_stats = self.teacher_pop.update(subrng, ued_train_state, ued_train_batch)\n\n\t\t# --------------------------------------------------\n\t\t# Collect metrics\n\t\tif self.track_env_metrics:\n\t\t\tenv_metrics = self.benv.get_env_metrics(reset_state)\n\t\telse:\n\t\t\tenv_metrics = None\n\n\t\tgrad_stats, ued_grad_stats = None, None\n\n\t\tstats = self._compile_stats(\n\t\t\tupdate_stats, ep_stats, \n\t\t\tued_update_stats, ued_ep_stats,\n\t\t\tenv_metrics,\n\t\t\tgrad_stats, ued_grad_stats)\n\t\tstats.update(dict(n_updates=train_state.n_updates[0]))\n\n\t\ttrain_state = train_state.increment()\n\t\tued_train_state = ued_train_state.increment()\n\t\tself.n_updates += 1\n\n\t\treturn (\n\t\t\tstats, \n\t\t\trng,\n\t\t\ttrain_state, state, obs, carry, ep_stats,\n\t\t\tued_train_state, ued_state, ued_obs, ued_carry, ued_ep_stats\n\t\t)"},{"identifier":"PLRRunner","path":"src/minimax/runners/plr_runner.py","snippet":"class PLRRunner(DRRunner):\n\tdef __init__(\n\t\tself, \n\t\t*,\n\t\treplay_prob=0.5,\n\t\tbuffer_size=100,\n\t\tstaleness_coef=0.3,\n\t\tuse_score_ranks=True,\n\t\ttemp=1.0,\n\t\tmin_fill_ratio=0.5,\n\t\tuse_robust_plr=False,\n\t\tuse_parallel_eval=False,\n\t\tued_score='l1_value_loss',\n\t\tforce_unique=False, # Slower if True\n\t\tmutation_fn=None,\n\t\tn_mutations=0,\n\t\tmutation_criterion='batch',\n\t\tmutation_subsample_size=1,\n\t\t**kwargs):\n\t\tuse_mutations = mutation_fn is not None\n\t\tif use_parallel_eval:\n\t\t\treplay_prob = 1.0 # Replay every rollout cycle\n\t\t\tmutation_criterion = 'batch' # Force batch mutations (no UED scores)\n\t\t\tself._n_parallel_batches = 3 if use_mutations else 2\n\t\t\tkwargs['n_parallel'] *= self._n_parallel_batches\n\n\t\tsuper().__init__(**kwargs)\n\n\t\tself.replay_prob = replay_prob\n\t\tself.buffer_size = buffer_size\n\t\tself.staleness_coef = staleness_coef\n\t\tself.temp = temp\n\t\tself.use_score_ranks = use_score_ranks\n\t\tself.min_fill_ratio = min_fill_ratio\n\t\tself.use_robust_plr = use_robust_plr\n\t\tself.use_parallel_eval = use_parallel_eval\n\t\tself.ued_score = UEDScore[ued_score.upper()]\n\n\t\tself.use_mutations = use_mutations\n\t\tif self.use_mutations:\n\t\t\tself.mutation_fn = envs.get_mutator(self.benv.env_name, mutation_fn)\n\t\telse:\n\t\t\tself.mutation_fn = None\n\t\tself.n_mutations = n_mutations\n\t\tself.mutation_criterion = MutationCriterion[mutation_criterion.upper()]\n\t\tself.mutation_subsample_size = mutation_subsample_size\n\n\t\tself.force_unique = force_unique\n\t\tif force_unique:\n\t\t\tself.comparator_fn = envs.get_comparator(self.benv.env_name)\n\t\telse:\n\t\t\tself.comparator_fn = None\n\n\t\tif mutation_fn is not None and mutation_criterion != 'batch':\n\t\t\tassert self.n_parallel % self.mutation_subsample_size == 0, \\\n\t\t\t\t'Number of parallel envs must be divisible by mutation subsample size.'\n\n\tdef reset(self, rng):\n\t\trunner_state = list(super().reset(rng))\n\t\trng = runner_state[0]\n\t\trunner_state[0], subrng = jax.random.split(rng)\n\t\texample_state = self.benv.env.reset(rng)[1]\n\n\t\tself.plr_mgr = PopPLRManager(\n\t\t\tn_agents=self.n_students,\n\t\t\texample_level=example_state,\n\t\t\tued_score=self.ued_score,\n\t\t\treplay_prob=self.replay_prob,\n\t\t\tbuffer_size=self.buffer_size,\n\t\t\tstaleness_coef=self.staleness_coef,\n\t\t\ttemp=self.temp,\n\t\t\tuse_score_ranks=self.use_score_ranks,\n\t\t\tmin_fill_ratio=self.min_fill_ratio,\n\t\t\tuse_robust_plr=self.use_robust_plr,\n\t\t\tuse_parallel_eval=self.use_parallel_eval,\n\t\t\tcomparator_fn=self.comparator_fn,\n\t\t\tn_devices=self.n_devices\n\t\t)\n\t\tplr_buffer = self.plr_mgr.reset(self.n_students)\n\n\t\ttrain_state = runner_state[1]\n\t\ttrain_state = train_state.replace(plr_buffer=plr_buffer)\n\t\tif self.n_devices == 1:\n\t\t\trunner_state[1] = train_state\n\t\telse:\n\t\t\tplr_buffer = jax.tree_map(lambda x: x.repeat(self.n_devices, 1), plr_buffer) # replicate plr buffer\n\t\t\trunner_state += (plr_buffer,) # Return PLR buffer directly to make shmap easier\n\n\t\tself.dummy_eval_output = self._create_dummy_eval_output(train_state)\n\n\t\treturn tuple(runner_state)\n\n\tdef _create_dummy_eval_output(self, train_state):\n\t\trng, *vrngs = jax.random.split(jax.random.PRNGKey(0), self.n_students+1)\n\t\tobs, state, extra = self.benv.reset(jnp.array(vrngs))\n\n\t\tep_stats = self.rolling_stats.reset_stats(\n\t\t\tbatch_shape=(self.n_students, self.n_parallel*self.n_eval))\n\n\t\tued_scores = jnp.zeros((self.n_students, self.n_parallel))\n\n\t\tif self.student_pop.agent.is_recurrent:\n\t\t\tcarry = self.zero_carry\n\t\telse:\n\t\t\tcarry = None\n\t\trollout = self.student_rollout.reset()\n\n\t\ttrain_batch = self.student_rollout.get_batch(\n\t\t\trollout, \n\t\t\tself.student_pop.get_value(\n\t\t\t\tjax.lax.stop_gradient(train_state.params), \n\t\t\t\tobs, \n\t\t\t\tcarry,\n\t\t\t)\n\t\t)\n\n\t\treturn (\n\t\t\trng,\n\t\t\ttrain_state, \n\t\t\tstate, \n\t\t\tstate,\n\t\t\tobs, \n\t\t\tcarry, \n\t\t\textra, \n\t\t\tep_stats,\n\t\t\tstate,\n\t\t\ttrain_batch,\n\t\t\tued_scores\n\t\t)\n\n\t@partial(jax.jit, static_argnums=(0,8))\n\tdef _eval_and_update_plr(\n\t\t\tself,\n\t\t\trng,\n\t\t\tlevels,\n\t\t\tlevel_idxs, \n\t\t\ttrain_state, \n\t\t\tupdate_plr,\n\t\t\tparent_idxs=None,\n\t\t\tdupe_mask=None,\n\t\t\tfake=False):\n\t\t# Collect rollout and optionally update plr buffer\n\t\t# Returns train_batch and ued_scores\n\t\t# Perform rollout: @todo: pmap this\n\t\tif fake:\n\t\t\tdummy_eval_output = list(self.dummy_eval_output)\n\t\t\tdummy_eval_output[1] = train_state\n\t\t\treturn tuple(dummy_eval_output)\n\n\t\trollout_batch_shape = (self.n_students, self.n_parallel*self.n_eval)\n\t\tobs, state, extra = self.benv.set_state(levels)\n\t\tep_stats = self.rolling_stats.reset_stats(\n\t\t\tbatch_shape=rollout_batch_shape)\n\n\t\trollout_start_state = state\n\n\t\tdone = jnp.zeros(rollout_batch_shape, dtype=jnp.bool_)\n\t\tif self.student_pop.agent.is_recurrent:\n\t\t\tcarry = self.zero_carry\n\t\telse:\n\t\t\tcarry = None\n\n\t\trng, subrng = jax.random.split(rng)\n\t\tstart_state = state\n\t\trollout, state, start_state, obs, carry, extra, ep_stats, train_state = \\\n\t\t\tself._rollout_students(\n\t\t\t\tsubrng, \n\t\t\t\ttrain_state, \n\t\t\t\tstate, \n\t\t\t\tstart_state,\n\t\t\t\tobs, \n\t\t\t\tcarry, \n\t\t\t\tdone,\n\t\t\t\textra, \n\t\t\t\tep_stats\n\t\t\t)\n\n\t\ttrain_batch = self.student_rollout.get_batch(\n\t\t\trollout, \n\t\t\tself.student_pop.get_value(\n\t\t\t\tjax.lax.stop_gradient(train_state.params), \n\t\t\t\tobs, \n\t\t\t\tcarry\n\t\t\t)\n\t\t)\n\n\t\t# Update PLR buffer\n\t\tif self.ued_score == UEDScore.MAX_MC:\n\t\t\tmax_returns = jax.vmap(lambda x,y: x.at[y].get())(train_state.plr_buffer.max_returns, level_idxs)\n\t\t\tmax_returns = jnp.where(\n\t\t\t\tjnp.greater_equal(level_idxs, 0),\n\t\t\t\tmax_returns,\n\t\t\t\tjnp.full_like(max_returns, -jnp.inf)\n\t\t\t)\n\t\t\tued_info = {'max_returns': max_returns}\n\t\telse:\n\t\t\tued_info = None\n\t\tued_scores, ued_score_info = compute_ued_scores(\n\t\t\tself.ued_score, train_batch, self.n_eval, info=ued_info, ignore_val=-jnp.inf, per_agent=True)\n\t\tnext_plr_buffer = self.plr_mgr.update(\n\t\t\ttrain_state.plr_buffer, \n\t\t\tlevels=levels, \n\t\t\tlevel_idxs=level_idxs, \n\t\t\tued_scores=ued_scores,\n\t\t\tdupe_mask=dupe_mask, \n\t\t\tinfo=ued_score_info, \n\t\t\tignore_val=-jnp.inf,\n\t\t\tparent_idxs=parent_idxs)\n\n\t\tnext_plr_buffer = jax.vmap(\n\t\t\tlambda update, new, prev: jax.tree_map(\n\t\t\t\tlambda x, y: jax.lax.select(update, x, y), new, prev)\n\t\t)(update_plr, next_plr_buffer, train_state.plr_buffer)\n\n\t\ttrain_state = train_state.replace(plr_buffer=next_plr_buffer)\n\n\t\treturn (\n\t\t\trng,\n\t\t\ttrain_state, \n\t\t\tstate, \n\t\t\tstart_state, \n\t\t\tobs, \n\t\t\tcarry, \n\t\t\textra, \n\t\t\tep_stats,\n\t\t\trollout_start_state,\n\t\t\ttrain_batch,\n\t\t\tued_scores,\n\t\t)\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef _mutate_levels(self, rng, levels, level_idxs, ued_scores=None):\n\t\tif not self.use_mutations:\n\t\t\treturn levels, level_idxs, jnp.full_like(level_idxs, -1)\n\n\t\tdef upsample_levels(levels, level_idxs, subsample_idxs):\n\t\t\tsubsample_idxs = subsample_idxs.repeat(self.n_parallel//self.mutation_subsample_size, -1)\n\t\t\tparent_idxs = level_idxs.take(subsample_idxs)\n\t\t\tlevels = jax.vmap(\n\t\t\t\tlambda x, y: jax.tree_map(lambda _x: jnp.array(_x).take(y, 0), x)\n\t\t\t)(levels, parent_idxs)\n\t\t\t\n\t\t\treturn levels, parent_idxs\n\n\t\tif self.mutation_criterion == MutationCriterion.BATCH:\n\t\t\tparent_idxs = level_idxs\n\n\t\tif self.mutation_criterion == MutationCriterion.EASY:\n\t\t\t_, top_level_idxs = jax.lax.approx_min_k(ued_scores, self.mutation_subsample_size)\n\t\t\tlevels, parent_idxs = upsample_levels(levels, level_idxs, top_level_idxs)\n\n\t\telif self.mutation_criterion == MutationCriterion.HARD:\n\t\t\t_, top_level_idxs = jax.lax.approx_max_k(ued_scores, self.mutation_subsample_size)\n\t\t\tlevels, parent_idxs = upsample_levels(levels, level_idxs, top_level_idxs)\n\n\t\tn_parallel = level_idxs.shape[-1]\n\t\tvrngs = jax.vmap(lambda subrng: jax.random.split(subrng, n_parallel))(\n\t\t\tjax.random.split(rng, self.n_students)\n\t\t)\n\n\t\tmutated_levels = jax.vmap(\n\t\t\tlambda *args: jax.vmap(self.mutation_fn, in_axes=(0,None,0,None))(*args),\n\t\t\tin_axes=(0,None,0,None)\n\t\t)(vrngs, self.benv.env_params, levels, self.n_mutations)\n\n\t\t# Mutated levels do not have existing idxs in the PLR buffer.\n\t\tmutated_level_idxs = jnp.full((self.n_students, n_parallel), -1)\n\n\t\treturn mutated_levels, mutated_level_idxs, parent_idxs\n\n\tdef _efficient_grad_update(self, rng, train_state, train_batch, is_replay):\n\t\t# PPOAgent vmaps over the train state and batch. Batch must be N x EM\n\t\tskip_grad_update = jnp.logical_and(self.use_robust_plr, ~is_replay)\n\n\t\tif self.n_students == 1:\n\t\t\ttrain_state, stats = jax.lax.cond(\n\t\t\t\tskip_grad_update[0],\n\t\t\t\tpartial(self.student_pop.update, fake=True),\n\t\t\t\tself.student_pop.update,\n\t\t\t\t*(rng, train_state, train_batch)\n\t\t\t)\n\t\telif self.n_students > 1: # Have to vmap all students + take only students that need updates\n\t\t\t_, dummy_stats = jax.vmap(lambda *_: self.student_pop.agent.get_empty_update_stats())(np.arange(self.n_students))\n\t\t\t_train_state, stats = self.student.update(rng, train_state, train_batch)\n\t\t\ttrain_state, stats = jax.vmap(lambda cond,x,y: \\\n\t\t\t\t\tjax.tree_map(lambda _cond,_x,_y: jax.lax.select(_cond,_x,_y), cond, x, y))(\n\t\t\t\t\t\tis_replay, (train_state, stats), (_train_state, dummy_stats)\n\t\t\t\t\t)\n\n\t\treturn train_state, stats\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef _compile_stats(self, update_stats, ep_stats, env_metrics=None, plr_stats=None):\n\t\tstats = super()._compile_stats(update_stats, ep_stats, env_metrics)\n\n\t\tif plr_stats is not None:\n\t\t\tplr_stats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(plr_stats)\n\n\t\tif self.n_students > 1:\n\t\t\t_plr_stats = {}\n\t\t\tfor i in range(self.n_students):\n\t\t\t\t_student_plr_stats = jax.tree_util.tree_map(lambda x: x[i], plr_stats) # for agent0\n\t\t\t\t_plr_stats.update({f'{k}_a{i}':v for k,v in _student_plr_stats.items()})\n\t\t\tplr_stats = _plr_stats\n\t\telse:\n\t\t\tplr_stats = jax.tree_map(lambda x: x[0], plr_stats) \n\n\t\tstats.update({f'plr_{k}':v for k,v in plr_stats.items()})\n\n\t\tif self.n_devices > 1:\n\t\t\tstats = jax.tree_map(lambda x: jax.lax.pmean(x, 'device'), stats)\n\n\t\treturn stats\n\n\t@partial(jax.jit, static_argnums=(0,))\n\tdef run(\n\t\tself, \n\t\trng, \n\t\ttrain_state, \n\t\tstate, \n\t\tstart_state,\n\t\tobs, \n\t\tcarry=None, \n\t\textra=None, \n\t\tep_stats=None,\n\t\tplr_buffer=None):\n\t\t# If device sharded, load sharded PLR buffer into train state\n\t\tif self.n_devices > 1:\n\t\t\trng = jax.random.fold_in(rng, jax.lax.axis_index('device'))\n\t\t\ttrain_state = train_state.replace(plr_buffer=plr_buffer)\n\n\t\t# Sample next training levels via PLR\n\t\trng, *vrngs = jax.random.split(rng, self.n_students+1)\n\t\tobs, state, extra = self.benv.reset(jnp.array(vrngs), self.n_parallel, 1)\n\n\t\tif self.use_parallel_eval:\n\t\t\tn_level_samples = self.n_parallel//self._n_parallel_batches\n\t\t\tnew_levels = jax.tree_map(lambda x: x.at[:,n_level_samples:2*n_level_samples].get(), state)\n\t\telse:\n\t\t\tn_level_samples = self.n_parallel\n\t\t\tnew_levels = state\n\n\t\trng, subrng = jax.random.split(rng)\n\t\tlevels, level_idxs, is_replay, next_plr_buffer = \\\n\t\t\tself.plr_mgr.sample(subrng, train_state.plr_buffer, new_levels, n_level_samples)\n\t\ttrain_state = train_state.replace(plr_buffer=next_plr_buffer)\n\n\t\t# If use_parallel_eval=True, need to combine replay and non-replay levels together\n\t\t# Need to mutate levels as well\n\t\tparent_idxs = jnp.full((self.n_students, self.n_parallel), -1)\n\t\tif self.use_parallel_eval: # Parallel ACCEL\n\t\t\tnew_level_idxs = jnp.full_like(parent_idxs, -1)\n\n\t\t\t_all_levels = jax.vmap(\n\t\t\t\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=n_level_samples, src_len=n_level_samples),\n\t\t\t\t)(state, levels)\n\t\t\t_all_level_idxs = jax.vmap(\n\t\t\t\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=n_level_samples, src_len=n_level_samples),\n\t\t\t\t)(new_level_idxs, level_idxs)\n\n\t\t\tif self.use_mutations:\n\t\t\t\trng, subrng = jax.random.split(rng)\n\t\t\t\tmutated_levels, mutated_level_idxs, _parent_idxs = self._mutate_levels(subrng, levels, level_idxs)\n\t\t\t\t\n\t\t\t\tfallback_levels = jax.tree_map(lambda x: x.at[:,-n_level_samples:].get(), state)\n\t\t\t\tfallback_level_idxs = jnp.full_like(mutated_level_idxs, -1)\n\n\t\t\t\tmutated_levels = jax.vmap(\n\t\t\t\t\tlambda cond,x,y: jax.tree_map(\n\t\t\t\t\t\tlambda _x,_y: jax.lax.select(cond,_x,_y), x, y\n\t\t\t\t\t))(is_replay, mutated_levels, fallback_levels)\n\n\t\t\t\tmutated_level_idxs = jax.vmap(\n\t\t\t\t\tlambda cond,x,y: jax.tree_map(\n\t\t\t\t\t\tlambda _x,_y: jax.lax.select(cond,_x,_y), x, y\n\t\t\t\t\t))(is_replay, mutated_level_idxs, fallback_level_idxs)\n\n\t\t\t\t_parent_idxs = jax.vmap(\n\t\t\t\t\tlambda cond,x,y: jax.tree_map(\n\t\t\t\t\t\tlambda _x,_y: jax.lax.select(cond,_x,_y), x, y\n\t\t\t\t\t))(is_replay, _parent_idxs, fallback_level_idxs)\n\t\t\n\t\t\t\tmutated_levels_start_idx = 2*n_level_samples\n\t\t\t\t_all_levels = jax.vmap(\n\t\t\t\t\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=mutated_levels_start_idx, src_len=n_level_samples),\n\t\t\t\t\t)(_all_levels, mutated_levels)\n\t\t\t\t_all_level_idxs = jax.vmap(\n\t\t\t\t\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=mutated_levels_start_idx, src_len=n_level_samples),\n\t\t\t\t\t)(_all_level_idxs, mutated_level_idxs)\n\t\t\t\tparent_idxs = jax.vmap(\n\t\t\t\t\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=mutated_levels_start_idx, src_len=n_level_samples),\n\t\t\t\t\t)(parent_idxs, _parent_idxs)\n\n\t\t\tlevels = _all_levels\n\t\t\tlevel_idxs = _all_level_idxs\n\n\t\t# dedupe levels, move into PLR buffer logic\n\t\tif self.force_unique:\n\t\t\tlevel_idxs, dupe_mask = self.plr_mgr.dedupe_levels(next_plr_buffer, levels, level_idxs)\n\t\telse:\n\t\t\tdupe_mask = None \n\n\t\t# Evaluate levels + update PLR\n\t\tresult = self._eval_and_update_plr(\n\t\t\trng, levels, level_idxs, train_state, update_plr=jnp.array([True]*self.n_students), parent_idxs=parent_idxs, dupe_mask=dupe_mask)\n\t\trng, train_state, state, start_state, obs, carry, extra, ep_stats, \\\n\t\t\trollout_start_state, train_batch, ued_scores = result\n\n\t\tif self.use_parallel_eval:\n\t\t\treplay_start_idx = self.n_eval*n_level_samples\n\t\t\treplay_end_idx = 2*replay_start_idx\n\t\t\ttrain_batch = jax.vmap(\n\t\t\t\tlambda x: jax.tree_map(\n\t\t\t\t\tlambda _x: _x.at[:,replay_start_idx:replay_end_idx].get(), x)\n\t\t\t\t)(train_batch)\n\n\t\t# Gradient update\n\t\trng, subrng = jax.random.split(rng)\n\t\ttrain_state, update_stats = self._efficient_grad_update(subrng, train_state, train_batch, is_replay)\n\n\t\t# Mutation step\n\t\tuse_mutations = jnp.logical_and(self.use_mutations, is_replay)\n\t\tuse_mutations = jnp.logical_and(use_mutations, not self.use_parallel_eval) # Already mutated above in parallel\n\t\trng, arng, brng = jax.random.split(rng, 3)\n\n\t\tmutated_levels, mutated_level_idxs, parent_idxs = jax.lax.cond(\n\t\t\tuse_mutations.any(),\n\t\t\tself._mutate_levels,\n\t\t\tlambda *_: (levels, level_idxs, jnp.full_like(level_idxs, -1)),\n\t\t\t*(arng, levels, level_idxs, ued_scores)\n\t\t)\n\n\t\tmutated_dupe_mask = jnp.zeros_like(mutated_level_idxs, dtype=jnp.bool_)\n\t\tif self.force_unique: # Should move into update plr logic\n\t\t\tmutated_level_idxs, mutated_dupe_mask = jax.lax.cond(\n\t\t\t\tuse_mutations.any(),\n\t\t\t\tself.plr_mgr.dedupe_levels,\n\t\t\t\tlambda *_: (mutated_level_idxs, mutated_dupe_mask),\n\t\t\t\t*(next_plr_buffer, mutated_levels, mutated_level_idxs)\n\t\t\t)\n\n\t\tmutation_eval_result = jax.lax.cond(\n\t\t\tuse_mutations.any(),\n\t\t\tself._eval_and_update_plr,\n\t\t\tpartial(self._eval_and_update_plr, fake=True),\n\t\t\t*(brng, mutated_levels, mutated_level_idxs, train_state, use_mutations, parent_idxs, mutated_dupe_mask)\n\t\t)\n\t\ttrain_state = mutation_eval_result[1]\n\n\t\t# Collect training env metrics\n\t\tif self.track_env_metrics:\n\t\t\tenv_metrics = self.benv.get_env_metrics(levels)\n\t\telse:\n\t\t\tenv_metrics = None\n\n\t\tplr_stats = self.plr_mgr.get_metrics(train_state.plr_buffer)\n\n\t\tstats = self._compile_stats(update_stats, ep_stats, env_metrics, plr_stats)\n\n\t\tif self.n_devices > 1:\n\t\t\tplr_buffer = train_state.plr_buffer\n\t\t\ttrain_state = train_state.replace(plr_buffer=None)\n\n\t\ttrain_state = train_state.increment()\n\t\tstats.update(dict(n_updates=train_state.n_updates[0]))\n\n\t\treturn (\n\t\t\tstats, \n\t\t\trng, \n\t\t\ttrain_state, \n\t\t\tstate, \n\t\t\tstart_state, \n\t\t\tobs, \n\t\t\tcarry, \n\t\t\textra, \n\t\t\tep_stats,\n\t\t\tplr_buffer\n\t\t)"}],"string":"[\n {\n \"identifier\": \"EvalRunner\",\n \"path\": \"src/minimax/runners/eval_runner.py\",\n \"snippet\": \"class EvalRunner:\\n def __init__(\\n self,\\n pop,\\n env_names,\\n env_kwargs=None,\\n n_episodes=10,\\n agent_idxs='*',\\n render_mode=None):\\n\\n self.pop = pop\\n\\n if isinstance(agent_idxs, str):\\n if \\\"*\\\" in agent_idxs:\\n self.agent_idxs = np.arange(pop.n_agents)\\n else:\\n self.agent_idxs = \\\\\\n np.array([int(x) for x in agent_idxs.split(',')])\\n else:\\n self.agent_idxs = agent_idxs # assume array\\n\\n assert np.max(self.agent_idxs) < pop.n_agents, \\\\\\n 'Agent index is out of bounds.'\\n\\n if isinstance(env_names, str):\\n env_names = [\\n x.strip() for x in env_names.split(',')\\n ]\\n\\n self.n_episodes = n_episodes\\n env_infos = create_envs_for_kwargs(env_names, env_kwargs)\\n env_names = []\\n self.ext_env_names = []\\n env_kwargs = []\\n for (name, ext_name, kwargs) in env_infos:\\n env_names.append(name)\\n self.ext_env_names.append(ext_name)\\n env_kwargs.append(kwargs)\\n self.n_envs = len(env_names)\\n\\n self.benvs = []\\n self.env_params = []\\n self.env_has_solved_rate = []\\n for env_name, kwargs in zip(env_names, env_kwargs):\\n benv = envs.BatchEnv(\\n env_name=env_name,\\n n_parallel=n_episodes,\\n n_eval=1,\\n env_kwargs=kwargs,\\n wrappers=['monitor_return', 'monitor_ep_metrics']\\n )\\n self.benvs.append(benv)\\n self.env_params.append(benv.env.params)\\n self.env_has_solved_rate.append(benv.env.eval_solved_rate is not None)\\n\\n self.action_dtype = self.benvs[0].env.action_space().dtype\\n\\n monitored_metrics = self.benvs[0].env.get_monitored_metrics()\\n self.rolling_stats = RollingStats(names=monitored_metrics, window=1)\\n self._update_ep_stats = jax.vmap(\\n jax.vmap(\\n self.rolling_stats.update_stats, in_axes=(0,0,0,None)),\\n in_axes=(0,0,0,None))\\n\\n self.test_return_pre = 'test_return'\\n self.test_solved_rate_pre = 'test_solved_rate'\\n\\n self.render_mode = render_mode\\n if render_mode:\\n from minimax.envs.viz.grid_viz import GridVisualizer\\n self.viz = GridVisualizer()\\n self.viz.show()\\n\\n if render_mode == 'ipython':\\n from IPython import display\\n self.ipython_display = display\\n\\n def load_checkpoint_state(self, runner_state, state):\\n runner_state = list(runner_state)\\n runner_state[1] = runner_state[1].load_state_dict(state[1])\\n\\n return tuple(runner_state)\\n\\n @partial(jax.jit, static_argnums=(0,2))\\n def _get_transition(\\n self,\\n rng,\\n benv,\\n params,\\n state,\\n obs,\\n carry,\\n zero_carry,\\n extra):\\n value, pi_params, next_carry = self.pop.act(params, obs, carry)\\n pi = self.pop.get_action_dist(pi_params, dtype=self.action_dtype)\\n rng, subrng = jax.random.split(rng)\\n action = pi.sample(seed=subrng)\\n log_pi = pi.log_prob(action)\\n\\n rng, *vrngs = jax.random.split(rng, self.pop.n_agents+1)\\n\\n step_args = (jnp.array(vrngs), state, action, extra)\\n (next_obs, \\n next_state, \\n reward, \\n done, \\n info, \\n extra) = benv.step(*step_args)\\n\\n # Add transition to storage\\n step = (obs, action, reward, done, log_pi, value)\\n if carry is not None:\\n step += (carry,)\\n\\n # Zero carry if needed\\n if carry is not None:\\n next_carry = jax.vmap(_tree_util.pytree_select)(\\n done, zero_carry, next_carry)\\n\\n if self.render_mode:\\n self.viz.render(\\n benv.env.params, \\n jax.tree_util.tree_map(lambda x: x[0][0], state))\\n if self.render_mode == 'ipython':\\n self.ipython_display.display(self.viz.window.fig)\\n self.ipython_display.clear_output(wait=True)\\n\\n return next_state, next_obs, next_carry, done, info, extra\\n\\n @partial(jax.jit, static_argnums=(0, 2))\\n def _rollout_benv(\\n self, \\n rng, \\n benv,\\n params,\\n env_params,\\n state,\\n obs,\\n carry,\\n zero_carry,\\n extra,\\n ep_stats):\\n\\n def _scan_rollout(scan_carry, rng):\\n (state, \\n obs, \\n carry,\\n extra, \\n ep_stats) = scan_carry\\n \\n step = \\\\\\n self._get_transition(\\n rng,\\n benv,\\n params, \\n state, \\n obs, \\n carry, \\n zero_carry,\\n extra)\\n\\n (next_state, \\n next_obs, \\n next_carry, \\n done, \\n info, \\n extra) = step\\n\\n ep_stats = self._update_ep_stats(ep_stats, done, info, 1)\\n\\n return (next_state, next_obs, next_carry, extra, ep_stats), None\\n\\n n_steps = benv.env.max_episode_steps()\\n rngs = jax.random.split(rng, n_steps)\\n (state, \\n obs, \\n carry, \\n extra,\\n ep_stats),_ = jax.lax.scan(\\n _scan_rollout,\\n (state, obs, carry, extra, ep_stats),\\n rngs,\\n length=n_steps)\\n\\n return ep_stats\\n\\n @partial(jax.jit, static_argnums=(0,))\\n def run(self, rng, params):\\n \\\"\\\"\\\"\\n Rollout agents on each env. \\n\\n For each env, run n_eval episodes in parallel, \\n where each is indexed to return in order.\\n \\\"\\\"\\\"\\n eval_stats = self.fake_run(rng, params)\\n rng, *rollout_rngs = jax.random.split(rng, self.n_envs+1)\\n for i, (benv, env_param) in enumerate(zip(self.benvs, self.env_params)):\\n rng, *reset_rngs = jax.random.split(rng, self.pop.n_agents+1)\\n obs, state, extra = benv.reset(jnp.array(reset_rngs))\\n\\n if self.pop.agent.is_recurrent:\\n rng, subrng = jax.random.split(rng)\\n zero_carry = self.pop.init_carry(subrng, obs)\\n else:\\n zero_carry = None\\n\\n # Reset episodic stats\\n ep_stats = self.rolling_stats.reset_stats(\\n batch_shape=(self.pop.n_agents, self.n_episodes))\\n\\n ep_stats = self._rollout_benv(\\n rollout_rngs[i],\\n benv,\\n jax.lax.stop_gradient(params), \\n env_param, \\n state, \\n obs,\\n zero_carry,\\n zero_carry,\\n extra,\\n ep_stats)\\n \\n env_name = self.ext_env_names[i]\\n mean_return = ep_stats['return'].mean(1)\\n\\n if self.env_has_solved_rate[i]:\\n mean_solved_rate = jax.vmap(jax.vmap(benv.env.eval_solved_rate))(ep_stats).mean(1)\\n\\n for idx in self.agent_idxs:\\n eval_stats[f'eval/a{idx}:{self.test_return_pre}:{env_name}'] = mean_return[idx].squeeze()\\n if self.env_has_solved_rate[i]:\\n eval_stats[f'eval/a{idx}:{self.test_solved_rate_pre}:{env_name}'] = mean_solved_rate[idx].squeeze()\\n\\n return eval_stats\\n\\n def fake_run(self, rng, params):\\n eval_stats = {}\\n for i, env_name in enumerate(self.ext_env_names):\\n for idx in self.agent_idxs:\\n eval_stats.update({\\n f'eval/a{idx}:{self.test_return_pre}:{env_name}':0.\\n })\\n if self.env_has_solved_rate[i]:\\n eval_stats.update({\\n f'eval/a{idx}:{self.test_solved_rate_pre}:{env_name}':0.,\\n })\\n\\n return eval_stats\"\n },\n {\n \"identifier\": \"DRRunner\",\n \"path\": \"src/minimax/runners/dr_runner.py\",\n \"snippet\": \"class DRRunner:\\n\\t\\\"\\\"\\\"\\n\\tOrchestrates rollouts across one or more students. \\n\\tThe main components at play:\\n\\t- AgentPop: Manages train state and batched inference logic \\n\\t\\tfor a population of agents.\\n\\t- BatchEnv: Manages environment step and reset logic, using a \\n\\t\\tpopulaton of agents.\\n\\t- RolloutStorage: Manages the storing and sampling of collected txns.\\n\\t- PPO: Handles PPO updates, which take a train state + batch of txns.\\n\\t\\\"\\\"\\\"\\n\\tdef __init__(\\n\\t\\tself, \\n\\t\\tenv_name,\\n\\t\\tenv_kwargs,\\n\\t\\tstudent_agents,\\n\\t\\tn_students=1,\\n\\t\\tn_parallel=1,\\n\\t\\tn_eval=1,\\n\\t\\tn_rollout_steps=256,\\n\\t\\tlr=1e-4,\\n\\t\\tlr_final=None,\\n\\t\\tlr_anneal_steps=0,\\n\\t\\tmax_grad_norm=0.5,\\n\\t\\tdiscount=0.99,\\n\\t\\tgae_lambda=0.95,\\n\\t\\tadam_eps=1e-5,\\n\\t\\tnormalize_return=False,\\n\\t\\ttrack_env_metrics=False,\\n\\t\\tn_unroll_rollout=1,\\n\\t\\tn_devices=1,\\n\\t\\trender=False):\\n\\n\\t\\tassert len(student_agents) == 1, 'Only one type of student supported.'\\n\\t\\tassert n_parallel % n_devices == 0, 'Num envs must be divisible by num devices.'\\n\\n\\t\\tself.n_students = n_students\\n\\t\\tself.n_parallel = n_parallel // n_devices\\n\\t\\tself.n_eval = n_eval\\n\\t\\tself.n_devices = n_devices\\n\\t\\tself.step_batch_size = n_students*n_eval*n_parallel\\n\\t\\tself.n_rollout_steps = n_rollout_steps\\n\\t\\tself.n_updates = 0\\n\\t\\tself.lr = lr\\n\\t\\tself.lr_final = lr if lr_final is None else lr_final\\n\\t\\tself.lr_anneal_steps = lr_anneal_steps\\n\\t\\tself.max_grad_norm = max_grad_norm\\n\\t\\tself.adam_eps = adam_eps\\n\\t\\tself.normalize_return = normalize_return\\n\\t\\tself.track_env_metrics = track_env_metrics\\n\\t\\tself.n_unroll_rollout = n_unroll_rollout\\n\\t\\tself.render = render\\n\\n\\t\\tself.student_pop = AgentPop(student_agents[0], n_agents=n_students)\\n\\n\\t\\tself.env, self.env_params = envs.make(\\n\\t\\t\\tenv_name, \\n\\t\\t\\tenv_kwargs=env_kwargs\\n\\t\\t)\\n\\t\\tself._action_shape = self.env.action_space().shape\\n\\n\\t\\tself.benv = envs.BatchEnv(\\n\\t\\t\\tenv_name=env_name,\\n\\t\\t\\tn_parallel=self.n_parallel,\\n\\t\\t\\tn_eval=self.n_eval,\\n\\t\\t\\tenv_kwargs=env_kwargs,\\n\\t\\t\\twrappers=['monitor_return', 'monitor_ep_metrics']\\n\\t\\t)\\n\\t\\tself.action_dtype = self.benv.env.action_space().dtype\\n\\n\\t\\tself.student_rollout = RolloutStorage(\\n\\t\\t\\tdiscount=discount,\\n\\t\\t\\tgae_lambda=gae_lambda,\\n\\t\\t\\tn_steps=n_rollout_steps,\\n\\t\\t\\tn_agents=n_students,\\n\\t\\t\\tn_envs=self.n_parallel,\\n\\t\\t\\tn_eval=self.n_eval,\\n\\t\\t\\taction_space=self.env.action_space(),\\n\\t\\t\\tobs_space=self.env.observation_space(),\\n\\t\\t\\tagent=self.student_pop.agent,\\n\\t\\t)\\n\\n\\t\\tmonitored_metrics = self.benv.env.get_monitored_metrics()\\n\\t\\tself.rolling_stats = RollingStats(\\n\\t\\t\\tnames=monitored_metrics,\\n\\t\\t\\twindow=10,\\n\\t\\t)\\n\\t\\tself._update_ep_stats = jax.vmap(jax.vmap(self.rolling_stats.update_stats))\\n\\n\\t\\tif self.render:\\n\\t\\t\\tfrom envs.viz.grid_viz import GridVisualizer\\n\\t\\t\\tself.viz = GridVisualizer()\\n\\t\\t\\tself.viz.show()\\n\\n\\tdef reset(self, rng):\\n\\t\\tself.n_updates = 0\\n\\n\\t\\tn_parallel = self.n_parallel*self.n_devices\\n\\n\\t\\trngs, *vrngs = jax.random.split(rng, self.n_students+1)\\n\\t\\tobs, state, extra = self.benv.reset(jnp.array(vrngs), n_parallel=n_parallel)\\n\\t\\tdummy_obs = jax.tree_util.tree_map(lambda x: x[0], obs) # for one agent only\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tif self.student_pop.agent.is_recurrent:\\n\\t\\t\\tcarry = self.student_pop.init_carry(subrng, obs)\\n\\t\\t\\tself.zero_carry = jax.tree_map(lambda x: x.at[:,:self.n_parallel].get(), carry)\\n\\t\\telse:\\n\\t\\t\\tcarry = None\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tparams = self.student_pop.init_params(subrng, dummy_obs)\\n\\n\\t\\tschedule_fn = optax.linear_schedule(\\n\\t\\t\\tinit_value=-float(self.lr),\\n\\t\\t\\tend_value=-float(self.lr_final),\\n\\t\\t\\ttransition_steps=self.lr_anneal_steps,\\n\\t\\t)\\n\\n\\t\\ttx = optax.chain(\\n\\t\\t\\toptax.clip_by_global_norm(self.max_grad_norm),\\n\\t\\t\\toptax.adam(learning_rate=float(self.lr), eps=self.adam_eps)\\n\\t\\t)\\n\\n\\t\\ttrain_state = VmapTrainState.create(\\n\\t\\t\\tapply_fn=self.student_pop.agent.evaluate,\\n\\t\\t\\tparams=params,\\n\\t\\t\\ttx=tx\\n\\t\\t)\\n\\n\\t\\tep_stats = self.rolling_stats.reset_stats(\\n\\t\\t\\tbatch_shape=(self.n_students, n_parallel*self.n_eval))\\n\\n\\t\\tstart_state = state\\n\\n\\t\\treturn (\\n\\t\\t\\trng, \\n\\t\\t\\ttrain_state, \\n\\t\\t\\tstate,\\n\\t\\t\\tstart_state, # Used to track metrics from starting state\\n\\t\\t\\tobs, \\n\\t\\t\\tcarry, \\n\\t\\t\\textra, \\n\\t\\t\\tep_stats\\n\\t\\t)\\n\\n\\tdef get_checkpoint_state(self, state):\\n\\t\\t_state = list(state)\\n\\t\\t_state[1] = state[1].state_dict\\n\\n\\t\\treturn _state\\n\\n\\tdef load_checkpoint_state(self, runner_state, state):\\n\\t\\trunner_state = list(runner_state)\\n\\t\\trunner_state[1] = runner_state[1].load_state_dict(state[1])\\n\\n\\t\\treturn tuple(runner_state)\\n\\n\\t@partial(jax.jit, static_argnums=(0,2))\\n\\tdef _get_transition(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\tpop, \\n\\t\\tparams, \\n\\t\\trollout, \\n\\t\\tstate, \\n\\t\\tstart_state, \\n\\t\\tobs, \\n\\t\\tcarry, \\n\\t\\tdone,\\n\\t\\textra=None):\\n\\t\\t# Sample action\\n\\t\\tvalue, pi_params, next_carry = pop.act(params, obs, carry, done)\\n\\n\\t\\tpi = pop.get_action_dist(pi_params, dtype=self.action_dtype)\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\taction = pi.sample(seed=subrng)\\n\\t\\tlog_pi = pi.log_prob(action)\\n\\n\\t\\trng, *vrngs = jax.random.split(rng, self.n_students+1)\\n\\t\\t(next_obs, \\n\\t\\t next_state, \\n\\t\\t reward, \\n\\t\\t done, \\n\\t\\t info, \\n\\t\\t extra) = self.benv.step(jnp.array(vrngs), state, action, extra)\\n\\n\\t\\tnext_start_state = jax.vmap(_tree_util.pytree_select)(\\n\\t\\t\\tdone, next_state, start_state\\n\\t\\t)\\n\\n\\t\\t# Add transition to storage\\n\\t\\tstep = (obs, action, reward, done, log_pi, value)\\n\\t\\tif carry is not None:\\n\\t\\t\\tstep += (carry,)\\n\\n\\t\\trollout = self.student_rollout.append(rollout, *step)\\n\\n\\t\\tif self.render:\\n\\t\\t\\tself.viz.render(\\n\\t\\t\\t\\tself.benv.env.params, \\n\\t\\t\\t\\tjax.tree_util.tree_map(lambda x: x[0][0], state))\\n\\n\\t\\treturn (\\n\\t\\t\\trollout, \\n\\t\\t\\tnext_state,\\n\\t\\t\\tnext_start_state, \\n\\t\\t\\tnext_obs, \\n\\t\\t\\tnext_carry, \\n\\t\\t\\tdone, \\n\\t\\t\\tinfo, \\n\\t\\t\\textra\\n\\t\\t)\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef _rollout_students(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\ttrain_state, \\n\\t\\tstate, \\n\\t\\tstart_state, \\n\\t\\tobs, \\n\\t\\tcarry, \\n\\t\\tdone,\\n\\t\\textra=None, \\n\\t\\tep_stats=None):\\n\\t\\trollout = self.student_rollout.reset()\\n\\n\\t\\trngs = jax.random.split(rng, self.n_rollout_steps)\\n\\n\\t\\tdef _scan_rollout(scan_carry, rng):\\n\\t\\t\\trollout, state, start_state, obs, carry, done, extra, ep_stats, train_state = scan_carry \\n\\n\\t\\t\\tnext_scan_carry = \\\\\\n\\t\\t\\t\\tself._get_transition(\\n\\t\\t\\t\\t\\trng, \\n\\t\\t\\t\\t\\tself.student_pop, \\n\\t\\t\\t\\t\\tjax.lax.stop_gradient(train_state.params), \\n\\t\\t\\t\\t\\trollout, \\n\\t\\t\\t\\t\\tstate,\\n\\t\\t\\t\\t\\tstart_state, \\n\\t\\t\\t\\t\\tobs, \\n\\t\\t\\t\\t\\tcarry,\\n\\t\\t\\t\\t\\tdone, \\n\\t\\t\\t\\t\\textra)\\n\\t\\t\\t(rollout, \\n\\t\\t\\t next_state,\\n\\t\\t\\t next_start_state, \\n\\t\\t\\t next_obs, \\n\\t\\t\\t next_carry, \\n\\t\\t\\t done, \\n\\t\\t\\t info, \\n\\t\\t\\t extra) = next_scan_carry\\n\\n\\t\\t\\tep_stats = self._update_ep_stats(ep_stats, done, info)\\n\\n\\t\\t\\treturn (\\n\\t\\t\\t\\trollout, \\n\\t\\t\\t\\tnext_state,\\n\\t\\t\\t\\tnext_start_state,\\n\\t\\t\\t\\tnext_obs, \\n\\t\\t\\t\\tnext_carry,\\n\\t\\t\\t\\tdone,\\n\\t\\t\\t\\textra, \\n\\t\\t\\t\\tep_stats,\\n\\t\\t\\t\\ttrain_state), None\\n\\n\\t\\t(rollout, \\n\\t\\t state, \\n\\t\\t start_state, \\n\\t\\t obs, \\n\\t\\t carry, \\n\\t\\t done,\\n\\t\\t extra, \\n\\t\\t ep_stats,\\n\\t\\t train_state), _ = jax.lax.scan(\\n\\t\\t\\t_scan_rollout,\\n\\t\\t\\t(rollout, \\n\\t\\t\\t state, \\n\\t\\t\\t start_state,\\n\\t\\t\\t obs, \\n\\t\\t\\t carry, \\n\\t\\t\\t done,\\n\\t\\t\\t extra, \\n\\t\\t\\t ep_stats,\\n\\t\\t\\t train_state),\\n\\t\\t\\trngs,\\n\\t\\t\\tlength=self.n_rollout_steps,\\n\\t\\t)\\n\\n\\t\\treturn rollout, state, start_state, obs, carry, extra, ep_stats, train_state\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef _compile_stats(self, update_stats, ep_stats, env_metrics=None):\\n\\t\\tstats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(\\n\\t\\t\\t{k:ep_stats[k] for k in self.rolling_stats.names}\\n\\t\\t)\\n\\t\\tstats.update(update_stats)\\n\\n\\t\\tif self.n_students > 1:\\n\\t\\t\\t_stats = {}\\n\\t\\t\\tfor i in range(self.n_students):\\n\\t\\t\\t\\t_student_stats = jax.tree_util.tree_map(lambda x: x[i], stats) # for agent0\\n\\t\\t\\t\\t_stats.update({f'a{i}/{k}':v for k,v in _student_stats.items()})\\n\\t\\t\\tstats = _stats\\n\\n\\t\\tif self.track_env_metrics:\\n\\t\\t\\tmean_env_metrics = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(env_metrics)\\n\\t\\t\\tmean_env_metrics = {f'env/{k}':v for k,v in mean_env_metrics.items()}\\n\\n\\t\\t\\tif self.n_students > 1:\\n\\t\\t\\t\\t_env_metrics = {}\\n\\t\\t\\t\\tfor i in range(self.n_students):\\n\\t\\t\\t\\t\\t_student_env_metrics = jax.tree_util.tree_map(lambda x: x[i], mean_env_metrics) # for agent0\\n\\t\\t\\t\\t\\t_env_metrics.update({f'{k}_a{i}':v for k,v in _student_env_metrics.items()})\\n\\t\\t\\t\\tmean_env_metrics = _env_metrics\\n\\n\\t\\t\\tstats.update(mean_env_metrics)\\n\\n\\t\\tif self.n_students == 1:\\n\\t\\t\\tstats = jax.tree_map(lambda x: x[0], stats)\\n\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\tstats = jax.tree_map(lambda x: jax.lax.pmean(x, 'device'), stats)\\n\\n\\t\\treturn stats\\n\\n\\tdef get_shmap_spec(self):\\n\\t\\trunner_state_size = len(inspect.signature(self.run).parameters)\\n\\t\\tin_spec = [P(None,'device'),]*(runner_state_size)\\n\\t\\tout_spec = [P(None,'device'),]*(runner_state_size)\\n\\n\\t\\tin_spec[:2] = [P(None),]*2\\n\\t\\tin_spec = tuple(in_spec)\\n\\t\\tout_spec = (P(None),) + in_spec\\n\\n\\t\\treturn in_spec, out_spec\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef run(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\ttrain_state, \\n\\t\\tstate, \\n\\t\\tstart_state,\\n\\t\\tobs, \\n\\t\\tcarry=None, \\n\\t\\textra=None, \\n\\t\\tep_stats=None):\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tPerform one update step: rollout all students and teachers + update with PPO\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\trng = jax.random.fold_in(rng, jax.lax.axis_index('device'))\\n\\n\\t\\trng, *vrngs = jax.random.split(rng, self.n_students+1)\\n\\t\\trollout_batch_shape = (self.n_students, self.n_parallel*self.n_eval)\\n\\n\\t\\tobs, state, extra = self.benv.reset(jnp.array(vrngs))\\n\\t\\tep_stats = self.rolling_stats.reset_stats(\\n\\t\\t\\tbatch_shape=rollout_batch_shape)\\n\\n\\t\\trollout_start_state = state\\n\\n\\t\\tdone = jnp.zeros(rollout_batch_shape, dtype=jnp.bool_)\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\trollout, state, start_state, obs, carry, extra, ep_stats, train_state = \\\\\\n\\t\\t\\tself._rollout_students(\\n\\t\\t\\t\\tsubrng, \\n\\t\\t\\t\\ttrain_state, \\n\\t\\t\\t\\tstate, \\n\\t\\t\\t\\tstart_state,\\n\\t\\t\\t\\tobs, \\n\\t\\t\\t\\tcarry, \\n\\t\\t\\t\\tdone,\\n\\t\\t\\t\\textra, \\n\\t\\t\\t\\tep_stats\\n\\t\\t\\t)\\n\\n\\t\\ttrain_batch = self.student_rollout.get_batch(\\n\\t\\t\\trollout, \\n\\t\\t\\tself.student_pop.get_value(\\n\\t\\t\\t\\tjax.lax.stop_gradient(train_state.params), \\n\\t\\t\\t\\tobs, \\n\\t\\t\\t\\tcarry,\\n\\t\\t\\t)\\n\\t\\t)\\n\\n\\t\\t# PPOAgent vmaps over the train state and batch. Batch must be N x EM\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\ttrain_state, update_stats = self.student_pop.update(subrng, train_state, train_batch)\\n\\n\\t\\t# Collect env metrics\\n\\t\\tif self.track_env_metrics:\\n\\t\\t\\tenv_metrics = self.benv.get_env_metrics(rollout_start_state)\\n\\t\\telse:\\n\\t\\t\\tenv_metrics = None\\n\\n\\t\\tstats = self._compile_stats(update_stats, ep_stats, env_metrics)\\n\\t\\tstats.update(dict(n_updates=train_state.n_updates[0]))\\n\\n\\t\\ttrain_state = train_state.increment()\\n\\t\\tself.n_updates += 1\\n\\n\\t\\treturn (\\n\\t\\t\\tstats, \\n\\t\\t\\trng, \\n\\t\\t\\ttrain_state, \\n\\t\\t\\tstate, \\n\\t\\t\\tstart_state, \\n\\t\\t\\tobs, \\n\\t\\t\\tcarry, \\n\\t\\t\\textra, \\n\\t\\t\\tep_stats\\n\\t\\t)\"\n },\n {\n \"identifier\": \"PAIREDRunner\",\n \"path\": \"src/minimax/runners/paired_runner.py\",\n \"snippet\": \"class PAIREDRunner:\\n\\t\\\"\\\"\\\"\\n\\tOrchestrates rollouts across one or more students and teachers. \\n\\tThe main components at play:\\n\\t- AgentPop: Manages train state and batched inference logic \\n\\t\\tfor a population of agents.\\n\\t- BatchUEDEnv: Manages environment step and reset logic for a \\n\\t\\tpopulation of agents batched over a pair of student and \\n\\t\\tteacher MDPs.\\n\\t- RolloutStorage: Manages the storing and sampling of collected txns.\\n\\t- PPO: Handles PPO updates, which take a train state + batch of txns.\\n\\t\\\"\\\"\\\"\\n\\tdef __init__(\\n\\t\\tself, \\n\\t\\tenv_name,\\n\\t\\tenv_kwargs,\\n\\t\\tued_env_kwargs,\\n\\t\\tstudent_agents,\\n\\t\\tn_students=2,\\n\\t\\tn_parallel=1,\\n\\t\\tn_eval=1,\\n\\t\\tn_rollout_steps=250,\\n\\t\\tlr=1e-4,\\n\\t\\tlr_final=None,\\n\\t\\tlr_anneal_steps=0,\\n\\t\\tmax_grad_norm=0.5,\\n\\t\\tdiscount=0.99,\\n\\t\\tgae_lambda=0.95,\\n\\t\\tadam_eps=1e-5,\\n\\t\\tteacher_lr=None,\\n\\t\\tteacher_lr_final=None,\\n\\t\\tteacher_lr_anneal_steps=None,\\n\\t\\tteacher_discount=0.99,\\n\\t\\tteacher_gae_lambda=0.95,\\n\\t\\tteacher_agents=None,\\n\\t\\tued_score='relative_regret',\\n\\t\\ttrack_env_metrics=False,\\n\\t\\tn_unroll_rollout=1,\\n\\t\\trender=False,\\n\\t\\tn_devices=1):\\n\\t\\tassert n_parallel % n_devices == 0, 'Num envs must be divisible by num devices.'\\n\\n\\t\\tued_score = UEDScore[ued_score.upper()]\\n\\n\\t\\tassert len(student_agents) == 1, \\\\\\n\\t\\t\\t'Only one type of student supported.'\\n\\t\\tassert not (n_students > 2 and ued_score in [UEDScore.RELATIVE_REGRET, UEDScore.MEAN_RELATIVE_REGRET]), \\\\\\n\\t\\t\\t'Standard PAIRED uses only 2 students.'\\n\\t\\tassert teacher_agents is None or len(teacher_agents) == 1, \\\\\\n\\t\\t\\t'Only one type of teacher supported.'\\n\\n\\t\\tself.n_students = n_students\\n\\t\\tself.n_parallel = n_parallel // n_devices\\n\\t\\tself.n_eval = n_eval\\n\\t\\tself.n_devices = n_devices\\n\\t\\tself.step_batch_size = n_students*n_eval*n_parallel\\n\\t\\tself.n_rollout_steps = n_rollout_steps\\n\\t\\tself.n_updates = 0\\n\\t\\tself.lr = lr\\n\\t\\tself.lr_final = lr if lr_final is None else lr_final\\n\\t\\tself.lr_anneal_steps = lr_anneal_steps\\n\\t\\tself.teacher_lr = \\\\\\n\\t\\t\\tlr if teacher_lr is None else lr\\n\\t\\tself.teacher_lr_final = \\\\\\n\\t\\t\\tself.lr_final if teacher_lr_final is None else teacher_lr_final\\n\\t\\tself.teacher_lr_anneal_steps = \\\\\\n\\t\\t\\tlr_anneal_steps if teacher_lr_anneal_steps is None else teacher_lr_anneal_steps\\n\\t\\tself.max_grad_norm = max_grad_norm\\n\\t\\tself.adam_eps = adam_eps\\n\\t\\tself.ued_score = ued_score\\n\\t\\tself.track_env_metrics = track_env_metrics\\n\\n\\t\\tself.n_unroll_rollout = n_unroll_rollout\\n\\t\\tself.render = render\\n\\n\\t\\tself.student_pop = AgentPop(student_agents[0], n_agents=n_students)\\n\\n\\t\\tif teacher_agents is not None:\\n\\t\\t\\tself.teacher_pop = AgentPop(teacher_agents[0], n_agents=1)\\n\\n\\t\\t# This ensures correct partial-episodic bootstrapping by avoiding\\n\\t\\t# any termination purely due to timeouts.\\n\\t\\t# env_kwargs.max_episode_steps = self.n_rollout_steps + 1\\n\\t\\tself.benv = envs.BatchUEDEnv(\\n\\t\\t\\tenv_name=env_name,\\n\\t\\t\\tn_parallel=self.n_parallel,\\n\\t\\t\\tn_eval=n_eval,\\n\\t\\t\\tenv_kwargs=env_kwargs,\\n\\t\\t\\tued_env_kwargs=ued_env_kwargs,\\n\\t\\t\\twrappers=['monitor_return', 'monitor_ep_metrics'],\\n\\t\\t\\tued_wrappers=[]\\n\\t\\t)\\n\\t\\tself.teacher_n_rollout_steps = \\\\\\n\\t\\t\\tself.benv.env.ued_max_episode_steps()\\n\\n\\t\\tself.student_rollout = RolloutStorage(\\n\\t\\t\\tdiscount=discount,\\n\\t\\t\\tgae_lambda=gae_lambda,\\n\\t\\t\\tn_steps=n_rollout_steps,\\n\\t\\t\\tn_agents=n_students,\\n\\t\\t\\tn_envs=self.n_parallel,\\n\\t\\t\\tn_eval=self.n_eval,\\n\\t\\t\\taction_space=self.benv.env.action_space(),\\n\\t\\t\\tobs_space=self.benv.env.observation_space(),\\n\\t\\t\\tagent=self.student_pop.agent\\n\\t\\t)\\n\\n\\t\\tself.teacher_rollout = RolloutStorage(\\n\\t\\t\\tdiscount=teacher_discount,\\n\\t\\t\\tgae_lambda=teacher_gae_lambda,\\n\\t\\t\\tn_steps=self.teacher_n_rollout_steps,\\n\\t\\t\\tn_agents=1,\\n\\t\\t\\tn_envs=self.n_parallel,\\n\\t\\t\\tn_eval=1,\\n\\t\\t\\taction_space=self.benv.env.ued_action_space(),\\n\\t\\t\\tobs_space=self.benv.env.ued_observation_space(),\\n\\t\\t\\tagent=self.teacher_pop.agent,\\n\\t\\t)\\n\\n\\t\\tued_monitored_metrics = ('return',)\\n\\t\\tself.ued_rolling_stats = RollingStats(\\t\\n\\t\\t\\tnames=ued_monitored_metrics,\\n\\t\\t\\twindow=10,\\n\\t\\t)\\n\\t\\t\\n\\t\\tmonitored_metrics = self.benv.env.get_monitored_metrics()\\n\\t\\tself.rolling_stats = RollingStats(\\n\\t\\t\\tnames=monitored_metrics,\\n\\t\\t\\twindow=10,\\n\\t\\t)\\n\\n\\t\\tself._update_ep_stats = jax.vmap(jax.vmap(self.rolling_stats.update_stats))\\n\\t\\tself._update_ued_ep_stats = jax.vmap(jax.vmap(self.ued_rolling_stats.update_stats))\\n\\n\\t\\tif self.render:\\n\\t\\t\\tfrom envs.viz.grid_viz import GridVisualizer\\n\\t\\t\\tself.viz = GridVisualizer()\\n\\t\\t\\tself.viz.show()\\n\\n\\tdef reset(self, rng):\\n\\t\\tself.n_updates = 0\\n\\n\\t\\tn_parallel = self.n_parallel*self.n_devices\\n\\n\\t\\trng, student_rng, teacher_rng = jax.random.split(rng,3)\\n\\t\\tstudent_info = self._reset_pop(\\n\\t\\t\\t\\tstudent_rng, \\n\\t\\t\\t\\tself.student_pop, \\n\\t\\t\\t\\tpartial(self.benv.reset, sub_batch_size=n_parallel*self.n_eval),\\n\\t\\t\\t\\tn_parallel_ep=n_parallel*self.n_eval,\\n\\t\\t\\t\\tlr_init=self.lr,\\n\\t\\t\\t\\tlr_final=self.lr_final,\\n\\t\\t\\t\\tlr_anneal_steps=self.lr_anneal_steps)\\n\\n\\t\\tteacher_info = self._reset_pop(\\n\\t\\t\\tteacher_rng, \\n\\t\\t\\tself.teacher_pop, \\n\\t\\t\\tpartial(self.benv.reset_teacher, n_parallel=n_parallel),\\n\\t\\t\\tn_parallel_ep=n_parallel,\\n\\t\\t\\tlr_init=self.teacher_lr,\\n\\t\\t\\tlr_final=self.teacher_lr_final,\\n\\t\\t\\tlr_anneal_steps=self.teacher_lr_anneal_steps)\\n\\n\\t\\treturn (\\n\\t\\t\\trng,\\n\\t\\t\\t*student_info,\\n\\t\\t\\t*teacher_info\\n\\t\\t)\\n\\n\\tdef _reset_pop(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\tpop, \\n\\t\\tenv_reset_fn, \\n\\t\\tn_parallel_ep=1,\\n\\t\\tlr_init=3e-4,\\n\\t\\tlr_final=3e-4,\\n\\t\\tlr_anneal_steps=0):\\n\\t\\trng, *vrngs = jax.random.split(rng, pop.n_agents+1)\\n\\t\\treset_out = env_reset_fn(jnp.array(vrngs))\\n\\t\\tif len(reset_out) == 2:\\n\\t\\t\\tobs, state = reset_out\\n\\t\\telse:\\n\\t\\t\\tobs, state, extra = reset_out\\n\\t\\tdummy_obs = jax.tree_util.tree_map(lambda x: x[0], obs) # for one agent only\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tif pop.agent.is_recurrent:\\n\\t\\t\\tcarry = pop.init_carry(subrng, obs)\\n\\t\\telse:\\n\\t\\t\\tcarry = None\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tparams = pop.init_params(subrng, dummy_obs)\\n\\n\\t\\tschedule_fn = optax.linear_schedule(\\n\\t\\t\\tinit_value=-float(lr_init),\\n\\t\\t\\tend_value=-float(lr_final),\\n\\t\\t\\ttransition_steps=lr_anneal_steps,\\n\\t\\t)\\n\\n\\t\\ttx = optax.chain(\\n\\t\\t\\toptax.clip_by_global_norm(self.max_grad_norm),\\n\\t\\t\\toptax.scale_by_adam(eps=self.adam_eps),\\n\\t\\t\\toptax.scale_by_schedule(schedule_fn),\\n\\t\\t)\\n\\n\\t\\ttrain_state = VmapTrainState.create(\\n\\t\\t\\tapply_fn=pop.agent.evaluate,\\n\\t\\t\\tparams=params,\\n\\t\\t\\ttx=tx\\n\\t\\t)\\n\\t\\t\\n\\t\\tep_stats = self.rolling_stats.reset_stats(\\n\\t\\t\\tbatch_shape=(pop.n_agents,n_parallel_ep))\\n\\n\\t\\treturn train_state, state, obs, carry, ep_stats\\n\\n\\tdef get_checkpoint_state(self, state):\\n\\t\\t_state = list(state)\\n\\t\\t_state[1] = state[1].state_dict\\n\\t\\t_state[6] = state[6].state_dict\\n\\n\\t\\treturn _state\\n\\n\\tdef load_checkpoint_state(self, runner_state, state):\\n\\t\\trunner_state = list(runner_state)\\n\\t\\trunner_state[1] = runner_state[1].load_state_dict(state[1])\\n\\t\\trunner_state[6] = runner_state[6].load_state_dict(state[6])\\n\\n\\t\\treturn tuple(runner_state)\\n\\n\\t@partial(jax.jit, static_argnums=(0,2,3))\\n\\tdef _get_transition(\\n\\t\\tself,\\n\\t\\trng, \\n\\t\\tpop, \\n\\t\\trollout_mgr, \\n\\t\\trollout, \\n\\t\\tparams, \\n\\t\\tstate, \\n\\t\\tobs, \\n\\t\\tcarry, \\n\\t\\tdone,\\n\\t\\treset_state=None,\\n\\t\\textra=None):\\n\\t\\t# Sample action\\n\\t\\tvalue, pi_params, next_carry = pop.act(params, obs, carry, done)\\n\\t\\tpi = pop.get_action_dist(pi_params)\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\taction = pi.sample(seed=subrng)\\n\\t\\tlog_pi = pi.log_prob(action)\\n\\n\\t\\trng, *vrngs = jax.random.split(rng, pop.n_agents+1)\\n\\n\\t\\tif pop is self.student_pop:\\n\\t\\t\\tstep_fn = self.benv.step_student\\n\\t\\telse:\\n\\t\\t\\tstep_fn = self.benv.step_teacher\\n\\t\\tstep_args = (jnp.array(vrngs), state, action)\\n\\n\\t\\tif reset_state is not None: # Needed for student to reset to same instance\\n\\t\\t\\tstep_args += (reset_state,)\\n\\n\\t\\tif extra is not None:\\n\\t\\t\\tstep_args += (extra,)\\n\\t\\t\\tnext_obs, next_state, reward, done, info, extra = step_fn(*step_args)\\n\\t\\telse:\\n\\t\\t\\tnext_obs, next_state, reward, done, info = step_fn(*step_args)\\n\\n\\t\\t# Add transition to storage\\n\\t\\tstep = (obs, action, reward, done, log_pi, value)\\n\\t\\tif carry is not None:\\n\\t\\t\\tstep += (carry,)\\n\\n\\t\\trollout = rollout_mgr.append(rollout, *step)\\n\\n\\t\\tif self.render and pop is self.student_pop:\\n\\t\\t\\tself.viz.render(\\n\\t\\t\\t\\tself.benv.env.env.params, \\n\\t\\t\\t\\tjax.tree_util.tree_map(lambda x: x[0][0], state))\\n\\n\\t\\treturn rollout, next_state, next_obs, next_carry, done, info, extra\\n\\n\\t@partial(jax.jit, static_argnums=(0,2,3,4))\\n\\tdef _rollout(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\tpop, \\n\\t\\trollout_mgr,\\n\\t\\tn_steps,\\n\\t\\tparams, \\n\\t\\tstate, \\n\\t\\tobs, \\n\\t\\tcarry, \\n\\t\\tdone,\\n\\t\\treset_state=None, \\n\\t\\textra=None, \\n\\t\\tep_stats=None):\\n\\t\\trngs = jax.random.split(rng, n_steps)\\n\\n\\t\\trollout = rollout_mgr.reset()\\n\\n\\t\\tdef _scan_rollout(scan_carry, rng):\\n\\t\\t\\t(rollout, \\n\\t\\t\\t state, \\n\\t\\t\\t obs, \\n\\t\\t\\t carry,\\n\\t\\t\\t done, \\n\\t\\t\\t extra, \\n\\t\\t\\t ep_stats) = scan_carry\\n\\t\\t\\t\\n\\t\\t\\tnext_scan_carry = \\\\\\n\\t\\t\\t\\tself._get_transition(\\n\\t\\t\\t\\t\\trng,\\n\\t\\t\\t\\t\\tpop, \\n\\t\\t\\t\\t\\trollout_mgr,\\n\\t\\t\\t\\t\\trollout,\\n\\t\\t\\t\\t\\tparams, \\n\\t\\t\\t\\t\\tstate, \\n\\t\\t\\t\\t\\tobs, \\n\\t\\t\\t\\t\\tcarry, \\n\\t\\t\\t\\t\\tdone,\\n\\t\\t\\t\\t\\treset_state, \\n\\t\\t\\t\\t\\textra)\\n\\n\\t\\t\\t(rollout, \\n\\t\\t\\t next_state, \\n\\t\\t\\t next_obs, \\n\\t\\t\\t next_carry, \\n\\t\\t\\t done, \\n\\t\\t\\t info, \\n\\t\\t\\t extra) = next_scan_carry\\n\\n\\t\\t\\tif ep_stats is not None:\\n\\t\\t\\t\\t_ep_stats_update_fn = self._update_ep_stats \\\\\\n\\t\\t\\t\\t\\tif pop is self.student_pop else self._update_ued_ep_stats\\n\\n\\t\\t\\t\\tep_stats = _ep_stats_update_fn(ep_stats, done, info)\\n\\n\\t\\t\\treturn (rollout, next_state, next_obs, next_carry, done, extra, ep_stats), None\\n\\n\\t\\t(rollout, state, obs, carry, done, extra, ep_stats), _ = jax.lax.scan(\\n\\t\\t\\t_scan_rollout,\\n\\t\\t\\t(rollout, state, obs, carry, done, extra, ep_stats),\\n\\t\\t\\trngs,\\n\\t\\t\\tlength=n_steps,\\n\\t\\t\\tunroll=self.n_unroll_rollout\\n\\t\\t)\\n\\n\\t\\treturn rollout, state, obs, carry, extra, ep_stats\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef _compile_stats(self, \\n\\t\\tupdate_stats, ep_stats, \\n\\t\\tued_update_stats, ued_ep_stats,\\n\\t\\tenv_metrics=None,\\n\\t\\tgrad_stats=None, ued_grad_stats=None):\\n\\t\\tmean_returns_by_student = jax.vmap(lambda x: x.mean())(ep_stats['return'])\\n\\t\\tmean_returns_by_teacher = jax.vmap(lambda x: x.mean())(ued_ep_stats['return'])\\n\\n\\t\\tmean_ep_stats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(\\n\\t\\t\\t{k:ep_stats[k] for k in self.rolling_stats.names}\\n\\t\\t)\\n\\t\\tued_mean_ep_stats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(\\n\\t\\t\\t{k:ued_ep_stats[k] for k in self.ued_rolling_stats.names}\\n\\t\\t)\\n\\n\\t\\tstudent_stats = {\\n\\t\\t\\tf'mean_{k}':v for k,v in mean_ep_stats.items()\\n\\t\\t}\\n\\t\\tstudent_stats.update(update_stats)\\n\\n\\t\\tstats = {}\\n\\t\\tfor i in range(self.n_students):\\n\\t\\t\\t_student_stats = jax.tree_util.tree_map(lambda x: x[i], student_stats) # for agent0\\n\\t\\t\\tstats.update({f'{k}_a{i}':v for k,v in _student_stats.items()})\\n\\n\\t\\tteacher_stats = {\\n\\t\\t\\tf'mean_{k}_tch':v for k,v in ued_mean_ep_stats.items()\\n\\t\\t}\\n\\t\\tteacher_stats.update({\\n\\t\\t\\tf'{k}_tch':v[0] for k,v in ued_update_stats.items()\\n\\t\\t})\\n\\t\\tstats.update(teacher_stats)\\n\\n\\t\\tif self.track_env_metrics:\\n\\t\\t\\tpassable_mask = env_metrics.pop('passable')\\n\\t\\t\\tmean_env_metrics = jax.tree_util.tree_map(\\n\\t\\t\\t\\tlambda x: (x*passable_mask).sum()/passable_mask.sum(), \\n\\t\\t\\t\\tenv_metrics\\n\\t\\t\\t)\\n\\t\\t\\tmean_env_metrics.update({'passable_ratio': passable_mask.mean()})\\n\\t\\t\\tstats.update({\\n\\t\\t\\t\\tf'env/{k}':v for k,v in mean_env_metrics.items()\\n\\t\\t\\t})\\n\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\tstats = jax.tree_map(lambda x: jax.lax.pmean(x, 'device'), stats)\\n\\n\\t\\treturn stats\\n\\n\\tdef get_shmap_spec(self):\\n\\t\\trunner_state_size = len(inspect.signature(self.run).parameters)\\n\\t\\tin_spec = [P(None,'device'),]*(runner_state_size)\\n\\t\\tout_spec = [P(None,'device'),]*(runner_state_size)\\n\\n\\t\\tin_spec[:2] = [P(None),]*2\\n\\t\\tin_spec[6] = P(None)\\n\\t\\tin_spec = tuple(in_spec)\\n\\t\\tout_spec = (P(None),) + in_spec\\n\\n\\t\\treturn in_spec, out_spec\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef run(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\ttrain_state, \\n\\t\\tstate,\\n\\t\\tobs,\\n\\t\\tcarry,\\n\\t\\tep_stats,\\n\\t\\tued_train_state,\\n\\t\\tued_state,\\n\\t\\tued_obs,\\n\\t\\tued_carry,\\n\\t\\tued_ep_stats):\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tPerform one update step: rollout teacher + students\\n\\t\\t\\\"\\\"\\\"\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\trng = jax.random.fold_in(rng, jax.lax.axis_index('device'))\\n\\n\\t\\t# === Reset teacher env + rollout teacher\\n\\t\\trng, *vrngs = jax.random.split(rng, self.teacher_pop.n_agents+1)\\n\\t\\tued_reset_out = self.benv.reset_teacher(jnp.array(vrngs))\\n\\t\\tif len(ued_reset_out) > 2:\\n\\t\\t\\tued_obs, ued_state, ued_extra = ued_reset_out\\n\\t\\telse:\\n\\t\\t\\tued_obs, ued_state = ued_reset_out\\n\\t\\t\\tued_extra = None\\n\\n\\t\\t# Reset UED ep_stats\\n\\t\\tif self.ued_rolling_stats is not None:\\n\\t\\t\\tued_ep_stats = self.ued_rolling_stats.reset_stats(\\n\\t\\t\\t\\tbatch_shape=(1,self.n_parallel))\\n\\t\\telse:\\n\\t\\t\\tued_ep_stats = None\\n\\n\\t\\ttch_rollout_batch_shape = (1,self.n_parallel*self.n_eval)\\n\\t\\tdone = jnp.zeros(tch_rollout_batch_shape, dtype=jnp.bool_)\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tued_rollout, ued_state, ued_obs, ued_carry, _, ued_ep_stats = \\\\\\n\\t\\t\\tself._rollout(\\n\\t\\t\\t\\tsubrng,\\n\\t\\t\\t\\tself.teacher_pop,\\n\\t\\t\\t\\tself.teacher_rollout,\\n\\t\\t\\t\\tself.teacher_n_rollout_steps,\\n\\t\\t\\t\\tjax.lax.stop_gradient(ued_train_state.params), \\n\\t\\t\\t\\tued_state, \\n\\t\\t\\t\\tued_obs, \\n\\t\\t\\t\\tued_carry,\\n\\t\\t\\t\\tdone, \\n\\t\\t\\t\\textra=ued_extra, \\n\\t\\t\\t\\tep_stats=ued_ep_stats\\n\\t\\t\\t)\\n\\n\\t\\t# === Reset student to new envs + rollout students\\n\\t\\trng, *vrngs = jax.random.split(rng, self.teacher_pop.n_agents+1)\\n\\t\\tobs, state, extra = jax.tree_util.tree_map(\\n\\t\\t\\tlambda x:x.squeeze(0), self.benv.reset_student(\\n\\t\\t\\t\\tjnp.array(vrngs),\\n\\t\\t\\t\\tued_state, \\n\\t\\t\\t\\tself.student_pop.n_agents))\\n\\t\\treset_state = state\\n\\n\\t\\t# Reset student ep_stats\\n\\t\\tst_rollout_batch_shape = (self.n_students,self.n_parallel*self.n_eval)\\n\\t\\tep_stats = self.rolling_stats.reset_stats(\\n\\t\\t\\tbatch_shape=st_rollout_batch_shape)\\n\\n\\t\\tdone = jnp.zeros(st_rollout_batch_shape, dtype=jnp.bool_)\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\trollout, state, obs, carry, extra, ep_stats = \\\\\\n\\t\\t\\tself._rollout(\\n\\t\\t\\t\\tsubrng, \\n\\t\\t\\t\\tself.student_pop,\\n\\t\\t\\t\\tself.student_rollout,\\n\\t\\t\\t\\tself.n_rollout_steps,\\n\\t\\t\\t\\tjax.lax.stop_gradient(train_state.params),\\n\\t\\t\\t\\tstate, \\n\\t\\t\\t\\tobs, \\n\\t\\t\\t\\tcarry, \\n\\t\\t\\t\\tdone,\\n\\t\\t\\t\\treset_state=reset_state, \\n\\t\\t\\t\\textra=extra, \\n\\t\\t\\t\\tep_stats=ep_stats)\\n\\n\\t\\t# === Update student with PPO\\n\\t\\t# PPOAgent vmaps over the train state and batch. Batch must be N x EM\\n\\t\\tstudent_rollout_last_value = self.student_pop.get_value(\\n\\t\\t\\tjax.lax.stop_gradient(train_state.params), obs, carry\\n\\t\\t)\\n\\t\\ttrain_batch = self.student_rollout.get_batch(\\n\\t\\t\\trollout, \\n\\t\\t\\tstudent_rollout_last_value\\n\\t\\t)\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\ttrain_state, update_stats = self.student_pop.update(subrng, train_state, train_batch)\\n\\n\\t\\t# === Update teacher with PPO\\n\\t\\t# - Compute returns per env per agent\\n\\t\\t# - Compute batched returns based on returns per env per agent\\n\\t\\tued_score, _ = compute_ued_scores(self.ued_score, train_batch, self.n_eval)\\n\\t\\tued_rollout = self.teacher_rollout.set_final_reward(ued_rollout, ued_score)\\n\\t\\tued_train_batch = self.teacher_rollout.get_batch(\\n\\t\\t\\tued_rollout, \\n\\t\\t\\tjnp.zeros((1, self.n_parallel)) # Last step terminates episode\\n\\t\\t)\\n\\n\\t\\tued_ep_stats = self._update_ued_ep_stats(\\n\\t\\t\\tued_ep_stats, \\n\\t\\t\\tjnp.ones((1,len(ued_score),1), dtype=jnp.bool_),\\n\\t\\t\\t{'return': jnp.expand_dims(ued_score, (0,-1))}\\n\\t\\t)\\n\\n\\t\\t# Update teacher, batch must be 1 x Ex1\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tued_train_state, ued_update_stats = self.teacher_pop.update(subrng, ued_train_state, ued_train_batch)\\n\\n\\t\\t# --------------------------------------------------\\n\\t\\t# Collect metrics\\n\\t\\tif self.track_env_metrics:\\n\\t\\t\\tenv_metrics = self.benv.get_env_metrics(reset_state)\\n\\t\\telse:\\n\\t\\t\\tenv_metrics = None\\n\\n\\t\\tgrad_stats, ued_grad_stats = None, None\\n\\n\\t\\tstats = self._compile_stats(\\n\\t\\t\\tupdate_stats, ep_stats, \\n\\t\\t\\tued_update_stats, ued_ep_stats,\\n\\t\\t\\tenv_metrics,\\n\\t\\t\\tgrad_stats, ued_grad_stats)\\n\\t\\tstats.update(dict(n_updates=train_state.n_updates[0]))\\n\\n\\t\\ttrain_state = train_state.increment()\\n\\t\\tued_train_state = ued_train_state.increment()\\n\\t\\tself.n_updates += 1\\n\\n\\t\\treturn (\\n\\t\\t\\tstats, \\n\\t\\t\\trng,\\n\\t\\t\\ttrain_state, state, obs, carry, ep_stats,\\n\\t\\t\\tued_train_state, ued_state, ued_obs, ued_carry, ued_ep_stats\\n\\t\\t)\"\n },\n {\n \"identifier\": \"PLRRunner\",\n \"path\": \"src/minimax/runners/plr_runner.py\",\n \"snippet\": \"class PLRRunner(DRRunner):\\n\\tdef __init__(\\n\\t\\tself, \\n\\t\\t*,\\n\\t\\treplay_prob=0.5,\\n\\t\\tbuffer_size=100,\\n\\t\\tstaleness_coef=0.3,\\n\\t\\tuse_score_ranks=True,\\n\\t\\ttemp=1.0,\\n\\t\\tmin_fill_ratio=0.5,\\n\\t\\tuse_robust_plr=False,\\n\\t\\tuse_parallel_eval=False,\\n\\t\\tued_score='l1_value_loss',\\n\\t\\tforce_unique=False, # Slower if True\\n\\t\\tmutation_fn=None,\\n\\t\\tn_mutations=0,\\n\\t\\tmutation_criterion='batch',\\n\\t\\tmutation_subsample_size=1,\\n\\t\\t**kwargs):\\n\\t\\tuse_mutations = mutation_fn is not None\\n\\t\\tif use_parallel_eval:\\n\\t\\t\\treplay_prob = 1.0 # Replay every rollout cycle\\n\\t\\t\\tmutation_criterion = 'batch' # Force batch mutations (no UED scores)\\n\\t\\t\\tself._n_parallel_batches = 3 if use_mutations else 2\\n\\t\\t\\tkwargs['n_parallel'] *= self._n_parallel_batches\\n\\n\\t\\tsuper().__init__(**kwargs)\\n\\n\\t\\tself.replay_prob = replay_prob\\n\\t\\tself.buffer_size = buffer_size\\n\\t\\tself.staleness_coef = staleness_coef\\n\\t\\tself.temp = temp\\n\\t\\tself.use_score_ranks = use_score_ranks\\n\\t\\tself.min_fill_ratio = min_fill_ratio\\n\\t\\tself.use_robust_plr = use_robust_plr\\n\\t\\tself.use_parallel_eval = use_parallel_eval\\n\\t\\tself.ued_score = UEDScore[ued_score.upper()]\\n\\n\\t\\tself.use_mutations = use_mutations\\n\\t\\tif self.use_mutations:\\n\\t\\t\\tself.mutation_fn = envs.get_mutator(self.benv.env_name, mutation_fn)\\n\\t\\telse:\\n\\t\\t\\tself.mutation_fn = None\\n\\t\\tself.n_mutations = n_mutations\\n\\t\\tself.mutation_criterion = MutationCriterion[mutation_criterion.upper()]\\n\\t\\tself.mutation_subsample_size = mutation_subsample_size\\n\\n\\t\\tself.force_unique = force_unique\\n\\t\\tif force_unique:\\n\\t\\t\\tself.comparator_fn = envs.get_comparator(self.benv.env_name)\\n\\t\\telse:\\n\\t\\t\\tself.comparator_fn = None\\n\\n\\t\\tif mutation_fn is not None and mutation_criterion != 'batch':\\n\\t\\t\\tassert self.n_parallel % self.mutation_subsample_size == 0, \\\\\\n\\t\\t\\t\\t'Number of parallel envs must be divisible by mutation subsample size.'\\n\\n\\tdef reset(self, rng):\\n\\t\\trunner_state = list(super().reset(rng))\\n\\t\\trng = runner_state[0]\\n\\t\\trunner_state[0], subrng = jax.random.split(rng)\\n\\t\\texample_state = self.benv.env.reset(rng)[1]\\n\\n\\t\\tself.plr_mgr = PopPLRManager(\\n\\t\\t\\tn_agents=self.n_students,\\n\\t\\t\\texample_level=example_state,\\n\\t\\t\\tued_score=self.ued_score,\\n\\t\\t\\treplay_prob=self.replay_prob,\\n\\t\\t\\tbuffer_size=self.buffer_size,\\n\\t\\t\\tstaleness_coef=self.staleness_coef,\\n\\t\\t\\ttemp=self.temp,\\n\\t\\t\\tuse_score_ranks=self.use_score_ranks,\\n\\t\\t\\tmin_fill_ratio=self.min_fill_ratio,\\n\\t\\t\\tuse_robust_plr=self.use_robust_plr,\\n\\t\\t\\tuse_parallel_eval=self.use_parallel_eval,\\n\\t\\t\\tcomparator_fn=self.comparator_fn,\\n\\t\\t\\tn_devices=self.n_devices\\n\\t\\t)\\n\\t\\tplr_buffer = self.plr_mgr.reset(self.n_students)\\n\\n\\t\\ttrain_state = runner_state[1]\\n\\t\\ttrain_state = train_state.replace(plr_buffer=plr_buffer)\\n\\t\\tif self.n_devices == 1:\\n\\t\\t\\trunner_state[1] = train_state\\n\\t\\telse:\\n\\t\\t\\tplr_buffer = jax.tree_map(lambda x: x.repeat(self.n_devices, 1), plr_buffer) # replicate plr buffer\\n\\t\\t\\trunner_state += (plr_buffer,) # Return PLR buffer directly to make shmap easier\\n\\n\\t\\tself.dummy_eval_output = self._create_dummy_eval_output(train_state)\\n\\n\\t\\treturn tuple(runner_state)\\n\\n\\tdef _create_dummy_eval_output(self, train_state):\\n\\t\\trng, *vrngs = jax.random.split(jax.random.PRNGKey(0), self.n_students+1)\\n\\t\\tobs, state, extra = self.benv.reset(jnp.array(vrngs))\\n\\n\\t\\tep_stats = self.rolling_stats.reset_stats(\\n\\t\\t\\tbatch_shape=(self.n_students, self.n_parallel*self.n_eval))\\n\\n\\t\\tued_scores = jnp.zeros((self.n_students, self.n_parallel))\\n\\n\\t\\tif self.student_pop.agent.is_recurrent:\\n\\t\\t\\tcarry = self.zero_carry\\n\\t\\telse:\\n\\t\\t\\tcarry = None\\n\\t\\trollout = self.student_rollout.reset()\\n\\n\\t\\ttrain_batch = self.student_rollout.get_batch(\\n\\t\\t\\trollout, \\n\\t\\t\\tself.student_pop.get_value(\\n\\t\\t\\t\\tjax.lax.stop_gradient(train_state.params), \\n\\t\\t\\t\\tobs, \\n\\t\\t\\t\\tcarry,\\n\\t\\t\\t)\\n\\t\\t)\\n\\n\\t\\treturn (\\n\\t\\t\\trng,\\n\\t\\t\\ttrain_state, \\n\\t\\t\\tstate, \\n\\t\\t\\tstate,\\n\\t\\t\\tobs, \\n\\t\\t\\tcarry, \\n\\t\\t\\textra, \\n\\t\\t\\tep_stats,\\n\\t\\t\\tstate,\\n\\t\\t\\ttrain_batch,\\n\\t\\t\\tued_scores\\n\\t\\t)\\n\\n\\t@partial(jax.jit, static_argnums=(0,8))\\n\\tdef _eval_and_update_plr(\\n\\t\\t\\tself,\\n\\t\\t\\trng,\\n\\t\\t\\tlevels,\\n\\t\\t\\tlevel_idxs, \\n\\t\\t\\ttrain_state, \\n\\t\\t\\tupdate_plr,\\n\\t\\t\\tparent_idxs=None,\\n\\t\\t\\tdupe_mask=None,\\n\\t\\t\\tfake=False):\\n\\t\\t# Collect rollout and optionally update plr buffer\\n\\t\\t# Returns train_batch and ued_scores\\n\\t\\t# Perform rollout: @todo: pmap this\\n\\t\\tif fake:\\n\\t\\t\\tdummy_eval_output = list(self.dummy_eval_output)\\n\\t\\t\\tdummy_eval_output[1] = train_state\\n\\t\\t\\treturn tuple(dummy_eval_output)\\n\\n\\t\\trollout_batch_shape = (self.n_students, self.n_parallel*self.n_eval)\\n\\t\\tobs, state, extra = self.benv.set_state(levels)\\n\\t\\tep_stats = self.rolling_stats.reset_stats(\\n\\t\\t\\tbatch_shape=rollout_batch_shape)\\n\\n\\t\\trollout_start_state = state\\n\\n\\t\\tdone = jnp.zeros(rollout_batch_shape, dtype=jnp.bool_)\\n\\t\\tif self.student_pop.agent.is_recurrent:\\n\\t\\t\\tcarry = self.zero_carry\\n\\t\\telse:\\n\\t\\t\\tcarry = None\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tstart_state = state\\n\\t\\trollout, state, start_state, obs, carry, extra, ep_stats, train_state = \\\\\\n\\t\\t\\tself._rollout_students(\\n\\t\\t\\t\\tsubrng, \\n\\t\\t\\t\\ttrain_state, \\n\\t\\t\\t\\tstate, \\n\\t\\t\\t\\tstart_state,\\n\\t\\t\\t\\tobs, \\n\\t\\t\\t\\tcarry, \\n\\t\\t\\t\\tdone,\\n\\t\\t\\t\\textra, \\n\\t\\t\\t\\tep_stats\\n\\t\\t\\t)\\n\\n\\t\\ttrain_batch = self.student_rollout.get_batch(\\n\\t\\t\\trollout, \\n\\t\\t\\tself.student_pop.get_value(\\n\\t\\t\\t\\tjax.lax.stop_gradient(train_state.params), \\n\\t\\t\\t\\tobs, \\n\\t\\t\\t\\tcarry\\n\\t\\t\\t)\\n\\t\\t)\\n\\n\\t\\t# Update PLR buffer\\n\\t\\tif self.ued_score == UEDScore.MAX_MC:\\n\\t\\t\\tmax_returns = jax.vmap(lambda x,y: x.at[y].get())(train_state.plr_buffer.max_returns, level_idxs)\\n\\t\\t\\tmax_returns = jnp.where(\\n\\t\\t\\t\\tjnp.greater_equal(level_idxs, 0),\\n\\t\\t\\t\\tmax_returns,\\n\\t\\t\\t\\tjnp.full_like(max_returns, -jnp.inf)\\n\\t\\t\\t)\\n\\t\\t\\tued_info = {'max_returns': max_returns}\\n\\t\\telse:\\n\\t\\t\\tued_info = None\\n\\t\\tued_scores, ued_score_info = compute_ued_scores(\\n\\t\\t\\tself.ued_score, train_batch, self.n_eval, info=ued_info, ignore_val=-jnp.inf, per_agent=True)\\n\\t\\tnext_plr_buffer = self.plr_mgr.update(\\n\\t\\t\\ttrain_state.plr_buffer, \\n\\t\\t\\tlevels=levels, \\n\\t\\t\\tlevel_idxs=level_idxs, \\n\\t\\t\\tued_scores=ued_scores,\\n\\t\\t\\tdupe_mask=dupe_mask, \\n\\t\\t\\tinfo=ued_score_info, \\n\\t\\t\\tignore_val=-jnp.inf,\\n\\t\\t\\tparent_idxs=parent_idxs)\\n\\n\\t\\tnext_plr_buffer = jax.vmap(\\n\\t\\t\\tlambda update, new, prev: jax.tree_map(\\n\\t\\t\\t\\tlambda x, y: jax.lax.select(update, x, y), new, prev)\\n\\t\\t)(update_plr, next_plr_buffer, train_state.plr_buffer)\\n\\n\\t\\ttrain_state = train_state.replace(plr_buffer=next_plr_buffer)\\n\\n\\t\\treturn (\\n\\t\\t\\trng,\\n\\t\\t\\ttrain_state, \\n\\t\\t\\tstate, \\n\\t\\t\\tstart_state, \\n\\t\\t\\tobs, \\n\\t\\t\\tcarry, \\n\\t\\t\\textra, \\n\\t\\t\\tep_stats,\\n\\t\\t\\trollout_start_state,\\n\\t\\t\\ttrain_batch,\\n\\t\\t\\tued_scores,\\n\\t\\t)\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef _mutate_levels(self, rng, levels, level_idxs, ued_scores=None):\\n\\t\\tif not self.use_mutations:\\n\\t\\t\\treturn levels, level_idxs, jnp.full_like(level_idxs, -1)\\n\\n\\t\\tdef upsample_levels(levels, level_idxs, subsample_idxs):\\n\\t\\t\\tsubsample_idxs = subsample_idxs.repeat(self.n_parallel//self.mutation_subsample_size, -1)\\n\\t\\t\\tparent_idxs = level_idxs.take(subsample_idxs)\\n\\t\\t\\tlevels = jax.vmap(\\n\\t\\t\\t\\tlambda x, y: jax.tree_map(lambda _x: jnp.array(_x).take(y, 0), x)\\n\\t\\t\\t)(levels, parent_idxs)\\n\\t\\t\\t\\n\\t\\t\\treturn levels, parent_idxs\\n\\n\\t\\tif self.mutation_criterion == MutationCriterion.BATCH:\\n\\t\\t\\tparent_idxs = level_idxs\\n\\n\\t\\tif self.mutation_criterion == MutationCriterion.EASY:\\n\\t\\t\\t_, top_level_idxs = jax.lax.approx_min_k(ued_scores, self.mutation_subsample_size)\\n\\t\\t\\tlevels, parent_idxs = upsample_levels(levels, level_idxs, top_level_idxs)\\n\\n\\t\\telif self.mutation_criterion == MutationCriterion.HARD:\\n\\t\\t\\t_, top_level_idxs = jax.lax.approx_max_k(ued_scores, self.mutation_subsample_size)\\n\\t\\t\\tlevels, parent_idxs = upsample_levels(levels, level_idxs, top_level_idxs)\\n\\n\\t\\tn_parallel = level_idxs.shape[-1]\\n\\t\\tvrngs = jax.vmap(lambda subrng: jax.random.split(subrng, n_parallel))(\\n\\t\\t\\tjax.random.split(rng, self.n_students)\\n\\t\\t)\\n\\n\\t\\tmutated_levels = jax.vmap(\\n\\t\\t\\tlambda *args: jax.vmap(self.mutation_fn, in_axes=(0,None,0,None))(*args),\\n\\t\\t\\tin_axes=(0,None,0,None)\\n\\t\\t)(vrngs, self.benv.env_params, levels, self.n_mutations)\\n\\n\\t\\t# Mutated levels do not have existing idxs in the PLR buffer.\\n\\t\\tmutated_level_idxs = jnp.full((self.n_students, n_parallel), -1)\\n\\n\\t\\treturn mutated_levels, mutated_level_idxs, parent_idxs\\n\\n\\tdef _efficient_grad_update(self, rng, train_state, train_batch, is_replay):\\n\\t\\t# PPOAgent vmaps over the train state and batch. Batch must be N x EM\\n\\t\\tskip_grad_update = jnp.logical_and(self.use_robust_plr, ~is_replay)\\n\\n\\t\\tif self.n_students == 1:\\n\\t\\t\\ttrain_state, stats = jax.lax.cond(\\n\\t\\t\\t\\tskip_grad_update[0],\\n\\t\\t\\t\\tpartial(self.student_pop.update, fake=True),\\n\\t\\t\\t\\tself.student_pop.update,\\n\\t\\t\\t\\t*(rng, train_state, train_batch)\\n\\t\\t\\t)\\n\\t\\telif self.n_students > 1: # Have to vmap all students + take only students that need updates\\n\\t\\t\\t_, dummy_stats = jax.vmap(lambda *_: self.student_pop.agent.get_empty_update_stats())(np.arange(self.n_students))\\n\\t\\t\\t_train_state, stats = self.student.update(rng, train_state, train_batch)\\n\\t\\t\\ttrain_state, stats = jax.vmap(lambda cond,x,y: \\\\\\n\\t\\t\\t\\t\\tjax.tree_map(lambda _cond,_x,_y: jax.lax.select(_cond,_x,_y), cond, x, y))(\\n\\t\\t\\t\\t\\t\\tis_replay, (train_state, stats), (_train_state, dummy_stats)\\n\\t\\t\\t\\t\\t)\\n\\n\\t\\treturn train_state, stats\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef _compile_stats(self, update_stats, ep_stats, env_metrics=None, plr_stats=None):\\n\\t\\tstats = super()._compile_stats(update_stats, ep_stats, env_metrics)\\n\\n\\t\\tif plr_stats is not None:\\n\\t\\t\\tplr_stats = jax.vmap(lambda info: jax.tree_map(lambda x: x.mean(), info))(plr_stats)\\n\\n\\t\\tif self.n_students > 1:\\n\\t\\t\\t_plr_stats = {}\\n\\t\\t\\tfor i in range(self.n_students):\\n\\t\\t\\t\\t_student_plr_stats = jax.tree_util.tree_map(lambda x: x[i], plr_stats) # for agent0\\n\\t\\t\\t\\t_plr_stats.update({f'{k}_a{i}':v for k,v in _student_plr_stats.items()})\\n\\t\\t\\tplr_stats = _plr_stats\\n\\t\\telse:\\n\\t\\t\\tplr_stats = jax.tree_map(lambda x: x[0], plr_stats) \\n\\n\\t\\tstats.update({f'plr_{k}':v for k,v in plr_stats.items()})\\n\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\tstats = jax.tree_map(lambda x: jax.lax.pmean(x, 'device'), stats)\\n\\n\\t\\treturn stats\\n\\n\\t@partial(jax.jit, static_argnums=(0,))\\n\\tdef run(\\n\\t\\tself, \\n\\t\\trng, \\n\\t\\ttrain_state, \\n\\t\\tstate, \\n\\t\\tstart_state,\\n\\t\\tobs, \\n\\t\\tcarry=None, \\n\\t\\textra=None, \\n\\t\\tep_stats=None,\\n\\t\\tplr_buffer=None):\\n\\t\\t# If device sharded, load sharded PLR buffer into train state\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\trng = jax.random.fold_in(rng, jax.lax.axis_index('device'))\\n\\t\\t\\ttrain_state = train_state.replace(plr_buffer=plr_buffer)\\n\\n\\t\\t# Sample next training levels via PLR\\n\\t\\trng, *vrngs = jax.random.split(rng, self.n_students+1)\\n\\t\\tobs, state, extra = self.benv.reset(jnp.array(vrngs), self.n_parallel, 1)\\n\\n\\t\\tif self.use_parallel_eval:\\n\\t\\t\\tn_level_samples = self.n_parallel//self._n_parallel_batches\\n\\t\\t\\tnew_levels = jax.tree_map(lambda x: x.at[:,n_level_samples:2*n_level_samples].get(), state)\\n\\t\\telse:\\n\\t\\t\\tn_level_samples = self.n_parallel\\n\\t\\t\\tnew_levels = state\\n\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\tlevels, level_idxs, is_replay, next_plr_buffer = \\\\\\n\\t\\t\\tself.plr_mgr.sample(subrng, train_state.plr_buffer, new_levels, n_level_samples)\\n\\t\\ttrain_state = train_state.replace(plr_buffer=next_plr_buffer)\\n\\n\\t\\t# If use_parallel_eval=True, need to combine replay and non-replay levels together\\n\\t\\t# Need to mutate levels as well\\n\\t\\tparent_idxs = jnp.full((self.n_students, self.n_parallel), -1)\\n\\t\\tif self.use_parallel_eval: # Parallel ACCEL\\n\\t\\t\\tnew_level_idxs = jnp.full_like(parent_idxs, -1)\\n\\n\\t\\t\\t_all_levels = jax.vmap(\\n\\t\\t\\t\\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=n_level_samples, src_len=n_level_samples),\\n\\t\\t\\t\\t)(state, levels)\\n\\t\\t\\t_all_level_idxs = jax.vmap(\\n\\t\\t\\t\\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=n_level_samples, src_len=n_level_samples),\\n\\t\\t\\t\\t)(new_level_idxs, level_idxs)\\n\\n\\t\\t\\tif self.use_mutations:\\n\\t\\t\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\t\\t\\tmutated_levels, mutated_level_idxs, _parent_idxs = self._mutate_levels(subrng, levels, level_idxs)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tfallback_levels = jax.tree_map(lambda x: x.at[:,-n_level_samples:].get(), state)\\n\\t\\t\\t\\tfallback_level_idxs = jnp.full_like(mutated_level_idxs, -1)\\n\\n\\t\\t\\t\\tmutated_levels = jax.vmap(\\n\\t\\t\\t\\t\\tlambda cond,x,y: jax.tree_map(\\n\\t\\t\\t\\t\\t\\tlambda _x,_y: jax.lax.select(cond,_x,_y), x, y\\n\\t\\t\\t\\t\\t))(is_replay, mutated_levels, fallback_levels)\\n\\n\\t\\t\\t\\tmutated_level_idxs = jax.vmap(\\n\\t\\t\\t\\t\\tlambda cond,x,y: jax.tree_map(\\n\\t\\t\\t\\t\\t\\tlambda _x,_y: jax.lax.select(cond,_x,_y), x, y\\n\\t\\t\\t\\t\\t))(is_replay, mutated_level_idxs, fallback_level_idxs)\\n\\n\\t\\t\\t\\t_parent_idxs = jax.vmap(\\n\\t\\t\\t\\t\\tlambda cond,x,y: jax.tree_map(\\n\\t\\t\\t\\t\\t\\tlambda _x,_y: jax.lax.select(cond,_x,_y), x, y\\n\\t\\t\\t\\t\\t))(is_replay, _parent_idxs, fallback_level_idxs)\\n\\t\\t\\n\\t\\t\\t\\tmutated_levels_start_idx = 2*n_level_samples\\n\\t\\t\\t\\t_all_levels = jax.vmap(\\n\\t\\t\\t\\t\\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=mutated_levels_start_idx, src_len=n_level_samples),\\n\\t\\t\\t\\t\\t)(_all_levels, mutated_levels)\\n\\t\\t\\t\\t_all_level_idxs = jax.vmap(\\n\\t\\t\\t\\t\\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=mutated_levels_start_idx, src_len=n_level_samples),\\n\\t\\t\\t\\t\\t)(_all_level_idxs, mutated_level_idxs)\\n\\t\\t\\t\\tparent_idxs = jax.vmap(\\n\\t\\t\\t\\t\\tlambda x,y: _tree_util.pytree_merge(x,y, start_idx=mutated_levels_start_idx, src_len=n_level_samples),\\n\\t\\t\\t\\t\\t)(parent_idxs, _parent_idxs)\\n\\n\\t\\t\\tlevels = _all_levels\\n\\t\\t\\tlevel_idxs = _all_level_idxs\\n\\n\\t\\t# dedupe levels, move into PLR buffer logic\\n\\t\\tif self.force_unique:\\n\\t\\t\\tlevel_idxs, dupe_mask = self.plr_mgr.dedupe_levels(next_plr_buffer, levels, level_idxs)\\n\\t\\telse:\\n\\t\\t\\tdupe_mask = None \\n\\n\\t\\t# Evaluate levels + update PLR\\n\\t\\tresult = self._eval_and_update_plr(\\n\\t\\t\\trng, levels, level_idxs, train_state, update_plr=jnp.array([True]*self.n_students), parent_idxs=parent_idxs, dupe_mask=dupe_mask)\\n\\t\\trng, train_state, state, start_state, obs, carry, extra, ep_stats, \\\\\\n\\t\\t\\trollout_start_state, train_batch, ued_scores = result\\n\\n\\t\\tif self.use_parallel_eval:\\n\\t\\t\\treplay_start_idx = self.n_eval*n_level_samples\\n\\t\\t\\treplay_end_idx = 2*replay_start_idx\\n\\t\\t\\ttrain_batch = jax.vmap(\\n\\t\\t\\t\\tlambda x: jax.tree_map(\\n\\t\\t\\t\\t\\tlambda _x: _x.at[:,replay_start_idx:replay_end_idx].get(), x)\\n\\t\\t\\t\\t)(train_batch)\\n\\n\\t\\t# Gradient update\\n\\t\\trng, subrng = jax.random.split(rng)\\n\\t\\ttrain_state, update_stats = self._efficient_grad_update(subrng, train_state, train_batch, is_replay)\\n\\n\\t\\t# Mutation step\\n\\t\\tuse_mutations = jnp.logical_and(self.use_mutations, is_replay)\\n\\t\\tuse_mutations = jnp.logical_and(use_mutations, not self.use_parallel_eval) # Already mutated above in parallel\\n\\t\\trng, arng, brng = jax.random.split(rng, 3)\\n\\n\\t\\tmutated_levels, mutated_level_idxs, parent_idxs = jax.lax.cond(\\n\\t\\t\\tuse_mutations.any(),\\n\\t\\t\\tself._mutate_levels,\\n\\t\\t\\tlambda *_: (levels, level_idxs, jnp.full_like(level_idxs, -1)),\\n\\t\\t\\t*(arng, levels, level_idxs, ued_scores)\\n\\t\\t)\\n\\n\\t\\tmutated_dupe_mask = jnp.zeros_like(mutated_level_idxs, dtype=jnp.bool_)\\n\\t\\tif self.force_unique: # Should move into update plr logic\\n\\t\\t\\tmutated_level_idxs, mutated_dupe_mask = jax.lax.cond(\\n\\t\\t\\t\\tuse_mutations.any(),\\n\\t\\t\\t\\tself.plr_mgr.dedupe_levels,\\n\\t\\t\\t\\tlambda *_: (mutated_level_idxs, mutated_dupe_mask),\\n\\t\\t\\t\\t*(next_plr_buffer, mutated_levels, mutated_level_idxs)\\n\\t\\t\\t)\\n\\n\\t\\tmutation_eval_result = jax.lax.cond(\\n\\t\\t\\tuse_mutations.any(),\\n\\t\\t\\tself._eval_and_update_plr,\\n\\t\\t\\tpartial(self._eval_and_update_plr, fake=True),\\n\\t\\t\\t*(brng, mutated_levels, mutated_level_idxs, train_state, use_mutations, parent_idxs, mutated_dupe_mask)\\n\\t\\t)\\n\\t\\ttrain_state = mutation_eval_result[1]\\n\\n\\t\\t# Collect training env metrics\\n\\t\\tif self.track_env_metrics:\\n\\t\\t\\tenv_metrics = self.benv.get_env_metrics(levels)\\n\\t\\telse:\\n\\t\\t\\tenv_metrics = None\\n\\n\\t\\tplr_stats = self.plr_mgr.get_metrics(train_state.plr_buffer)\\n\\n\\t\\tstats = self._compile_stats(update_stats, ep_stats, env_metrics, plr_stats)\\n\\n\\t\\tif self.n_devices > 1:\\n\\t\\t\\tplr_buffer = train_state.plr_buffer\\n\\t\\t\\ttrain_state = train_state.replace(plr_buffer=None)\\n\\n\\t\\ttrain_state = train_state.increment()\\n\\t\\tstats.update(dict(n_updates=train_state.n_updates[0]))\\n\\n\\t\\treturn (\\n\\t\\t\\tstats, \\n\\t\\t\\trng, \\n\\t\\t\\ttrain_state, \\n\\t\\t\\tstate, \\n\\t\\t\\tstart_state, \\n\\t\\t\\tobs, \\n\\t\\t\\tcarry, \\n\\t\\t\\textra, \\n\\t\\t\\tep_stats,\\n\\t\\t\\tplr_buffer\\n\\t\\t)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import copy\nimport time\nimport numpy as np\nimport jax\nimport minimax.envs as envs\nimport minimax.models as models\nimport minimax.agents as agents\nfrom functools import partial\nfrom collections import defaultdict\nfrom jax.sharding import Mesh, PartitionSpec as P\nfrom jax.experimental import mesh_utils\nfrom jax.experimental.shard_map import shard_map\nfrom .eval_runner import EvalRunner\nfrom .dr_runner import DRRunner\nfrom .paired_runner import PAIREDRunner\nfrom .plr_runner import PLRRunner\nfrom minimax.util.rl import UEDScore, PopPLRManager"},"token_num":{"kind":"number","value":16361,"string":"16,361"},"cropped_code":{"kind":"string","value":"\"\"\"\nCopyright (c) Meta Platforms, Inc. and affiliates.\nAll rights reserved.\n\nThis source code is licensed under the license found in the\nLICENSE file in the root directory of this source tree.\n\"\"\"\n\n\n\n\n\nclass RunnerInfo:\n\tdef __init__(\n\t\tself, \n\t\trunner_cls, \n\t\tis_ued=False):\n\t\tself.runner_cls = runner_cls\n\t\tself.is_ued = is_ued\n\n\nRUNNER_INFO = {\n\t'dr': RunnerInfo(\n"},"all_code":{"kind":"string","value":"\"\"\"\nCopyright (c) Meta Platforms, Inc. and affiliates.\nAll rights reserved.\n\nThis source code is licensed under the license found in the\nLICENSE file in the root directory of this source tree.\n\"\"\"\n\n\n\n\n\nclass RunnerInfo:\n\tdef __init__(\n\t\tself, \n\t\trunner_cls, \n\t\tis_ued=False):\n\t\tself.runner_cls = runner_cls\n\t\tself.is_ued = is_ued\n\n\nRUNNER_INFO = {\n\t'dr': RunnerInfo("},"next_line":{"kind":"string","value":"\t\trunner_cls=DRRunner,"},"gold_snippet_index":{"kind":"number","value":1,"string":"1"},"created_at":{"kind":"string","value":"2023-10-28 12:12:01+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5683,"cells":{"repo_name":{"kind":"string","value":"nv-tlabs/vid2player3d"},"file_path":{"kind":"string","value":"poselib/poselib/skeleton/tests/test_skeleton.py"},"context":{"kind":"list like","value":[{"identifier":"SkeletonTree","path":"poselib/poselib/skeleton/skeleton3d.py","snippet":"class SkeletonTree(Serializable):\n \"\"\"\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\n over a list of nodes with their names indicated by strings. Each edge in the tree has a local\n translation associated with it which describes the distance between the two nodes that it\n connects. \n\n Basic Usage:\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\n >>> t\n SkeletonTree(\n node_names=['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot'],\n parent_indices=tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11]),\n local_translation=tensor([[ 0.0000, 0.0000, 0.7500],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, -0.2000, 0.0000],\n [ 0.2000, -0.2000, 0.0000]])\n )\n >>> t.node_names\n ['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot']\n >>> t.parent_indices\n tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11])\n >>> t.local_translation\n tensor([[ 0.0000, 0.0000, 0.7500],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, -0.2000, 0.0000],\n [ 0.2000, -0.2000, 0.0000]])\n >>> t.parent_of('front_left_leg')\n 'torso'\n >>> t.index('front_right_foot')\n 6\n >>> t[2]\n 'aux_1'\n \"\"\"\n\n __example_mjcf_path__ = os.path.join(\n os.path.dirname(os.path.realpath(__file__)), \"tests/ant.xml\"\n )\n\n def __init__(self, node_names, parent_indices, local_translation):\n \"\"\"\n :param node_names: a list of names for each tree node\n :type node_names: List[str]\n :param parent_indices: an int32-typed tensor that represents the edge to its parent.\\\n -1 represents the root node\n :type parent_indices: Tensor\n :param local_translation: a 3d vector that gives local translation information\n :type local_translation: Tensor\n \"\"\"\n ln, lp, ll = len(node_names), len(parent_indices), len(local_translation)\n assert len(set((ln, lp, ll))) == 1\n self._node_names = node_names\n self._parent_indices = parent_indices.long()\n self._local_translation = local_translation\n self._node_indices = {self.node_names[i]: i for i in range(len(self))}\n\n def __len__(self):\n \"\"\" number of nodes in the skeleton tree \"\"\"\n return len(self.node_names)\n\n def __iter__(self):\n \"\"\" iterator that iterate through the name of each node \"\"\"\n yield from self.node_names\n\n def __getitem__(self, item):\n \"\"\" get the name of the node given the index \"\"\"\n return self.node_names[item]\n\n def __repr__(self):\n return (\n \"SkeletonTree(\\n node_names={},\\n parent_indices={},\"\n \"\\n local_translation={}\\n)\".format(\n self._indent(repr(self.node_names)),\n self._indent(repr(self.parent_indices)),\n self._indent(repr(self.local_translation)),\n )\n )\n\n def _indent(self, s):\n return \"\\n \".join(s.split(\"\\n\"))\n\n @property\n def node_names(self):\n return self._node_names\n\n @property\n def parent_indices(self):\n return self._parent_indices\n\n @property\n def local_translation(self):\n return self._local_translation\n\n @property\n def num_joints(self):\n \"\"\" number of nodes in the skeleton tree \"\"\"\n return len(self)\n\n @classmethod\n def from_dict(cls, dict_repr, *args, **kwargs):\n return cls(\n list(map(str, dict_repr[\"node_names\"])),\n TensorUtils.from_dict(dict_repr[\"parent_indices\"], *args, **kwargs),\n TensorUtils.from_dict(dict_repr[\"local_translation\"], *args, **kwargs),\n )\n\n def to_dict(self):\n return OrderedDict(\n [\n (\"node_names\", self.node_names),\n (\"parent_indices\", tensor_to_dict(self.parent_indices)),\n (\"local_translation\", tensor_to_dict(self.local_translation)),\n ]\n )\n\n @classmethod\n def from_mjcf(cls, path: str) -> \"SkeletonTree\":\n \"\"\"\n Parses a mujoco xml scene description file and returns a Skeleton Tree.\n We use the model attribute at the root as the name of the tree.\n \n :param path:\n :type path: string\n :return: The skeleton tree constructed from the mjcf file\n :rtype: SkeletonTree\n \"\"\"\n tree = ET.parse(path)\n xml_doc_root = tree.getroot()\n xml_world_body = xml_doc_root.find(\"worldbody\")\n if xml_world_body is None:\n raise ValueError(\"MJCF parsed incorrectly please verify it.\")\n # assume this is the root\n xml_body_root = xml_world_body.find(\"body\")\n if xml_body_root is None:\n raise ValueError(\"MJCF parsed incorrectly please verify it.\")\n\n node_names = []\n parent_indices = []\n local_translation = []\n\n # recursively adding all nodes into the skel_tree\n def _add_xml_node(xml_node, parent_index, node_index):\n node_name = xml_node.attrib.get(\"name\")\n # parse the local translation into float list\n pos = np.fromstring(xml_node.attrib.get(\"pos\"), dtype=float, sep=\" \")\n node_names.append(node_name)\n parent_indices.append(parent_index)\n local_translation.append(pos)\n curr_index = node_index\n node_index += 1\n for next_node in xml_node.findall(\"body\"):\n node_index = _add_xml_node(next_node, curr_index, node_index)\n return node_index\n\n _add_xml_node(xml_body_root, -1, 0)\n\n return cls(\n node_names,\n torch.from_numpy(np.array(parent_indices, dtype=np.int32)),\n torch.from_numpy(np.array(local_translation, dtype=np.float32)),\n )\n\n def parent_of(self, node_name):\n \"\"\" get the name of the parent of the given node\n\n :param node_name: the name of the node\n :type node_name: string\n :rtype: string\n \"\"\"\n return self[int(self.parent_indices[self.index(node_name)].item())]\n\n def index(self, node_name):\n \"\"\" get the index of the node\n \n :param node_name: the name of the node\n :type node_name: string\n :rtype: int\n \"\"\"\n return self._node_indices[node_name]\n\n def drop_nodes_by_names(\n self, node_names: List[str], pairwise_translation=None\n ) -> \"SkeletonTree\":\n new_length = len(self) - len(node_names)\n new_node_names = []\n new_local_translation = torch.zeros(\n new_length, 3, dtype=self.local_translation.dtype\n )\n new_parent_indices = torch.zeros(new_length, dtype=self.parent_indices.dtype)\n parent_indices = self.parent_indices.numpy()\n new_node_indices: dict = {}\n new_node_index = 0\n for node_index in range(len(self)):\n if self[node_index] in node_names:\n continue\n tb_node_index = parent_indices[node_index]\n if tb_node_index != -1:\n local_translation = self.local_translation[node_index, :]\n while tb_node_index != -1 and self[tb_node_index] in node_names:\n local_translation += self.local_translation[tb_node_index, :]\n tb_node_index = parent_indices[tb_node_index]\n assert tb_node_index != -1, \"the root node cannot be dropped\"\n\n if pairwise_translation is not None:\n local_translation = pairwise_translation[\n tb_node_index, node_index, :\n ]\n else:\n local_translation = self.local_translation[node_index, :]\n\n new_node_names.append(self[node_index])\n new_local_translation[new_node_index, :] = local_translation\n if tb_node_index == -1:\n new_parent_indices[new_node_index] = -1\n else:\n new_parent_indices[new_node_index] = new_node_indices[\n self[tb_node_index]\n ]\n new_node_indices[self[node_index]] = new_node_index\n new_node_index += 1\n\n return SkeletonTree(new_node_names, new_parent_indices, new_local_translation)\n\n def keep_nodes_by_names(\n self, node_names: List[str], pairwise_translation=None\n ) -> \"SkeletonTree\":\n nodes_to_drop = list(filter(lambda x: x not in node_names, self))\n return self.drop_nodes_by_names(nodes_to_drop, pairwise_translation)"},{"identifier":"SkeletonState","path":"poselib/poselib/skeleton/skeleton3d.py","snippet":"class SkeletonState(Serializable):\n \"\"\"\n A skeleton state contains all the information needed to describe a static state of a skeleton.\n It requires a skeleton tree, local/global rotation at each joint and the root translation.\n\n Example:\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\n >>> zero_pose = SkeletonState.zero_pose(t)\n >>> plot_skeleton_state(zero_pose) # can be imported from `.visualization.common`\n [plot of the ant at zero pose\n >>> local_rotation = zero_pose.local_rotation.clone()\n >>> local_rotation[2] = torch.tensor([0, 0, 1, 0])\n >>> new_pose = SkeletonState.from_rotation_and_root_translation(\n ... skeleton_tree=t,\n ... r=local_rotation,\n ... t=zero_pose.root_translation,\n ... is_local=True\n ... )\n >>> new_pose.local_rotation\n tensor([[0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 1., 0., 0.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.]])\n >>> plot_skeleton_state(new_pose) # you should be able to see one of ant's leg is bent\n [plot of the ant with the new pose\n >>> new_pose.global_rotation # the local rotation is propagated to the global rotation at joint #3\n tensor([[0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 1., 0., 0.],\n [0., 1., 0., 0.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.]])\n\n Global/Local Representation (cont. from the previous example)\n >>> new_pose.is_local\n True\n >>> new_pose.tensor # this will return the local rotation followed by the root translation\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0.,\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\n 0.])\n >>> new_pose.tensor.shape # 4 * 13 (joint rotation) + 3 (root translatio\n torch.Size([55])\n >>> new_pose.global_repr().is_local\n False\n >>> new_pose.global_repr().tensor # this will return the global rotation followed by the root translation instead\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0.,\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\n 0.])\n >>> new_pose.global_repr().tensor.shape # 4 * 13 (joint rotation) + 3 (root translation\n torch.Size([55])\n \"\"\"\n\n def __init__(self, tensor_backend, skeleton_tree, is_local):\n self._skeleton_tree = skeleton_tree\n self._is_local = is_local\n self.tensor = tensor_backend.clone()\n\n def __len__(self):\n return self.tensor.shape[0]\n\n @property\n def rotation(self):\n if not hasattr(self, \"_rotation\"):\n self._rotation = self.tensor[..., : self.num_joints * 4].reshape(\n *(self.tensor.shape[:-1] + (self.num_joints, 4))\n )\n return self._rotation\n\n @property\n def _local_rotation(self):\n if self._is_local:\n return self.rotation\n else:\n return None\n\n @property\n def _global_rotation(self):\n if not self._is_local:\n return self.rotation\n else:\n return None\n\n @property\n def is_local(self):\n \"\"\" is the rotation represented in local frame? \n \n :rtype: bool\n \"\"\"\n return self._is_local\n\n @property\n def invariant_property(self):\n return {\"skeleton_tree\": self.skeleton_tree, \"is_local\": self.is_local}\n\n @property\n def num_joints(self):\n \"\"\" number of joints in the skeleton tree \n \n :rtype: int\n \"\"\"\n return self.skeleton_tree.num_joints\n\n @property\n def skeleton_tree(self):\n \"\"\" skeleton tree \n \n :rtype: SkeletonTree\n \"\"\"\n return self._skeleton_tree\n\n @property\n def root_translation(self):\n \"\"\" root translation \n \n :rtype: Tensor\n \"\"\"\n if not hasattr(self, \"_root_translation\"):\n self._root_translation = self.tensor[\n ..., self.num_joints * 4 : self.num_joints * 4 + 3\n ]\n return self._root_translation\n\n @property\n def global_transformation(self):\n \"\"\" global transformation of each joint (transform from joint frame to global frame) \"\"\"\n if not hasattr(self, \"_global_transformation\"):\n local_transformation = self.local_transformation\n global_transformation = []\n parent_indices = self.skeleton_tree.parent_indices.numpy()\n # global_transformation = local_transformation.identity_like()\n for node_index in range(len(self.skeleton_tree)):\n parent_index = parent_indices[node_index]\n if parent_index == -1:\n global_transformation.append(\n local_transformation[..., node_index, :]\n )\n else:\n global_transformation.append(\n transform_mul(\n global_transformation[parent_index],\n local_transformation[..., node_index, :],\n )\n )\n self._global_transformation = torch.stack(global_transformation, axis=-2)\n return self._global_transformation\n\n @property\n def global_rotation(self):\n \"\"\" global rotation of each joint (rotation matrix to rotate from joint's F.O.R to global\n F.O.R) \"\"\"\n if self._global_rotation is None:\n if not hasattr(self, \"_comp_global_rotation\"):\n self._comp_global_rotation = transform_rotation(\n self.global_transformation\n )\n return self._comp_global_rotation\n else:\n return self._global_rotation\n\n @property\n def global_translation(self):\n \"\"\" global translation of each joint \"\"\"\n if not hasattr(self, \"_global_translation\"):\n self._global_translation = transform_translation(self.global_transformation)\n return self._global_translation\n\n @property\n def global_translation_xy(self):\n \"\"\" global translation in xy \"\"\"\n trans_xy_data = self.global_translation.zeros_like()\n trans_xy_data[..., 0:2] = self.global_translation[..., 0:2]\n return trans_xy_data\n\n @property\n def global_translation_xz(self):\n \"\"\" global translation in xz \"\"\"\n trans_xz_data = self.global_translation.zeros_like()\n trans_xz_data[..., 0:1] = self.global_translation[..., 0:1]\n trans_xz_data[..., 2:3] = self.global_translation[..., 2:3]\n return trans_xz_data\n\n @property\n def local_rotation(self):\n \"\"\" the rotation from child frame to parent frame given in the order of child nodes appeared\n in `.skeleton_tree.node_names` \"\"\"\n if self._local_rotation is None:\n if not hasattr(self, \"_comp_local_rotation\"):\n local_rotation = quat_identity_like(self.global_rotation)\n for node_index in range(len(self.skeleton_tree)):\n parent_index = self.skeleton_tree.parent_indices[node_index]\n if parent_index == -1:\n local_rotation[..., node_index, :] = self.global_rotation[\n ..., node_index, :\n ]\n else:\n local_rotation[..., node_index, :] = quat_mul_norm(\n quat_inverse(self.global_rotation[..., parent_index, :]),\n self.global_rotation[..., node_index, :],\n )\n self._comp_local_rotation = local_rotation\n return self._comp_local_rotation\n else:\n return self._local_rotation\n\n @property\n def local_transformation(self):\n \"\"\" local translation + local rotation. It describes the transformation from child frame to \n parent frame given in the order of child nodes appeared in `.skeleton_tree.node_names` \"\"\"\n if not hasattr(self, \"_local_transformation\"):\n self._local_transformation = transform_from_rotation_translation(\n r=self.local_rotation, t=self.local_translation\n )\n return self._local_transformation\n\n @property\n def local_translation(self):\n \"\"\" local translation of the skeleton state. It is identical to the local translation in\n `.skeleton_tree.local_translation` except the root translation. The root translation is\n identical to `.root_translation` \"\"\"\n if not hasattr(self, \"_local_translation\"):\n broadcast_shape = (\n tuple(self.tensor.shape[:-1])\n + (len(self.skeleton_tree),)\n + tuple(self.skeleton_tree.local_translation.shape[-1:])\n )\n local_translation = self.skeleton_tree.local_translation.broadcast_to(\n *broadcast_shape\n ).clone()\n local_translation[..., 0, :] = self.root_translation\n self._local_translation = local_translation\n return self._local_translation\n\n # Root Properties\n @property\n def root_translation_xy(self):\n \"\"\" root translation on xy \"\"\"\n if not hasattr(self, \"_root_translation_xy\"):\n self._root_translation_xy = self.global_translation_xy[..., 0, :]\n return self._root_translation_xy\n\n @property\n def global_root_rotation(self):\n \"\"\" root rotation \"\"\"\n if not hasattr(self, \"_global_root_rotation\"):\n self._global_root_rotation = self.global_rotation[..., 0, :]\n return self._global_root_rotation\n\n @property\n def global_root_yaw_rotation(self):\n \"\"\" root yaw rotation \"\"\"\n if not hasattr(self, \"_global_root_yaw_rotation\"):\n self._global_root_yaw_rotation = self.global_root_rotation.yaw_rotation()\n return self._global_root_yaw_rotation\n\n # Properties relative to root\n @property\n def local_translation_to_root(self):\n \"\"\" The 3D translation from joint frame to the root frame. \"\"\"\n if not hasattr(self, \"_local_translation_to_root\"):\n self._local_translation_to_root = (\n self.global_translation - self.root_translation.unsqueeze(-1)\n )\n return self._local_translation_to_root\n\n @property\n def local_rotation_to_root(self):\n \"\"\" The 3D rotation from joint frame to the root frame. It is equivalent to \n The root_R_world * world_R_node \"\"\"\n return (\n quat_inverse(self.global_root_rotation).unsqueeze(-1) * self.global_rotation\n )\n\n def compute_forward_vector(\n self,\n left_shoulder_index,\n right_shoulder_index,\n left_hip_index,\n right_hip_index,\n gaussian_filter_width=20,\n ):\n \"\"\" Computes forward vector based on cross product of the up vector with \n average of the right->left shoulder and hip vectors \"\"\"\n global_positions = self.global_translation\n # Perpendicular to the forward direction.\n # Uses the shoulders and hips to find this.\n side_direction = (\n global_positions[:, left_shoulder_index].numpy()\n - global_positions[:, right_shoulder_index].numpy()\n + global_positions[:, left_hip_index].numpy()\n - global_positions[:, right_hip_index].numpy()\n )\n side_direction = (\n side_direction\n / np.sqrt((side_direction ** 2).sum(axis=-1))[..., np.newaxis]\n )\n\n # Forward direction obtained by crossing with the up direction.\n forward_direction = np.cross(side_direction, np.array([[0, 1, 0]]))\n\n # Smooth the forward direction with a Gaussian.\n # Axis 0 is the time/frame axis.\n forward_direction = filters.gaussian_filter1d(\n forward_direction, gaussian_filter_width, axis=0, mode=\"nearest\"\n )\n forward_direction = (\n forward_direction\n / np.sqrt((forward_direction ** 2).sum(axis=-1))[..., np.newaxis]\n )\n\n return torch.from_numpy(forward_direction)\n\n @staticmethod\n def _to_state_vector(rot, rt):\n state_shape = rot.shape[:-2]\n vr = rot.reshape(*(state_shape + (-1,)))\n vt = rt.broadcast_to(*state_shape + rt.shape[-1:]).reshape(\n *(state_shape + (-1,))\n )\n v = torch.cat([vr, vt], axis=-1)\n return v\n\n @classmethod\n def from_dict(\n cls: Type[\"SkeletonState\"], dict_repr: OrderedDict, *args, **kwargs\n ) -> \"SkeletonState\":\n rot = TensorUtils.from_dict(dict_repr[\"rotation\"], *args, **kwargs)\n rt = TensorUtils.from_dict(dict_repr[\"root_translation\"], *args, **kwargs)\n return cls(\n SkeletonState._to_state_vector(rot, rt),\n SkeletonTree.from_dict(dict_repr[\"skeleton_tree\"], *args, **kwargs),\n dict_repr[\"is_local\"],\n )\n\n def to_dict(self) -> OrderedDict:\n return OrderedDict(\n [\n (\"rotation\", tensor_to_dict(self.rotation)),\n (\"root_translation\", tensor_to_dict(self.root_translation)),\n (\"skeleton_tree\", self.skeleton_tree.to_dict()),\n (\"is_local\", self.is_local),\n ]\n )\n\n @classmethod\n def from_rotation_and_root_translation(cls, skeleton_tree, r, t, is_local=True):\n \"\"\"\n Construct a skeleton state from rotation and root translation\n\n :param skeleton_tree: the skeleton tree\n :type skeleton_tree: SkeletonTree\n :param r: rotation (either global or local)\n :type r: Tensor\n :param t: root translation\n :type t: Tensor\n :param is_local: to indicate that whether the rotation is local or global\n :type is_local: bool, optional, default=True\n \"\"\"\n assert (\n r.dim() > 0\n ), \"the rotation needs to have at least 1 dimension (dim = {})\".format(r.dim)\n return cls(\n SkeletonState._to_state_vector(r, t),\n skeleton_tree=skeleton_tree,\n is_local=is_local,\n )\n\n @classmethod\n def zero_pose(cls, skeleton_tree):\n \"\"\"\n Construct a zero-pose skeleton state from the skeleton tree by assuming that all the local\n rotation is 0 and root translation is also 0.\n\n :param skeleton_tree: the skeleton tree as the rigid body\n :type skeleton_tree: SkeletonTree\n \"\"\"\n return cls.from_rotation_and_root_translation(\n skeleton_tree=skeleton_tree,\n r=quat_identity([skeleton_tree.num_joints]),\n t=torch.zeros(3, dtype=skeleton_tree.local_translation.dtype),\n is_local=True,\n )\n\n def local_repr(self):\n \"\"\" \n Convert the skeleton state into local representation. This will only affects the values of\n .tensor. If the skeleton state already has `is_local=True`. This method will do nothing. \n\n :rtype: SkeletonState\n \"\"\"\n if self.is_local:\n return self\n return SkeletonState.from_rotation_and_root_translation(\n self.skeleton_tree,\n r=self.local_rotation,\n t=self.root_translation,\n is_local=True,\n )\n\n def global_repr(self):\n \"\"\" \n Convert the skeleton state into global representation. This will only affects the values of\n .tensor. If the skeleton state already has `is_local=False`. This method will do nothing. \n\n :rtype: SkeletonState\n \"\"\"\n if not self.is_local:\n return self\n return SkeletonState.from_rotation_and_root_translation(\n self.skeleton_tree,\n r=self.global_rotation,\n t=self.root_translation,\n is_local=False,\n )\n\n def _get_pairwise_average_translation(self):\n global_transform_inv = transform_inverse(self.global_transformation)\n p1 = global_transform_inv.unsqueeze(-2)\n p2 = self.global_transformation.unsqueeze(-3)\n\n pairwise_translation = (\n transform_translation(transform_mul(p1, p2))\n .reshape(-1, len(self.skeleton_tree), len(self.skeleton_tree), 3)\n .mean(axis=0)\n )\n return pairwise_translation\n\n def _transfer_to(self, new_skeleton_tree: SkeletonTree):\n old_indices = list(map(self.skeleton_tree.index, new_skeleton_tree))\n return SkeletonState.from_rotation_and_root_translation(\n new_skeleton_tree,\n r=self.global_rotation[..., old_indices, :],\n t=self.root_translation,\n is_local=False,\n )\n\n def drop_nodes_by_names(\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\n ) -> \"SkeletonState\":\n \"\"\" \n Drop a list of nodes from the skeleton and re-compute the local rotation to match the \n original joint position as much as possible. \n\n :param node_names: a list node names that specifies the nodes need to be dropped\n :type node_names: List of strings\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\n or not to re-estimate the local translation from the states (avg.)\n :type estimate_local_translation_from_states: boolean\n :rtype: SkeletonState\n \"\"\"\n if estimate_local_translation_from_states:\n pairwise_translation = self._get_pairwise_average_translation()\n else:\n pairwise_translation = None\n new_skeleton_tree = self.skeleton_tree.drop_nodes_by_names(\n node_names, pairwise_translation\n )\n return self._transfer_to(new_skeleton_tree)\n\n def keep_nodes_by_names(\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\n ) -> \"SkeletonState\":\n \"\"\" \n Keep a list of nodes and drop all other nodes from the skeleton and re-compute the local \n rotation to match the original joint position as much as possible. \n\n :param node_names: a list node names that specifies the nodes need to be dropped\n :type node_names: List of strings\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\n or not to re-estimate the local translation from the states (avg.)\n :type estimate_local_translation_from_states: boolean\n :rtype: SkeletonState\n \"\"\"\n return self.drop_nodes_by_names(\n list(filter(lambda x: (x not in node_names), self)),\n estimate_local_translation_from_states,\n )\n\n def _remapped_to(\n self, joint_mapping: Dict[str, str], target_skeleton_tree: SkeletonTree\n ):\n joint_mapping_inv = {target: source for source, target in joint_mapping.items()}\n reduced_target_skeleton_tree = target_skeleton_tree.keep_nodes_by_names(\n list(joint_mapping_inv)\n )\n n_joints = (\n len(joint_mapping),\n len(self.skeleton_tree),\n len(reduced_target_skeleton_tree),\n )\n assert (\n len(set(n_joints)) == 1\n ), \"the joint mapping is not consistent with the skeleton trees\"\n source_indices = list(\n map(\n lambda x: self.skeleton_tree.index(joint_mapping_inv[x]),\n reduced_target_skeleton_tree,\n )\n )\n target_local_rotation = self.local_rotation[..., source_indices, :]\n return SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=reduced_target_skeleton_tree,\n r=target_local_rotation,\n t=self.root_translation,\n is_local=True,\n )\n\n def retarget_to(\n self,\n joint_mapping: Dict[str, str],\n source_tpose_local_rotation,\n source_tpose_root_translation: np.ndarray,\n target_skeleton_tree: SkeletonTree,\n target_tpose_local_rotation,\n target_tpose_root_translation: np.ndarray,\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n z_up: bool = True,\n ) -> \"SkeletonState\":\n \"\"\" \n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\n implementation with rough approximations. The function follows the procedures below.\n\n Steps:\n 1. Drop the joints from the source (self) that do not belong to the joint mapping\\\n with an implementation that is similar to \"keep_nodes_by_names()\" - take a\\\n look at the function doc for more details (same for source_tpose)\n \n 2. Rotate the source state and the source tpose by \"rotation_to_target_skeleton\"\\\n to align the source with the target orientation\n \n 3. Extract the root translation and normalize it to match the scale of the target\\\n skeleton\n \n 4. Extract the global rotation from source state relative to source tpose and\\\n re-apply the relative rotation to the target tpose to construct the global\\\n rotation after retargetting\n \n 5. Combine the computed global rotation and the root translation from 3 and 4 to\\\n complete the retargeting.\n \n 6. Make feet on the ground (global translation z)\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose_local_rotation: the local rotation of the source skeleton\n :type source_tpose_local_rotation: Tensor\n \n :param source_tpose_root_translation: the root translation of the source tpose\n :type source_tpose_root_translation: np.ndarray\n \n :param target_skeleton_tree: the target skeleton tree\n :type target_skeleton_tree: SkeletonTree\n \n :param target_tpose_local_rotation: the local rotation of the target skeleton\n :type target_tpose_local_rotation: Tensor\n \n :param target_tpose_root_translation: the root translation of the target tpose\n :type target_tpose_root_translation: Tensor\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonState\n \"\"\"\n\n # STEP 0: Preprocess\n source_tpose = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=self.skeleton_tree,\n r=source_tpose_local_rotation,\n t=source_tpose_root_translation,\n is_local=True,\n )\n target_tpose = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=target_skeleton_tree,\n r=target_tpose_local_rotation,\n t=target_tpose_root_translation,\n is_local=True,\n )\n\n # STEP 1: Drop the irrelevant joints\n pairwise_translation = self._get_pairwise_average_translation()\n node_names = list(joint_mapping)\n new_skeleton_tree = self.skeleton_tree.keep_nodes_by_names(\n node_names, pairwise_translation\n )\n\n # TODO: combine the following steps before STEP 3\n source_tpose = source_tpose._transfer_to(new_skeleton_tree)\n source_state = self._transfer_to(new_skeleton_tree)\n\n source_tpose = source_tpose._remapped_to(joint_mapping, target_skeleton_tree)\n source_state = source_state._remapped_to(joint_mapping, target_skeleton_tree)\n\n # STEP 2: Rotate the source to align with the target\n new_local_rotation = source_tpose.local_rotation.clone()\n new_local_rotation[..., 0, :] = quat_mul_norm(\n rotation_to_target_skeleton, source_tpose.local_rotation[..., 0, :]\n )\n\n source_tpose = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=source_tpose.skeleton_tree,\n r=new_local_rotation,\n t=quat_rotate(rotation_to_target_skeleton, source_tpose.root_translation),\n is_local=True,\n )\n\n new_local_rotation = source_state.local_rotation.clone()\n new_local_rotation[..., 0, :] = quat_mul_norm(\n rotation_to_target_skeleton, source_state.local_rotation[..., 0, :]\n )\n source_state = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=source_state.skeleton_tree,\n r=new_local_rotation,\n t=quat_rotate(rotation_to_target_skeleton, source_state.root_translation),\n is_local=True,\n )\n\n # STEP 3: Normalize to match the target scale\n root_translation_diff = (\n source_state.root_translation - source_tpose.root_translation\n ) * scale_to_target_skeleton\n\n # STEP 4: the global rotation from source state relative to source tpose and\n # re-apply to the target\n current_skeleton_tree = source_state.skeleton_tree\n target_tpose_global_rotation = source_state.global_rotation[0, :].clone()\n for current_index, name in enumerate(current_skeleton_tree):\n if name in target_tpose.skeleton_tree:\n target_tpose_global_rotation[\n current_index, :\n ] = target_tpose.global_rotation[\n target_tpose.skeleton_tree.index(name), :\n ]\n\n global_rotation_diff = quat_mul_norm(\n source_state.global_rotation, quat_inverse(source_tpose.global_rotation)\n )\n new_global_rotation = quat_mul_norm(\n global_rotation_diff, target_tpose_global_rotation\n )\n\n # STEP 5: Putting 3 and 4 together\n current_skeleton_tree = source_state.skeleton_tree\n shape = source_state.global_rotation.shape[:-1]\n shape = shape[:-1] + target_tpose.global_rotation.shape[-2:-1]\n new_global_rotation_output = quat_identity(shape)\n for current_index, name in enumerate(target_skeleton_tree):\n while name not in current_skeleton_tree:\n name = target_skeleton_tree.parent_of(name)\n parent_index = current_skeleton_tree.index(name)\n new_global_rotation_output[:, current_index, :] = new_global_rotation[\n :, parent_index, :\n ]\n\n source_state = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=target_skeleton_tree,\n r=new_global_rotation_output,\n t=target_tpose.root_translation + root_translation_diff,\n is_local=False,\n ).local_repr()\n\n return source_state\n\n def retarget_to_by_tpose(\n self,\n joint_mapping: Dict[str, str],\n source_tpose: \"SkeletonState\",\n target_tpose: \"SkeletonState\",\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n ) -> \"SkeletonState\":\n \"\"\" \n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\n implementation with rough approximations. See the method `retarget_to()` for more information\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose: t-pose of the source skeleton\n :type source_tpose: SkeletonState\n \n :param target_tpose: t-pose of the target skeleton\n :type target_tpose: SkeletonState\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonState\n \"\"\"\n assert (\n len(source_tpose.shape) == 0 and len(target_tpose.shape) == 0\n ), \"the retargeting script currently doesn't support vectorized operations\"\n return self.retarget_to(\n joint_mapping,\n source_tpose.local_rotation,\n source_tpose.root_translation,\n target_tpose.skeleton_tree,\n target_tpose.local_rotation,\n target_tpose.root_translation,\n rotation_to_target_skeleton,\n scale_to_target_skeleton,\n )"},{"identifier":"SkeletonMotion","path":"poselib/poselib/skeleton/skeleton3d.py","snippet":"class SkeletonMotion(SkeletonState):\n def __init__(self, tensor_backend, skeleton_tree, is_local, fps, *args, **kwargs):\n self._fps = fps\n super().__init__(tensor_backend, skeleton_tree, is_local, *args, **kwargs)\n\n def clone(self):\n return SkeletonMotion(\n self.tensor.clone(), self.skeleton_tree, self._is_local, self._fps\n )\n\n @property\n def invariant_property(self):\n return {\n \"skeleton_tree\": self.skeleton_tree,\n \"is_local\": self.is_local,\n \"fps\": self.fps,\n }\n\n @property\n def global_velocity(self):\n \"\"\" global velocity \"\"\"\n curr_index = self.num_joints * 4 + 3\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\n )\n\n @property\n def global_angular_velocity(self):\n \"\"\" global angular velocity \"\"\"\n curr_index = self.num_joints * 7 + 3\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\n )\n\n @property\n def fps(self):\n \"\"\" number of frames per second \"\"\"\n return self._fps\n\n @property\n def time_delta(self):\n \"\"\" time between two adjacent frames \"\"\"\n return 1.0 / self.fps\n\n @property\n def global_root_velocity(self):\n \"\"\" global root velocity \"\"\"\n return self.global_velocity[..., 0, :]\n\n @property\n def global_root_angular_velocity(self):\n \"\"\" global root angular velocity \"\"\"\n return self.global_angular_velocity[..., 0, :]\n\n @classmethod\n def from_state_vector_and_velocity(\n cls,\n skeleton_tree,\n state_vector,\n global_velocity,\n global_angular_velocity,\n is_local,\n fps,\n ):\n \"\"\"\n Construct a skeleton motion from a skeleton state vector, global velocity and angular\n velocity at each joint.\n\n :param skeleton_tree: the skeleton tree that the motion is based on \n :type skeleton_tree: SkeletonTree\n :param state_vector: the state vector from the skeleton state by `.tensor`\n :type state_vector: Tensor\n :param global_velocity: the global velocity at each joint\n :type global_velocity: Tensor\n :param global_angular_velocity: the global angular velocity at each joint\n :type global_angular_velocity: Tensor\n :param is_local: if the rotation ins the state vector is given in local frame\n :type is_local: boolean\n :param fps: number of frames per second\n :type fps: int\n\n :rtype: SkeletonMotion\n \"\"\"\n state_shape = state_vector.shape[:-1]\n v = global_velocity.reshape(*(state_shape + (-1,)))\n av = global_angular_velocity.reshape(*(state_shape + (-1,)))\n new_state_vector = torch.cat([state_vector, v, av], axis=-1)\n return cls(\n new_state_vector, skeleton_tree=skeleton_tree, is_local=is_local, fps=fps,\n )\n\n @classmethod\n def from_skeleton_state(\n cls: Type[\"SkeletonMotion\"], skeleton_state: SkeletonState, fps: int\n ):\n \"\"\"\n Construct a skeleton motion from a skeleton state. The velocities are estimated using second\n order guassian filter along the last axis. The skeleton state must have at least .dim >= 1\n\n :param skeleton_state: the skeleton state that the motion is based on \n :type skeleton_state: SkeletonState\n :param fps: number of frames per second\n :type fps: int\n\n :rtype: SkeletonMotion\n \"\"\"\n assert (\n type(skeleton_state) == SkeletonState\n ), \"expected type of {}, got {}\".format(SkeletonState, type(skeleton_state))\n global_velocity = SkeletonMotion._compute_velocity(\n p=skeleton_state.global_translation, time_delta=1 / fps\n )\n global_angular_velocity = SkeletonMotion._compute_angular_velocity(\n r=skeleton_state.global_rotation, time_delta=1 / fps\n )\n return cls.from_state_vector_and_velocity(\n skeleton_tree=skeleton_state.skeleton_tree,\n state_vector=skeleton_state.tensor,\n global_velocity=global_velocity,\n global_angular_velocity=global_angular_velocity,\n is_local=skeleton_state.is_local,\n fps=fps,\n )\n\n @staticmethod\n def _to_state_vector(rot, rt, vel, avel):\n state_shape = rot.shape[:-2]\n skeleton_state_v = SkeletonState._to_state_vector(rot, rt)\n v = vel.reshape(*(state_shape + (-1,)))\n av = avel.reshape(*(state_shape + (-1,)))\n skeleton_motion_v = torch.cat([skeleton_state_v, v, av], axis=-1)\n return skeleton_motion_v\n\n @classmethod\n def from_dict(\n cls: Type[\"SkeletonMotion\"], dict_repr: OrderedDict, *args, **kwargs\n ) -> \"SkeletonMotion\":\n rot = TensorUtils.from_dict(dict_repr[\"rotation\"], *args, **kwargs)\n rt = TensorUtils.from_dict(dict_repr[\"root_translation\"], *args, **kwargs)\n vel = TensorUtils.from_dict(dict_repr[\"global_velocity\"], *args, **kwargs)\n avel = TensorUtils.from_dict(\n dict_repr[\"global_angular_velocity\"], *args, **kwargs\n )\n return cls(\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\n skeleton_tree=SkeletonTree.from_dict(\n dict_repr[\"skeleton_tree\"], *args, **kwargs\n ),\n is_local=dict_repr[\"is_local\"],\n fps=dict_repr[\"fps\"],\n )\n\n def to_dict(self) -> OrderedDict:\n return OrderedDict(\n [\n (\"rotation\", tensor_to_dict(self.rotation)),\n (\"root_translation\", tensor_to_dict(self.root_translation)),\n (\"global_velocity\", tensor_to_dict(self.global_velocity)),\n (\"global_angular_velocity\", tensor_to_dict(self.global_angular_velocity)),\n (\"skeleton_tree\", self.skeleton_tree.to_dict()),\n (\"is_local\", self.is_local),\n (\"fps\", self.fps),\n ]\n )\n\n @classmethod\n def from_fbx(\n cls: Type[\"SkeletonMotion\"],\n fbx_file_path,\n fbx_configs,\n skeleton_tree=None,\n is_local=True,\n fps=120,\n root_joint=\"\",\n root_trans_index=0,\n *args,\n **kwargs,\n ) -> \"SkeletonMotion\":\n \"\"\"\n Construct a skeleton motion from a fbx file (TODO - generalize this). If the skeleton tree\n is not given, it will use the first frame of the mocap to construct the skeleton tree.\n\n :param fbx_file_path: the path of the fbx file\n :type fbx_file_path: string\n :param fbx_configs: the configuration in terms of {\"tmp_path\": ..., \"fbx_py27_path\": ...}\n :type fbx_configs: dict\n :param skeleton_tree: the optional skeleton tree that the rotation will be applied to\n :type skeleton_tree: SkeletonTree, optional\n :param is_local: the state vector uses local or global rotation as the representation\n :type is_local: bool, optional, default=True\n :rtype: SkeletonMotion\n \"\"\"\n joint_names, joint_parents, transforms, fps = fbx_to_array(\n fbx_file_path, fbx_configs, root_joint, fps\n )\n # swap the last two axis to match the convention\n local_transform = euclidean_to_transform(\n transformation_matrix=torch.from_numpy(\n np.swapaxes(np.array(transforms), -1, -2),\n ).float()\n )\n local_rotation = transform_rotation(local_transform)\n root_translation = transform_translation(local_transform)[..., root_trans_index, :]\n joint_parents = torch.from_numpy(np.array(joint_parents)).int()\n\n if skeleton_tree is None:\n local_translation = transform_translation(local_transform).reshape(\n -1, len(joint_parents), 3\n )[0]\n skeleton_tree = SkeletonTree(joint_names, joint_parents, local_translation)\n skeleton_state = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree, r=local_rotation, t=root_translation, is_local=True\n )\n if not is_local:\n skeleton_state = skeleton_state.global_repr()\n return cls.from_skeleton_state(\n skeleton_state=skeleton_state, fps=fps\n )\n\n @staticmethod\n def _compute_velocity(p, time_delta, guassian_filter=True):\n velocity = torch.from_numpy(\n filters.gaussian_filter1d(\n np.gradient(p.numpy(), axis=-3), 2, axis=-3, mode=\"nearest\"\n )\n / time_delta,\n )\n return velocity\n\n @staticmethod\n def _compute_angular_velocity(r, time_delta: float, guassian_filter=True):\n # assume the second last dimension is the time axis\n diff_quat_data = quat_identity_like(r)\n diff_quat_data[..., :-1, :, :] = quat_mul_norm(\n r[..., 1:, :, :], quat_inverse(r[..., :-1, :, :])\n )\n diff_angle, diff_axis = quat_angle_axis(diff_quat_data)\n angular_velocity = diff_axis * diff_angle.unsqueeze(-1) / time_delta\n angular_velocity = torch.from_numpy(\n filters.gaussian_filter1d(\n angular_velocity.numpy(), 2, axis=-3, mode=\"nearest\"\n ),\n )\n return angular_velocity\n\n def crop(self, start: int, end: int, fps: Optional[int] = None):\n \"\"\"\n Crop the motion along its last axis. This is equivalent to performing a slicing on the\n object with [..., start: end: skip_every] where skip_every = old_fps / fps. Note that the\n new fps provided must be a factor of the original fps. \n\n :param start: the beginning frame index\n :type start: int\n :param end: the ending frame index\n :type end: int\n :param fps: number of frames per second in the output (if not given the original fps will be used)\n :type fps: int, optional\n :rtype: SkeletonMotion\n \"\"\"\n if fps is None:\n new_fps = int(self.fps)\n old_fps = int(self.fps)\n else:\n new_fps = int(fps)\n old_fps = int(self.fps)\n assert old_fps % fps == 0, (\n \"the resampling doesn't support fps with non-integer division \"\n \"from the original fps: {} => {}\".format(old_fps, fps)\n )\n skip_every = old_fps // new_fps\n s = slice(start, end, skip_every)\n z = self[..., s]\n\n rot = z.local_rotation if z.is_local else z.global_rotation\n rt = z.root_translation\n vel = z.global_velocity\n avel = z.global_angular_velocity\n return SkeletonMotion(\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\n skeleton_tree=z.skeleton_tree,\n is_local=z.is_local,\n fps=new_fps,\n )\n\n def retarget_to(\n self,\n joint_mapping: Dict[str, str],\n source_tpose_local_rotation,\n source_tpose_root_translation: np.ndarray,\n target_skeleton_tree: \"SkeletonTree\",\n target_tpose_local_rotation,\n target_tpose_root_translation: np.ndarray,\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n z_up: bool = True,\n ) -> \"SkeletonMotion\":\n \"\"\" \n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\n new retargetted motion.\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose_local_rotation: the local rotation of the source skeleton\n :type source_tpose_local_rotation: Tensor\n \n :param source_tpose_root_translation: the root translation of the source tpose\n :type source_tpose_root_translation: np.ndarray\n \n :param target_skeleton_tree: the target skeleton tree\n :type target_skeleton_tree: SkeletonTree\n \n :param target_tpose_local_rotation: the local rotation of the target skeleton\n :type target_tpose_local_rotation: Tensor\n \n :param target_tpose_root_translation: the root translation of the target tpose\n :type target_tpose_root_translation: Tensor\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonMotion\n \"\"\"\n return SkeletonMotion.from_skeleton_state(\n super().retarget_to(\n joint_mapping,\n source_tpose_local_rotation,\n source_tpose_root_translation,\n target_skeleton_tree,\n target_tpose_local_rotation,\n target_tpose_root_translation,\n rotation_to_target_skeleton,\n scale_to_target_skeleton,\n z_up,\n ),\n self.fps,\n )\n\n def retarget_to_by_tpose(\n self,\n joint_mapping: Dict[str, str],\n source_tpose: \"SkeletonState\",\n target_tpose: \"SkeletonState\",\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n z_up: bool = True,\n ) -> \"SkeletonMotion\":\n \"\"\" \n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\n new retargetted motion.\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose: t-pose of the source skeleton\n :type source_tpose: SkeletonState\n \n :param target_tpose: t-pose of the target skeleton\n :type target_tpose: SkeletonState\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonMotion\n \"\"\"\n return self.retarget_to(\n joint_mapping,\n source_tpose.local_rotation,\n source_tpose.root_translation,\n target_tpose.skeleton_tree,\n target_tpose.local_rotation,\n target_tpose.root_translation,\n rotation_to_target_skeleton,\n scale_to_target_skeleton,\n z_up,\n )"},{"identifier":"plot_skeleton_state","path":"poselib/poselib/visualization/common.py","snippet":"def plot_skeleton_state(skeleton_state, task_name=\"\"):\n \"\"\"\n Visualize a skeleton state\n\n :param skeleton_state:\n :param task_name:\n :type skeleton_state: SkeletonState\n :type task_name: string, optional\n \"\"\"\n logger.info(\"plotting {}\".format(task_name))\n task = Draw3DSkeletonState(task_name=task_name, skeleton_state=skeleton_state)\n plotter = Matplotlib3DPlotter(task)\n plotter.show()"},{"identifier":"plot_skeleton_motion_interactive","path":"poselib/poselib/visualization/common.py","snippet":"def plot_skeleton_motion_interactive(skeleton_motion, task_name=\"\"):\n \"\"\"\n Visualize a skeleton motion along its first dimension interactively.\n\n :param skeleton_motion:\n :param task_name:\n :type skeleton_motion: SkeletonMotion\n :type task_name: string, optional\n \"\"\"\n for _ in plot_skeleton_motion_interactive_base(skeleton_motion, task_name):\n pass"},{"identifier":"Matplotlib3DPlotter","path":"poselib/poselib/visualization/plt_plotter.py","snippet":"class Matplotlib3DPlotter(BasePlotter):\n _fig: plt.figure # plt figure\n _ax: p3.Axes3D # plt 3d axis\n # stores artist objects for each task (task name as the key)\n _artist_cache: Dict[str, Any]\n # callables for each task primitives\n _create_impl_callables: Dict[str, Callable]\n _update_impl_callables: Dict[str, Callable]\n\n def __init__(self, task: \"BasePlotterTask\") -> None:\n self._fig = plt.figure()\n self._ax = p3.Axes3D(self._fig)\n self._artist_cache = {}\n\n self._create_impl_callables = {\n \"Draw3DLines\": self._lines_create_impl,\n \"Draw3DDots\": self._dots_create_impl,\n \"Draw3DTrail\": self._trail_create_impl,\n }\n self._update_impl_callables = {\n \"Draw3DLines\": self._lines_update_impl,\n \"Draw3DDots\": self._dots_update_impl,\n \"Draw3DTrail\": self._trail_update_impl,\n }\n self._init_lim()\n super().__init__(task)\n\n @property\n def ax(self):\n return self._ax\n\n @property\n def fig(self):\n return self._fig\n\n def show(self):\n plt.show()\n\n def _min(self, x, y):\n if x is None:\n return y\n if y is None:\n return x\n return min(x, y)\n\n def _max(self, x, y):\n if x is None:\n return y\n if y is None:\n return x\n return max(x, y)\n\n def _init_lim(self):\n self._curr_x_min = None\n self._curr_y_min = None\n self._curr_z_min = None\n self._curr_x_max = None\n self._curr_y_max = None\n self._curr_z_max = None\n\n def _update_lim(self, xs, ys, zs):\n self._curr_x_min = self._min(np.min(xs), self._curr_x_min)\n self._curr_y_min = self._min(np.min(ys), self._curr_y_min)\n self._curr_z_min = self._min(np.min(zs), self._curr_z_min)\n self._curr_x_max = self._max(np.max(xs), self._curr_x_max)\n self._curr_y_max = self._max(np.max(ys), self._curr_y_max)\n self._curr_z_max = self._max(np.max(zs), self._curr_z_max)\n\n def _set_lim(self):\n if not (\n self._curr_x_min is None\n or self._curr_x_max is None\n or self._curr_y_min is None\n or self._curr_y_max is None\n or self._curr_z_min is None\n or self._curr_z_max is None\n ):\n self._ax.set_xlim3d(self._curr_x_min, self._curr_x_max)\n self._ax.set_ylim3d(self._curr_y_min, self._curr_y_max)\n self._ax.set_zlim3d(self._curr_z_min, self._curr_z_max)\n self._init_lim()\n\n @staticmethod\n def _lines_extract_xyz_impl(index, lines_task):\n return lines_task[index, :, 0], lines_task[index, :, 1], lines_task[index, :, 2]\n\n @staticmethod\n def _trail_extract_xyz_impl(index, trail_task):\n return (\n trail_task[index : index + 2, 0],\n trail_task[index : index + 2, 1],\n trail_task[index : index + 2, 2],\n )\n\n def _lines_create_impl(self, lines_task):\n color = lines_task.color\n self._artist_cache[lines_task.task_name] = [\n self._ax.plot(\n *Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task),\n color=color,\n linewidth=lines_task.line_width,\n alpha=lines_task.alpha\n )[0]\n for i in range(len(lines_task))\n ]\n\n def _lines_update_impl(self, lines_task):\n lines_artists = self._artist_cache[lines_task.task_name]\n for i in range(len(lines_task)):\n artist = lines_artists[i]\n xs, ys, zs = Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task)\n artist.set_data(xs, ys)\n artist.set_3d_properties(zs)\n if lines_task.influence_lim:\n self._update_lim(xs, ys, zs)\n\n def _dots_create_impl(self, dots_task):\n color = dots_task.color\n self._artist_cache[dots_task.task_name] = self._ax.plot(\n dots_task[:, 0],\n dots_task[:, 1],\n dots_task[:, 2],\n c=color,\n linestyle=\"\",\n marker=\".\",\n markersize=dots_task.marker_size,\n alpha=dots_task.alpha,\n )[0]\n\n def _dots_update_impl(self, dots_task):\n dots_artist = self._artist_cache[dots_task.task_name]\n dots_artist.set_data(dots_task[:, 0], dots_task[:, 1])\n dots_artist.set_3d_properties(dots_task[:, 2])\n if dots_task.influence_lim:\n self._update_lim(dots_task[:, 0], dots_task[:, 1], dots_task[:, 2])\n\n def _trail_create_impl(self, trail_task):\n color = trail_task.color\n trail_length = len(trail_task) - 1\n self._artist_cache[trail_task.task_name] = [\n self._ax.plot(\n *Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task),\n color=trail_task.color,\n linewidth=trail_task.line_width,\n alpha=trail_task.alpha * (1.0 - i / (trail_length - 1))\n )[0]\n for i in range(trail_length)\n ]\n\n def _trail_update_impl(self, trail_task):\n trails_artists = self._artist_cache[trail_task.task_name]\n for i in range(len(trail_task) - 1):\n artist = trails_artists[i]\n xs, ys, zs = Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task)\n artist.set_data(xs, ys)\n artist.set_3d_properties(zs)\n if trail_task.influence_lim:\n self._update_lim(xs, ys, zs)\n\n def _create_impl(self, task_list):\n for task in task_list:\n self._create_impl_callables[task.task_type](task)\n self._draw()\n\n def _update_impl(self, task_list):\n for task in task_list:\n self._update_impl_callables[task.task_type](task)\n self._draw()\n\n def _set_aspect_equal_3d(self):\n xlim = self._ax.get_xlim3d()\n ylim = self._ax.get_ylim3d()\n zlim = self._ax.get_zlim3d()\n\n xmean = np.mean(xlim)\n ymean = np.mean(ylim)\n zmean = np.mean(zlim)\n\n plot_radius = max(\n [\n abs(lim - mean_)\n for lims, mean_ in ((xlim, xmean), (ylim, ymean), (zlim, zmean))\n for lim in lims\n ]\n )\n\n self._ax.set_xlim3d([xmean - plot_radius, xmean + plot_radius])\n self._ax.set_ylim3d([ymean - plot_radius, ymean + plot_radius])\n self._ax.set_zlim3d([zmean - plot_radius, zmean + plot_radius])\n\n def _draw(self):\n self._set_lim()\n self._set_aspect_equal_3d()\n self._fig.canvas.draw()\n self._fig.canvas.flush_events()\n plt.pause(0.00001)"},{"identifier":"Draw3DSkeletonMotion","path":"poselib/poselib/visualization/skeleton_plotter_tasks.py","snippet":"class Draw3DSkeletonMotion(BasePlotterTask):\n def __init__(\n self,\n task_name: str,\n skeleton_motion,\n frame_index=None,\n joints_color=\"red\",\n lines_color=\"blue\",\n velocity_color=\"green\",\n angular_velocity_color=\"purple\",\n trail_color=\"black\",\n trail_length=10,\n alpha=1.0,\n ) -> None:\n super().__init__(task_name=task_name, task_type=\"3DSkeletonMotion\")\n self._trail_length = trail_length\n self._skeleton_motion = skeleton_motion\n # if frame_index is None:\n curr_skeleton_motion = self._skeleton_motion.clone()\n if frame_index is not None:\n curr_skeleton_motion.tensor = self._skeleton_motion.tensor[frame_index, :]\n # else:\n # curr_skeleton_motion = self._skeleton_motion[frame_index, :]\n self._skeleton_state_task = Draw3DSkeletonState(\n self.get_scoped_name(\"skeleton_state\"),\n curr_skeleton_motion,\n joints_color=joints_color,\n lines_color=lines_color,\n alpha=alpha,\n )\n vel_lines, avel_lines = Draw3DSkeletonMotion._get_vel_and_avel(\n curr_skeleton_motion\n )\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\n np.newaxis, ...\n ].repeat(trail_length, axis=0)\n self._vel_task = Draw3DLines(\n self.get_scoped_name(\"velocity\"),\n vel_lines,\n velocity_color,\n influence_lim=False,\n alpha=alpha,\n )\n self._avel_task = Draw3DLines(\n self.get_scoped_name(\"angular_velocity\"),\n avel_lines,\n angular_velocity_color,\n influence_lim=False,\n alpha=alpha,\n )\n self._com_trail_task = Draw3DTrail(\n self.get_scoped_name(\"com_trail\"),\n self._com_pos,\n trail_color,\n marker_size=2,\n influence_lim=True,\n alpha=alpha,\n )\n\n @property\n def name(self):\n return \"3DSkeletonMotion\"\n\n def update(self, frame_index=None, reset_trail=False, skeleton_motion=None) -> None:\n if skeleton_motion is not None:\n self._skeleton_motion = skeleton_motion\n\n curr_skeleton_motion = self._skeleton_motion.clone()\n if frame_index is not None:\n curr_skeleton_motion.tensor = curr_skeleton_motion.tensor[frame_index, :]\n if reset_trail:\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\n np.newaxis, ...\n ].repeat(self._trail_length, axis=0)\n else:\n self._com_pos = np.concatenate(\n (\n curr_skeleton_motion.root_translation.numpy()[np.newaxis, ...],\n self._com_pos[:-1],\n ),\n axis=0,\n )\n self._skeleton_state_task.update(curr_skeleton_motion)\n self._com_trail_task.update(self._com_pos)\n self._update(*Draw3DSkeletonMotion._get_vel_and_avel(curr_skeleton_motion))\n\n @staticmethod\n def _get_vel_and_avel(skeleton_motion):\n \"\"\"Get all the velocity and angular velocity lines\n \"\"\"\n pos = skeleton_motion.global_translation.numpy()\n vel = skeleton_motion.global_velocity.numpy()\n avel = skeleton_motion.global_angular_velocity.numpy()\n\n vel_lines = np.stack((pos, pos + vel * 0.02), axis=1)\n avel_lines = np.stack((pos, pos + avel * 0.01), axis=1)\n return vel_lines, avel_lines\n\n def _update(self, vel_lines, avel_lines) -> None:\n self._vel_task.update(vel_lines)\n self._avel_task.update(avel_lines)\n\n def __iter__(self):\n yield from self._skeleton_state_task\n yield from self._vel_task\n yield from self._avel_task\n yield from self._com_trail_task"},{"identifier":"Draw3DSkeletonState","path":"poselib/poselib/visualization/skeleton_plotter_tasks.py","snippet":"class Draw3DSkeletonState(BasePlotterTask):\n _lines_task: Draw3DLines # sub-task for drawing lines\n _dots_task: Draw3DDots # sub-task for drawing dots\n\n def __init__(\n self,\n task_name: str,\n skeleton_state,\n joints_color: str = \"red\",\n lines_color: str = \"blue\",\n alpha=1.0,\n ) -> None:\n super().__init__(task_name=task_name, task_type=\"3DSkeletonState\")\n lines, dots = Draw3DSkeletonState._get_lines_and_dots(skeleton_state)\n self._lines_task = Draw3DLines(\n self.get_scoped_name(\"bodies\"), lines, joints_color, alpha=alpha\n )\n self._dots_task = Draw3DDots(\n self.get_scoped_name(\"joints\"), dots, lines_color, alpha=alpha\n )\n\n @property\n def name(self):\n return \"3DSkeleton\"\n\n def update(self, skeleton_state) -> None:\n self._update(*Draw3DSkeletonState._get_lines_and_dots(skeleton_state))\n\n @staticmethod\n def _get_lines_and_dots(skeleton_state):\n \"\"\"Get all the lines and dots needed to draw the skeleton state\n \"\"\"\n assert (\n len(skeleton_state.tensor.shape) == 1\n ), \"the state has to be zero dimensional\"\n dots = skeleton_state.global_translation.numpy()\n skeleton_tree = skeleton_state.skeleton_tree\n parent_indices = skeleton_tree.parent_indices.numpy()\n lines = []\n for node_index in range(len(skeleton_tree)):\n parent_index = parent_indices[node_index]\n if parent_index != -1:\n lines.append([dots[node_index], dots[parent_index]])\n lines = np.array(lines)\n return lines, dots\n\n def _update(self, lines, dots) -> None:\n self._lines_task.update(lines)\n self._dots_task.update(dots)\n\n def __iter__(self):\n yield from self._lines_task\n yield from self._dots_task"}],"string":"[\n {\n \"identifier\": \"SkeletonTree\",\n \"path\": \"poselib/poselib/skeleton/skeleton3d.py\",\n \"snippet\": \"class SkeletonTree(Serializable):\\n \\\"\\\"\\\"\\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\\n over a list of nodes with their names indicated by strings. Each edge in the tree has a local\\n translation associated with it which describes the distance between the two nodes that it\\n connects. \\n\\n Basic Usage:\\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\\n >>> t\\n SkeletonTree(\\n node_names=['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot'],\\n parent_indices=tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11]),\\n local_translation=tensor([[ 0.0000, 0.0000, 0.7500],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000]])\\n )\\n >>> t.node_names\\n ['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot']\\n >>> t.parent_indices\\n tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11])\\n >>> t.local_translation\\n tensor([[ 0.0000, 0.0000, 0.7500],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000]])\\n >>> t.parent_of('front_left_leg')\\n 'torso'\\n >>> t.index('front_right_foot')\\n 6\\n >>> t[2]\\n 'aux_1'\\n \\\"\\\"\\\"\\n\\n __example_mjcf_path__ = os.path.join(\\n os.path.dirname(os.path.realpath(__file__)), \\\"tests/ant.xml\\\"\\n )\\n\\n def __init__(self, node_names, parent_indices, local_translation):\\n \\\"\\\"\\\"\\n :param node_names: a list of names for each tree node\\n :type node_names: List[str]\\n :param parent_indices: an int32-typed tensor that represents the edge to its parent.\\\\\\n -1 represents the root node\\n :type parent_indices: Tensor\\n :param local_translation: a 3d vector that gives local translation information\\n :type local_translation: Tensor\\n \\\"\\\"\\\"\\n ln, lp, ll = len(node_names), len(parent_indices), len(local_translation)\\n assert len(set((ln, lp, ll))) == 1\\n self._node_names = node_names\\n self._parent_indices = parent_indices.long()\\n self._local_translation = local_translation\\n self._node_indices = {self.node_names[i]: i for i in range(len(self))}\\n\\n def __len__(self):\\n \\\"\\\"\\\" number of nodes in the skeleton tree \\\"\\\"\\\"\\n return len(self.node_names)\\n\\n def __iter__(self):\\n \\\"\\\"\\\" iterator that iterate through the name of each node \\\"\\\"\\\"\\n yield from self.node_names\\n\\n def __getitem__(self, item):\\n \\\"\\\"\\\" get the name of the node given the index \\\"\\\"\\\"\\n return self.node_names[item]\\n\\n def __repr__(self):\\n return (\\n \\\"SkeletonTree(\\\\n node_names={},\\\\n parent_indices={},\\\"\\n \\\"\\\\n local_translation={}\\\\n)\\\".format(\\n self._indent(repr(self.node_names)),\\n self._indent(repr(self.parent_indices)),\\n self._indent(repr(self.local_translation)),\\n )\\n )\\n\\n def _indent(self, s):\\n return \\\"\\\\n \\\".join(s.split(\\\"\\\\n\\\"))\\n\\n @property\\n def node_names(self):\\n return self._node_names\\n\\n @property\\n def parent_indices(self):\\n return self._parent_indices\\n\\n @property\\n def local_translation(self):\\n return self._local_translation\\n\\n @property\\n def num_joints(self):\\n \\\"\\\"\\\" number of nodes in the skeleton tree \\\"\\\"\\\"\\n return len(self)\\n\\n @classmethod\\n def from_dict(cls, dict_repr, *args, **kwargs):\\n return cls(\\n list(map(str, dict_repr[\\\"node_names\\\"])),\\n TensorUtils.from_dict(dict_repr[\\\"parent_indices\\\"], *args, **kwargs),\\n TensorUtils.from_dict(dict_repr[\\\"local_translation\\\"], *args, **kwargs),\\n )\\n\\n def to_dict(self):\\n return OrderedDict(\\n [\\n (\\\"node_names\\\", self.node_names),\\n (\\\"parent_indices\\\", tensor_to_dict(self.parent_indices)),\\n (\\\"local_translation\\\", tensor_to_dict(self.local_translation)),\\n ]\\n )\\n\\n @classmethod\\n def from_mjcf(cls, path: str) -> \\\"SkeletonTree\\\":\\n \\\"\\\"\\\"\\n Parses a mujoco xml scene description file and returns a Skeleton Tree.\\n We use the model attribute at the root as the name of the tree.\\n \\n :param path:\\n :type path: string\\n :return: The skeleton tree constructed from the mjcf file\\n :rtype: SkeletonTree\\n \\\"\\\"\\\"\\n tree = ET.parse(path)\\n xml_doc_root = tree.getroot()\\n xml_world_body = xml_doc_root.find(\\\"worldbody\\\")\\n if xml_world_body is None:\\n raise ValueError(\\\"MJCF parsed incorrectly please verify it.\\\")\\n # assume this is the root\\n xml_body_root = xml_world_body.find(\\\"body\\\")\\n if xml_body_root is None:\\n raise ValueError(\\\"MJCF parsed incorrectly please verify it.\\\")\\n\\n node_names = []\\n parent_indices = []\\n local_translation = []\\n\\n # recursively adding all nodes into the skel_tree\\n def _add_xml_node(xml_node, parent_index, node_index):\\n node_name = xml_node.attrib.get(\\\"name\\\")\\n # parse the local translation into float list\\n pos = np.fromstring(xml_node.attrib.get(\\\"pos\\\"), dtype=float, sep=\\\" \\\")\\n node_names.append(node_name)\\n parent_indices.append(parent_index)\\n local_translation.append(pos)\\n curr_index = node_index\\n node_index += 1\\n for next_node in xml_node.findall(\\\"body\\\"):\\n node_index = _add_xml_node(next_node, curr_index, node_index)\\n return node_index\\n\\n _add_xml_node(xml_body_root, -1, 0)\\n\\n return cls(\\n node_names,\\n torch.from_numpy(np.array(parent_indices, dtype=np.int32)),\\n torch.from_numpy(np.array(local_translation, dtype=np.float32)),\\n )\\n\\n def parent_of(self, node_name):\\n \\\"\\\"\\\" get the name of the parent of the given node\\n\\n :param node_name: the name of the node\\n :type node_name: string\\n :rtype: string\\n \\\"\\\"\\\"\\n return self[int(self.parent_indices[self.index(node_name)].item())]\\n\\n def index(self, node_name):\\n \\\"\\\"\\\" get the index of the node\\n \\n :param node_name: the name of the node\\n :type node_name: string\\n :rtype: int\\n \\\"\\\"\\\"\\n return self._node_indices[node_name]\\n\\n def drop_nodes_by_names(\\n self, node_names: List[str], pairwise_translation=None\\n ) -> \\\"SkeletonTree\\\":\\n new_length = len(self) - len(node_names)\\n new_node_names = []\\n new_local_translation = torch.zeros(\\n new_length, 3, dtype=self.local_translation.dtype\\n )\\n new_parent_indices = torch.zeros(new_length, dtype=self.parent_indices.dtype)\\n parent_indices = self.parent_indices.numpy()\\n new_node_indices: dict = {}\\n new_node_index = 0\\n for node_index in range(len(self)):\\n if self[node_index] in node_names:\\n continue\\n tb_node_index = parent_indices[node_index]\\n if tb_node_index != -1:\\n local_translation = self.local_translation[node_index, :]\\n while tb_node_index != -1 and self[tb_node_index] in node_names:\\n local_translation += self.local_translation[tb_node_index, :]\\n tb_node_index = parent_indices[tb_node_index]\\n assert tb_node_index != -1, \\\"the root node cannot be dropped\\\"\\n\\n if pairwise_translation is not None:\\n local_translation = pairwise_translation[\\n tb_node_index, node_index, :\\n ]\\n else:\\n local_translation = self.local_translation[node_index, :]\\n\\n new_node_names.append(self[node_index])\\n new_local_translation[new_node_index, :] = local_translation\\n if tb_node_index == -1:\\n new_parent_indices[new_node_index] = -1\\n else:\\n new_parent_indices[new_node_index] = new_node_indices[\\n self[tb_node_index]\\n ]\\n new_node_indices[self[node_index]] = new_node_index\\n new_node_index += 1\\n\\n return SkeletonTree(new_node_names, new_parent_indices, new_local_translation)\\n\\n def keep_nodes_by_names(\\n self, node_names: List[str], pairwise_translation=None\\n ) -> \\\"SkeletonTree\\\":\\n nodes_to_drop = list(filter(lambda x: x not in node_names, self))\\n return self.drop_nodes_by_names(nodes_to_drop, pairwise_translation)\"\n },\n {\n \"identifier\": \"SkeletonState\",\n \"path\": \"poselib/poselib/skeleton/skeleton3d.py\",\n \"snippet\": \"class SkeletonState(Serializable):\\n \\\"\\\"\\\"\\n A skeleton state contains all the information needed to describe a static state of a skeleton.\\n It requires a skeleton tree, local/global rotation at each joint and the root translation.\\n\\n Example:\\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\\n >>> zero_pose = SkeletonState.zero_pose(t)\\n >>> plot_skeleton_state(zero_pose) # can be imported from `.visualization.common`\\n [plot of the ant at zero pose\\n >>> local_rotation = zero_pose.local_rotation.clone()\\n >>> local_rotation[2] = torch.tensor([0, 0, 1, 0])\\n >>> new_pose = SkeletonState.from_rotation_and_root_translation(\\n ... skeleton_tree=t,\\n ... r=local_rotation,\\n ... t=zero_pose.root_translation,\\n ... is_local=True\\n ... )\\n >>> new_pose.local_rotation\\n tensor([[0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 1., 0., 0.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.]])\\n >>> plot_skeleton_state(new_pose) # you should be able to see one of ant's leg is bent\\n [plot of the ant with the new pose\\n >>> new_pose.global_rotation # the local rotation is propagated to the global rotation at joint #3\\n tensor([[0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 1., 0., 0.],\\n [0., 1., 0., 0.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.]])\\n\\n Global/Local Representation (cont. from the previous example)\\n >>> new_pose.is_local\\n True\\n >>> new_pose.tensor # this will return the local rotation followed by the root translation\\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0.,\\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\\n 0.])\\n >>> new_pose.tensor.shape # 4 * 13 (joint rotation) + 3 (root translatio\\n torch.Size([55])\\n >>> new_pose.global_repr().is_local\\n False\\n >>> new_pose.global_repr().tensor # this will return the global rotation followed by the root translation instead\\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0.,\\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\\n 0.])\\n >>> new_pose.global_repr().tensor.shape # 4 * 13 (joint rotation) + 3 (root translation\\n torch.Size([55])\\n \\\"\\\"\\\"\\n\\n def __init__(self, tensor_backend, skeleton_tree, is_local):\\n self._skeleton_tree = skeleton_tree\\n self._is_local = is_local\\n self.tensor = tensor_backend.clone()\\n\\n def __len__(self):\\n return self.tensor.shape[0]\\n\\n @property\\n def rotation(self):\\n if not hasattr(self, \\\"_rotation\\\"):\\n self._rotation = self.tensor[..., : self.num_joints * 4].reshape(\\n *(self.tensor.shape[:-1] + (self.num_joints, 4))\\n )\\n return self._rotation\\n\\n @property\\n def _local_rotation(self):\\n if self._is_local:\\n return self.rotation\\n else:\\n return None\\n\\n @property\\n def _global_rotation(self):\\n if not self._is_local:\\n return self.rotation\\n else:\\n return None\\n\\n @property\\n def is_local(self):\\n \\\"\\\"\\\" is the rotation represented in local frame? \\n \\n :rtype: bool\\n \\\"\\\"\\\"\\n return self._is_local\\n\\n @property\\n def invariant_property(self):\\n return {\\\"skeleton_tree\\\": self.skeleton_tree, \\\"is_local\\\": self.is_local}\\n\\n @property\\n def num_joints(self):\\n \\\"\\\"\\\" number of joints in the skeleton tree \\n \\n :rtype: int\\n \\\"\\\"\\\"\\n return self.skeleton_tree.num_joints\\n\\n @property\\n def skeleton_tree(self):\\n \\\"\\\"\\\" skeleton tree \\n \\n :rtype: SkeletonTree\\n \\\"\\\"\\\"\\n return self._skeleton_tree\\n\\n @property\\n def root_translation(self):\\n \\\"\\\"\\\" root translation \\n \\n :rtype: Tensor\\n \\\"\\\"\\\"\\n if not hasattr(self, \\\"_root_translation\\\"):\\n self._root_translation = self.tensor[\\n ..., self.num_joints * 4 : self.num_joints * 4 + 3\\n ]\\n return self._root_translation\\n\\n @property\\n def global_transformation(self):\\n \\\"\\\"\\\" global transformation of each joint (transform from joint frame to global frame) \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_transformation\\\"):\\n local_transformation = self.local_transformation\\n global_transformation = []\\n parent_indices = self.skeleton_tree.parent_indices.numpy()\\n # global_transformation = local_transformation.identity_like()\\n for node_index in range(len(self.skeleton_tree)):\\n parent_index = parent_indices[node_index]\\n if parent_index == -1:\\n global_transformation.append(\\n local_transformation[..., node_index, :]\\n )\\n else:\\n global_transformation.append(\\n transform_mul(\\n global_transformation[parent_index],\\n local_transformation[..., node_index, :],\\n )\\n )\\n self._global_transformation = torch.stack(global_transformation, axis=-2)\\n return self._global_transformation\\n\\n @property\\n def global_rotation(self):\\n \\\"\\\"\\\" global rotation of each joint (rotation matrix to rotate from joint's F.O.R to global\\n F.O.R) \\\"\\\"\\\"\\n if self._global_rotation is None:\\n if not hasattr(self, \\\"_comp_global_rotation\\\"):\\n self._comp_global_rotation = transform_rotation(\\n self.global_transformation\\n )\\n return self._comp_global_rotation\\n else:\\n return self._global_rotation\\n\\n @property\\n def global_translation(self):\\n \\\"\\\"\\\" global translation of each joint \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_translation\\\"):\\n self._global_translation = transform_translation(self.global_transformation)\\n return self._global_translation\\n\\n @property\\n def global_translation_xy(self):\\n \\\"\\\"\\\" global translation in xy \\\"\\\"\\\"\\n trans_xy_data = self.global_translation.zeros_like()\\n trans_xy_data[..., 0:2] = self.global_translation[..., 0:2]\\n return trans_xy_data\\n\\n @property\\n def global_translation_xz(self):\\n \\\"\\\"\\\" global translation in xz \\\"\\\"\\\"\\n trans_xz_data = self.global_translation.zeros_like()\\n trans_xz_data[..., 0:1] = self.global_translation[..., 0:1]\\n trans_xz_data[..., 2:3] = self.global_translation[..., 2:3]\\n return trans_xz_data\\n\\n @property\\n def local_rotation(self):\\n \\\"\\\"\\\" the rotation from child frame to parent frame given in the order of child nodes appeared\\n in `.skeleton_tree.node_names` \\\"\\\"\\\"\\n if self._local_rotation is None:\\n if not hasattr(self, \\\"_comp_local_rotation\\\"):\\n local_rotation = quat_identity_like(self.global_rotation)\\n for node_index in range(len(self.skeleton_tree)):\\n parent_index = self.skeleton_tree.parent_indices[node_index]\\n if parent_index == -1:\\n local_rotation[..., node_index, :] = self.global_rotation[\\n ..., node_index, :\\n ]\\n else:\\n local_rotation[..., node_index, :] = quat_mul_norm(\\n quat_inverse(self.global_rotation[..., parent_index, :]),\\n self.global_rotation[..., node_index, :],\\n )\\n self._comp_local_rotation = local_rotation\\n return self._comp_local_rotation\\n else:\\n return self._local_rotation\\n\\n @property\\n def local_transformation(self):\\n \\\"\\\"\\\" local translation + local rotation. It describes the transformation from child frame to \\n parent frame given in the order of child nodes appeared in `.skeleton_tree.node_names` \\\"\\\"\\\"\\n if not hasattr(self, \\\"_local_transformation\\\"):\\n self._local_transformation = transform_from_rotation_translation(\\n r=self.local_rotation, t=self.local_translation\\n )\\n return self._local_transformation\\n\\n @property\\n def local_translation(self):\\n \\\"\\\"\\\" local translation of the skeleton state. It is identical to the local translation in\\n `.skeleton_tree.local_translation` except the root translation. The root translation is\\n identical to `.root_translation` \\\"\\\"\\\"\\n if not hasattr(self, \\\"_local_translation\\\"):\\n broadcast_shape = (\\n tuple(self.tensor.shape[:-1])\\n + (len(self.skeleton_tree),)\\n + tuple(self.skeleton_tree.local_translation.shape[-1:])\\n )\\n local_translation = self.skeleton_tree.local_translation.broadcast_to(\\n *broadcast_shape\\n ).clone()\\n local_translation[..., 0, :] = self.root_translation\\n self._local_translation = local_translation\\n return self._local_translation\\n\\n # Root Properties\\n @property\\n def root_translation_xy(self):\\n \\\"\\\"\\\" root translation on xy \\\"\\\"\\\"\\n if not hasattr(self, \\\"_root_translation_xy\\\"):\\n self._root_translation_xy = self.global_translation_xy[..., 0, :]\\n return self._root_translation_xy\\n\\n @property\\n def global_root_rotation(self):\\n \\\"\\\"\\\" root rotation \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_root_rotation\\\"):\\n self._global_root_rotation = self.global_rotation[..., 0, :]\\n return self._global_root_rotation\\n\\n @property\\n def global_root_yaw_rotation(self):\\n \\\"\\\"\\\" root yaw rotation \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_root_yaw_rotation\\\"):\\n self._global_root_yaw_rotation = self.global_root_rotation.yaw_rotation()\\n return self._global_root_yaw_rotation\\n\\n # Properties relative to root\\n @property\\n def local_translation_to_root(self):\\n \\\"\\\"\\\" The 3D translation from joint frame to the root frame. \\\"\\\"\\\"\\n if not hasattr(self, \\\"_local_translation_to_root\\\"):\\n self._local_translation_to_root = (\\n self.global_translation - self.root_translation.unsqueeze(-1)\\n )\\n return self._local_translation_to_root\\n\\n @property\\n def local_rotation_to_root(self):\\n \\\"\\\"\\\" The 3D rotation from joint frame to the root frame. It is equivalent to \\n The root_R_world * world_R_node \\\"\\\"\\\"\\n return (\\n quat_inverse(self.global_root_rotation).unsqueeze(-1) * self.global_rotation\\n )\\n\\n def compute_forward_vector(\\n self,\\n left_shoulder_index,\\n right_shoulder_index,\\n left_hip_index,\\n right_hip_index,\\n gaussian_filter_width=20,\\n ):\\n \\\"\\\"\\\" Computes forward vector based on cross product of the up vector with \\n average of the right->left shoulder and hip vectors \\\"\\\"\\\"\\n global_positions = self.global_translation\\n # Perpendicular to the forward direction.\\n # Uses the shoulders and hips to find this.\\n side_direction = (\\n global_positions[:, left_shoulder_index].numpy()\\n - global_positions[:, right_shoulder_index].numpy()\\n + global_positions[:, left_hip_index].numpy()\\n - global_positions[:, right_hip_index].numpy()\\n )\\n side_direction = (\\n side_direction\\n / np.sqrt((side_direction ** 2).sum(axis=-1))[..., np.newaxis]\\n )\\n\\n # Forward direction obtained by crossing with the up direction.\\n forward_direction = np.cross(side_direction, np.array([[0, 1, 0]]))\\n\\n # Smooth the forward direction with a Gaussian.\\n # Axis 0 is the time/frame axis.\\n forward_direction = filters.gaussian_filter1d(\\n forward_direction, gaussian_filter_width, axis=0, mode=\\\"nearest\\\"\\n )\\n forward_direction = (\\n forward_direction\\n / np.sqrt((forward_direction ** 2).sum(axis=-1))[..., np.newaxis]\\n )\\n\\n return torch.from_numpy(forward_direction)\\n\\n @staticmethod\\n def _to_state_vector(rot, rt):\\n state_shape = rot.shape[:-2]\\n vr = rot.reshape(*(state_shape + (-1,)))\\n vt = rt.broadcast_to(*state_shape + rt.shape[-1:]).reshape(\\n *(state_shape + (-1,))\\n )\\n v = torch.cat([vr, vt], axis=-1)\\n return v\\n\\n @classmethod\\n def from_dict(\\n cls: Type[\\\"SkeletonState\\\"], dict_repr: OrderedDict, *args, **kwargs\\n ) -> \\\"SkeletonState\\\":\\n rot = TensorUtils.from_dict(dict_repr[\\\"rotation\\\"], *args, **kwargs)\\n rt = TensorUtils.from_dict(dict_repr[\\\"root_translation\\\"], *args, **kwargs)\\n return cls(\\n SkeletonState._to_state_vector(rot, rt),\\n SkeletonTree.from_dict(dict_repr[\\\"skeleton_tree\\\"], *args, **kwargs),\\n dict_repr[\\\"is_local\\\"],\\n )\\n\\n def to_dict(self) -> OrderedDict:\\n return OrderedDict(\\n [\\n (\\\"rotation\\\", tensor_to_dict(self.rotation)),\\n (\\\"root_translation\\\", tensor_to_dict(self.root_translation)),\\n (\\\"skeleton_tree\\\", self.skeleton_tree.to_dict()),\\n (\\\"is_local\\\", self.is_local),\\n ]\\n )\\n\\n @classmethod\\n def from_rotation_and_root_translation(cls, skeleton_tree, r, t, is_local=True):\\n \\\"\\\"\\\"\\n Construct a skeleton state from rotation and root translation\\n\\n :param skeleton_tree: the skeleton tree\\n :type skeleton_tree: SkeletonTree\\n :param r: rotation (either global or local)\\n :type r: Tensor\\n :param t: root translation\\n :type t: Tensor\\n :param is_local: to indicate that whether the rotation is local or global\\n :type is_local: bool, optional, default=True\\n \\\"\\\"\\\"\\n assert (\\n r.dim() > 0\\n ), \\\"the rotation needs to have at least 1 dimension (dim = {})\\\".format(r.dim)\\n return cls(\\n SkeletonState._to_state_vector(r, t),\\n skeleton_tree=skeleton_tree,\\n is_local=is_local,\\n )\\n\\n @classmethod\\n def zero_pose(cls, skeleton_tree):\\n \\\"\\\"\\\"\\n Construct a zero-pose skeleton state from the skeleton tree by assuming that all the local\\n rotation is 0 and root translation is also 0.\\n\\n :param skeleton_tree: the skeleton tree as the rigid body\\n :type skeleton_tree: SkeletonTree\\n \\\"\\\"\\\"\\n return cls.from_rotation_and_root_translation(\\n skeleton_tree=skeleton_tree,\\n r=quat_identity([skeleton_tree.num_joints]),\\n t=torch.zeros(3, dtype=skeleton_tree.local_translation.dtype),\\n is_local=True,\\n )\\n\\n def local_repr(self):\\n \\\"\\\"\\\" \\n Convert the skeleton state into local representation. This will only affects the values of\\n .tensor. If the skeleton state already has `is_local=True`. This method will do nothing. \\n\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n if self.is_local:\\n return self\\n return SkeletonState.from_rotation_and_root_translation(\\n self.skeleton_tree,\\n r=self.local_rotation,\\n t=self.root_translation,\\n is_local=True,\\n )\\n\\n def global_repr(self):\\n \\\"\\\"\\\" \\n Convert the skeleton state into global representation. This will only affects the values of\\n .tensor. If the skeleton state already has `is_local=False`. This method will do nothing. \\n\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n if not self.is_local:\\n return self\\n return SkeletonState.from_rotation_and_root_translation(\\n self.skeleton_tree,\\n r=self.global_rotation,\\n t=self.root_translation,\\n is_local=False,\\n )\\n\\n def _get_pairwise_average_translation(self):\\n global_transform_inv = transform_inverse(self.global_transformation)\\n p1 = global_transform_inv.unsqueeze(-2)\\n p2 = self.global_transformation.unsqueeze(-3)\\n\\n pairwise_translation = (\\n transform_translation(transform_mul(p1, p2))\\n .reshape(-1, len(self.skeleton_tree), len(self.skeleton_tree), 3)\\n .mean(axis=0)\\n )\\n return pairwise_translation\\n\\n def _transfer_to(self, new_skeleton_tree: SkeletonTree):\\n old_indices = list(map(self.skeleton_tree.index, new_skeleton_tree))\\n return SkeletonState.from_rotation_and_root_translation(\\n new_skeleton_tree,\\n r=self.global_rotation[..., old_indices, :],\\n t=self.root_translation,\\n is_local=False,\\n )\\n\\n def drop_nodes_by_names(\\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Drop a list of nodes from the skeleton and re-compute the local rotation to match the \\n original joint position as much as possible. \\n\\n :param node_names: a list node names that specifies the nodes need to be dropped\\n :type node_names: List of strings\\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\\\\n or not to re-estimate the local translation from the states (avg.)\\n :type estimate_local_translation_from_states: boolean\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n if estimate_local_translation_from_states:\\n pairwise_translation = self._get_pairwise_average_translation()\\n else:\\n pairwise_translation = None\\n new_skeleton_tree = self.skeleton_tree.drop_nodes_by_names(\\n node_names, pairwise_translation\\n )\\n return self._transfer_to(new_skeleton_tree)\\n\\n def keep_nodes_by_names(\\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Keep a list of nodes and drop all other nodes from the skeleton and re-compute the local \\n rotation to match the original joint position as much as possible. \\n\\n :param node_names: a list node names that specifies the nodes need to be dropped\\n :type node_names: List of strings\\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\\\\n or not to re-estimate the local translation from the states (avg.)\\n :type estimate_local_translation_from_states: boolean\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n return self.drop_nodes_by_names(\\n list(filter(lambda x: (x not in node_names), self)),\\n estimate_local_translation_from_states,\\n )\\n\\n def _remapped_to(\\n self, joint_mapping: Dict[str, str], target_skeleton_tree: SkeletonTree\\n ):\\n joint_mapping_inv = {target: source for source, target in joint_mapping.items()}\\n reduced_target_skeleton_tree = target_skeleton_tree.keep_nodes_by_names(\\n list(joint_mapping_inv)\\n )\\n n_joints = (\\n len(joint_mapping),\\n len(self.skeleton_tree),\\n len(reduced_target_skeleton_tree),\\n )\\n assert (\\n len(set(n_joints)) == 1\\n ), \\\"the joint mapping is not consistent with the skeleton trees\\\"\\n source_indices = list(\\n map(\\n lambda x: self.skeleton_tree.index(joint_mapping_inv[x]),\\n reduced_target_skeleton_tree,\\n )\\n )\\n target_local_rotation = self.local_rotation[..., source_indices, :]\\n return SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=reduced_target_skeleton_tree,\\n r=target_local_rotation,\\n t=self.root_translation,\\n is_local=True,\\n )\\n\\n def retarget_to(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose_local_rotation,\\n source_tpose_root_translation: np.ndarray,\\n target_skeleton_tree: SkeletonTree,\\n target_tpose_local_rotation,\\n target_tpose_root_translation: np.ndarray,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n z_up: bool = True,\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\\n implementation with rough approximations. The function follows the procedures below.\\n\\n Steps:\\n 1. Drop the joints from the source (self) that do not belong to the joint mapping\\\\\\n with an implementation that is similar to \\\"keep_nodes_by_names()\\\" - take a\\\\\\n look at the function doc for more details (same for source_tpose)\\n \\n 2. Rotate the source state and the source tpose by \\\"rotation_to_target_skeleton\\\"\\\\\\n to align the source with the target orientation\\n \\n 3. Extract the root translation and normalize it to match the scale of the target\\\\\\n skeleton\\n \\n 4. Extract the global rotation from source state relative to source tpose and\\\\\\n re-apply the relative rotation to the target tpose to construct the global\\\\\\n rotation after retargetting\\n \\n 5. Combine the computed global rotation and the root translation from 3 and 4 to\\\\\\n complete the retargeting.\\n \\n 6. Make feet on the ground (global translation z)\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose_local_rotation: the local rotation of the source skeleton\\n :type source_tpose_local_rotation: Tensor\\n \\n :param source_tpose_root_translation: the root translation of the source tpose\\n :type source_tpose_root_translation: np.ndarray\\n \\n :param target_skeleton_tree: the target skeleton tree\\n :type target_skeleton_tree: SkeletonTree\\n \\n :param target_tpose_local_rotation: the local rotation of the target skeleton\\n :type target_tpose_local_rotation: Tensor\\n \\n :param target_tpose_root_translation: the root translation of the target tpose\\n :type target_tpose_root_translation: Tensor\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n\\n # STEP 0: Preprocess\\n source_tpose = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=self.skeleton_tree,\\n r=source_tpose_local_rotation,\\n t=source_tpose_root_translation,\\n is_local=True,\\n )\\n target_tpose = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=target_skeleton_tree,\\n r=target_tpose_local_rotation,\\n t=target_tpose_root_translation,\\n is_local=True,\\n )\\n\\n # STEP 1: Drop the irrelevant joints\\n pairwise_translation = self._get_pairwise_average_translation()\\n node_names = list(joint_mapping)\\n new_skeleton_tree = self.skeleton_tree.keep_nodes_by_names(\\n node_names, pairwise_translation\\n )\\n\\n # TODO: combine the following steps before STEP 3\\n source_tpose = source_tpose._transfer_to(new_skeleton_tree)\\n source_state = self._transfer_to(new_skeleton_tree)\\n\\n source_tpose = source_tpose._remapped_to(joint_mapping, target_skeleton_tree)\\n source_state = source_state._remapped_to(joint_mapping, target_skeleton_tree)\\n\\n # STEP 2: Rotate the source to align with the target\\n new_local_rotation = source_tpose.local_rotation.clone()\\n new_local_rotation[..., 0, :] = quat_mul_norm(\\n rotation_to_target_skeleton, source_tpose.local_rotation[..., 0, :]\\n )\\n\\n source_tpose = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=source_tpose.skeleton_tree,\\n r=new_local_rotation,\\n t=quat_rotate(rotation_to_target_skeleton, source_tpose.root_translation),\\n is_local=True,\\n )\\n\\n new_local_rotation = source_state.local_rotation.clone()\\n new_local_rotation[..., 0, :] = quat_mul_norm(\\n rotation_to_target_skeleton, source_state.local_rotation[..., 0, :]\\n )\\n source_state = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=source_state.skeleton_tree,\\n r=new_local_rotation,\\n t=quat_rotate(rotation_to_target_skeleton, source_state.root_translation),\\n is_local=True,\\n )\\n\\n # STEP 3: Normalize to match the target scale\\n root_translation_diff = (\\n source_state.root_translation - source_tpose.root_translation\\n ) * scale_to_target_skeleton\\n\\n # STEP 4: the global rotation from source state relative to source tpose and\\n # re-apply to the target\\n current_skeleton_tree = source_state.skeleton_tree\\n target_tpose_global_rotation = source_state.global_rotation[0, :].clone()\\n for current_index, name in enumerate(current_skeleton_tree):\\n if name in target_tpose.skeleton_tree:\\n target_tpose_global_rotation[\\n current_index, :\\n ] = target_tpose.global_rotation[\\n target_tpose.skeleton_tree.index(name), :\\n ]\\n\\n global_rotation_diff = quat_mul_norm(\\n source_state.global_rotation, quat_inverse(source_tpose.global_rotation)\\n )\\n new_global_rotation = quat_mul_norm(\\n global_rotation_diff, target_tpose_global_rotation\\n )\\n\\n # STEP 5: Putting 3 and 4 together\\n current_skeleton_tree = source_state.skeleton_tree\\n shape = source_state.global_rotation.shape[:-1]\\n shape = shape[:-1] + target_tpose.global_rotation.shape[-2:-1]\\n new_global_rotation_output = quat_identity(shape)\\n for current_index, name in enumerate(target_skeleton_tree):\\n while name not in current_skeleton_tree:\\n name = target_skeleton_tree.parent_of(name)\\n parent_index = current_skeleton_tree.index(name)\\n new_global_rotation_output[:, current_index, :] = new_global_rotation[\\n :, parent_index, :\\n ]\\n\\n source_state = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=target_skeleton_tree,\\n r=new_global_rotation_output,\\n t=target_tpose.root_translation + root_translation_diff,\\n is_local=False,\\n ).local_repr()\\n\\n return source_state\\n\\n def retarget_to_by_tpose(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose: \\\"SkeletonState\\\",\\n target_tpose: \\\"SkeletonState\\\",\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\\n implementation with rough approximations. See the method `retarget_to()` for more information\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose: t-pose of the source skeleton\\n :type source_tpose: SkeletonState\\n \\n :param target_tpose: t-pose of the target skeleton\\n :type target_tpose: SkeletonState\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n assert (\\n len(source_tpose.shape) == 0 and len(target_tpose.shape) == 0\\n ), \\\"the retargeting script currently doesn't support vectorized operations\\\"\\n return self.retarget_to(\\n joint_mapping,\\n source_tpose.local_rotation,\\n source_tpose.root_translation,\\n target_tpose.skeleton_tree,\\n target_tpose.local_rotation,\\n target_tpose.root_translation,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton,\\n )\"\n },\n {\n \"identifier\": \"SkeletonMotion\",\n \"path\": \"poselib/poselib/skeleton/skeleton3d.py\",\n \"snippet\": \"class SkeletonMotion(SkeletonState):\\n def __init__(self, tensor_backend, skeleton_tree, is_local, fps, *args, **kwargs):\\n self._fps = fps\\n super().__init__(tensor_backend, skeleton_tree, is_local, *args, **kwargs)\\n\\n def clone(self):\\n return SkeletonMotion(\\n self.tensor.clone(), self.skeleton_tree, self._is_local, self._fps\\n )\\n\\n @property\\n def invariant_property(self):\\n return {\\n \\\"skeleton_tree\\\": self.skeleton_tree,\\n \\\"is_local\\\": self.is_local,\\n \\\"fps\\\": self.fps,\\n }\\n\\n @property\\n def global_velocity(self):\\n \\\"\\\"\\\" global velocity \\\"\\\"\\\"\\n curr_index = self.num_joints * 4 + 3\\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\\n )\\n\\n @property\\n def global_angular_velocity(self):\\n \\\"\\\"\\\" global angular velocity \\\"\\\"\\\"\\n curr_index = self.num_joints * 7 + 3\\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\\n )\\n\\n @property\\n def fps(self):\\n \\\"\\\"\\\" number of frames per second \\\"\\\"\\\"\\n return self._fps\\n\\n @property\\n def time_delta(self):\\n \\\"\\\"\\\" time between two adjacent frames \\\"\\\"\\\"\\n return 1.0 / self.fps\\n\\n @property\\n def global_root_velocity(self):\\n \\\"\\\"\\\" global root velocity \\\"\\\"\\\"\\n return self.global_velocity[..., 0, :]\\n\\n @property\\n def global_root_angular_velocity(self):\\n \\\"\\\"\\\" global root angular velocity \\\"\\\"\\\"\\n return self.global_angular_velocity[..., 0, :]\\n\\n @classmethod\\n def from_state_vector_and_velocity(\\n cls,\\n skeleton_tree,\\n state_vector,\\n global_velocity,\\n global_angular_velocity,\\n is_local,\\n fps,\\n ):\\n \\\"\\\"\\\"\\n Construct a skeleton motion from a skeleton state vector, global velocity and angular\\n velocity at each joint.\\n\\n :param skeleton_tree: the skeleton tree that the motion is based on \\n :type skeleton_tree: SkeletonTree\\n :param state_vector: the state vector from the skeleton state by `.tensor`\\n :type state_vector: Tensor\\n :param global_velocity: the global velocity at each joint\\n :type global_velocity: Tensor\\n :param global_angular_velocity: the global angular velocity at each joint\\n :type global_angular_velocity: Tensor\\n :param is_local: if the rotation ins the state vector is given in local frame\\n :type is_local: boolean\\n :param fps: number of frames per second\\n :type fps: int\\n\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n state_shape = state_vector.shape[:-1]\\n v = global_velocity.reshape(*(state_shape + (-1,)))\\n av = global_angular_velocity.reshape(*(state_shape + (-1,)))\\n new_state_vector = torch.cat([state_vector, v, av], axis=-1)\\n return cls(\\n new_state_vector, skeleton_tree=skeleton_tree, is_local=is_local, fps=fps,\\n )\\n\\n @classmethod\\n def from_skeleton_state(\\n cls: Type[\\\"SkeletonMotion\\\"], skeleton_state: SkeletonState, fps: int\\n ):\\n \\\"\\\"\\\"\\n Construct a skeleton motion from a skeleton state. The velocities are estimated using second\\n order guassian filter along the last axis. The skeleton state must have at least .dim >= 1\\n\\n :param skeleton_state: the skeleton state that the motion is based on \\n :type skeleton_state: SkeletonState\\n :param fps: number of frames per second\\n :type fps: int\\n\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n assert (\\n type(skeleton_state) == SkeletonState\\n ), \\\"expected type of {}, got {}\\\".format(SkeletonState, type(skeleton_state))\\n global_velocity = SkeletonMotion._compute_velocity(\\n p=skeleton_state.global_translation, time_delta=1 / fps\\n )\\n global_angular_velocity = SkeletonMotion._compute_angular_velocity(\\n r=skeleton_state.global_rotation, time_delta=1 / fps\\n )\\n return cls.from_state_vector_and_velocity(\\n skeleton_tree=skeleton_state.skeleton_tree,\\n state_vector=skeleton_state.tensor,\\n global_velocity=global_velocity,\\n global_angular_velocity=global_angular_velocity,\\n is_local=skeleton_state.is_local,\\n fps=fps,\\n )\\n\\n @staticmethod\\n def _to_state_vector(rot, rt, vel, avel):\\n state_shape = rot.shape[:-2]\\n skeleton_state_v = SkeletonState._to_state_vector(rot, rt)\\n v = vel.reshape(*(state_shape + (-1,)))\\n av = avel.reshape(*(state_shape + (-1,)))\\n skeleton_motion_v = torch.cat([skeleton_state_v, v, av], axis=-1)\\n return skeleton_motion_v\\n\\n @classmethod\\n def from_dict(\\n cls: Type[\\\"SkeletonMotion\\\"], dict_repr: OrderedDict, *args, **kwargs\\n ) -> \\\"SkeletonMotion\\\":\\n rot = TensorUtils.from_dict(dict_repr[\\\"rotation\\\"], *args, **kwargs)\\n rt = TensorUtils.from_dict(dict_repr[\\\"root_translation\\\"], *args, **kwargs)\\n vel = TensorUtils.from_dict(dict_repr[\\\"global_velocity\\\"], *args, **kwargs)\\n avel = TensorUtils.from_dict(\\n dict_repr[\\\"global_angular_velocity\\\"], *args, **kwargs\\n )\\n return cls(\\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\\n skeleton_tree=SkeletonTree.from_dict(\\n dict_repr[\\\"skeleton_tree\\\"], *args, **kwargs\\n ),\\n is_local=dict_repr[\\\"is_local\\\"],\\n fps=dict_repr[\\\"fps\\\"],\\n )\\n\\n def to_dict(self) -> OrderedDict:\\n return OrderedDict(\\n [\\n (\\\"rotation\\\", tensor_to_dict(self.rotation)),\\n (\\\"root_translation\\\", tensor_to_dict(self.root_translation)),\\n (\\\"global_velocity\\\", tensor_to_dict(self.global_velocity)),\\n (\\\"global_angular_velocity\\\", tensor_to_dict(self.global_angular_velocity)),\\n (\\\"skeleton_tree\\\", self.skeleton_tree.to_dict()),\\n (\\\"is_local\\\", self.is_local),\\n (\\\"fps\\\", self.fps),\\n ]\\n )\\n\\n @classmethod\\n def from_fbx(\\n cls: Type[\\\"SkeletonMotion\\\"],\\n fbx_file_path,\\n fbx_configs,\\n skeleton_tree=None,\\n is_local=True,\\n fps=120,\\n root_joint=\\\"\\\",\\n root_trans_index=0,\\n *args,\\n **kwargs,\\n ) -> \\\"SkeletonMotion\\\":\\n \\\"\\\"\\\"\\n Construct a skeleton motion from a fbx file (TODO - generalize this). If the skeleton tree\\n is not given, it will use the first frame of the mocap to construct the skeleton tree.\\n\\n :param fbx_file_path: the path of the fbx file\\n :type fbx_file_path: string\\n :param fbx_configs: the configuration in terms of {\\\"tmp_path\\\": ..., \\\"fbx_py27_path\\\": ...}\\n :type fbx_configs: dict\\n :param skeleton_tree: the optional skeleton tree that the rotation will be applied to\\n :type skeleton_tree: SkeletonTree, optional\\n :param is_local: the state vector uses local or global rotation as the representation\\n :type is_local: bool, optional, default=True\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n joint_names, joint_parents, transforms, fps = fbx_to_array(\\n fbx_file_path, fbx_configs, root_joint, fps\\n )\\n # swap the last two axis to match the convention\\n local_transform = euclidean_to_transform(\\n transformation_matrix=torch.from_numpy(\\n np.swapaxes(np.array(transforms), -1, -2),\\n ).float()\\n )\\n local_rotation = transform_rotation(local_transform)\\n root_translation = transform_translation(local_transform)[..., root_trans_index, :]\\n joint_parents = torch.from_numpy(np.array(joint_parents)).int()\\n\\n if skeleton_tree is None:\\n local_translation = transform_translation(local_transform).reshape(\\n -1, len(joint_parents), 3\\n )[0]\\n skeleton_tree = SkeletonTree(joint_names, joint_parents, local_translation)\\n skeleton_state = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree, r=local_rotation, t=root_translation, is_local=True\\n )\\n if not is_local:\\n skeleton_state = skeleton_state.global_repr()\\n return cls.from_skeleton_state(\\n skeleton_state=skeleton_state, fps=fps\\n )\\n\\n @staticmethod\\n def _compute_velocity(p, time_delta, guassian_filter=True):\\n velocity = torch.from_numpy(\\n filters.gaussian_filter1d(\\n np.gradient(p.numpy(), axis=-3), 2, axis=-3, mode=\\\"nearest\\\"\\n )\\n / time_delta,\\n )\\n return velocity\\n\\n @staticmethod\\n def _compute_angular_velocity(r, time_delta: float, guassian_filter=True):\\n # assume the second last dimension is the time axis\\n diff_quat_data = quat_identity_like(r)\\n diff_quat_data[..., :-1, :, :] = quat_mul_norm(\\n r[..., 1:, :, :], quat_inverse(r[..., :-1, :, :])\\n )\\n diff_angle, diff_axis = quat_angle_axis(diff_quat_data)\\n angular_velocity = diff_axis * diff_angle.unsqueeze(-1) / time_delta\\n angular_velocity = torch.from_numpy(\\n filters.gaussian_filter1d(\\n angular_velocity.numpy(), 2, axis=-3, mode=\\\"nearest\\\"\\n ),\\n )\\n return angular_velocity\\n\\n def crop(self, start: int, end: int, fps: Optional[int] = None):\\n \\\"\\\"\\\"\\n Crop the motion along its last axis. This is equivalent to performing a slicing on the\\n object with [..., start: end: skip_every] where skip_every = old_fps / fps. Note that the\\n new fps provided must be a factor of the original fps. \\n\\n :param start: the beginning frame index\\n :type start: int\\n :param end: the ending frame index\\n :type end: int\\n :param fps: number of frames per second in the output (if not given the original fps will be used)\\n :type fps: int, optional\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n if fps is None:\\n new_fps = int(self.fps)\\n old_fps = int(self.fps)\\n else:\\n new_fps = int(fps)\\n old_fps = int(self.fps)\\n assert old_fps % fps == 0, (\\n \\\"the resampling doesn't support fps with non-integer division \\\"\\n \\\"from the original fps: {} => {}\\\".format(old_fps, fps)\\n )\\n skip_every = old_fps // new_fps\\n s = slice(start, end, skip_every)\\n z = self[..., s]\\n\\n rot = z.local_rotation if z.is_local else z.global_rotation\\n rt = z.root_translation\\n vel = z.global_velocity\\n avel = z.global_angular_velocity\\n return SkeletonMotion(\\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\\n skeleton_tree=z.skeleton_tree,\\n is_local=z.is_local,\\n fps=new_fps,\\n )\\n\\n def retarget_to(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose_local_rotation,\\n source_tpose_root_translation: np.ndarray,\\n target_skeleton_tree: \\\"SkeletonTree\\\",\\n target_tpose_local_rotation,\\n target_tpose_root_translation: np.ndarray,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n z_up: bool = True,\\n ) -> \\\"SkeletonMotion\\\":\\n \\\"\\\"\\\" \\n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\\n new retargetted motion.\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose_local_rotation: the local rotation of the source skeleton\\n :type source_tpose_local_rotation: Tensor\\n \\n :param source_tpose_root_translation: the root translation of the source tpose\\n :type source_tpose_root_translation: np.ndarray\\n \\n :param target_skeleton_tree: the target skeleton tree\\n :type target_skeleton_tree: SkeletonTree\\n \\n :param target_tpose_local_rotation: the local rotation of the target skeleton\\n :type target_tpose_local_rotation: Tensor\\n \\n :param target_tpose_root_translation: the root translation of the target tpose\\n :type target_tpose_root_translation: Tensor\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n return SkeletonMotion.from_skeleton_state(\\n super().retarget_to(\\n joint_mapping,\\n source_tpose_local_rotation,\\n source_tpose_root_translation,\\n target_skeleton_tree,\\n target_tpose_local_rotation,\\n target_tpose_root_translation,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton,\\n z_up,\\n ),\\n self.fps,\\n )\\n\\n def retarget_to_by_tpose(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose: \\\"SkeletonState\\\",\\n target_tpose: \\\"SkeletonState\\\",\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n z_up: bool = True,\\n ) -> \\\"SkeletonMotion\\\":\\n \\\"\\\"\\\" \\n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\\n new retargetted motion.\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose: t-pose of the source skeleton\\n :type source_tpose: SkeletonState\\n \\n :param target_tpose: t-pose of the target skeleton\\n :type target_tpose: SkeletonState\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n return self.retarget_to(\\n joint_mapping,\\n source_tpose.local_rotation,\\n source_tpose.root_translation,\\n target_tpose.skeleton_tree,\\n target_tpose.local_rotation,\\n target_tpose.root_translation,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton,\\n z_up,\\n )\"\n },\n {\n \"identifier\": \"plot_skeleton_state\",\n \"path\": \"poselib/poselib/visualization/common.py\",\n \"snippet\": \"def plot_skeleton_state(skeleton_state, task_name=\\\"\\\"):\\n \\\"\\\"\\\"\\n Visualize a skeleton state\\n\\n :param skeleton_state:\\n :param task_name:\\n :type skeleton_state: SkeletonState\\n :type task_name: string, optional\\n \\\"\\\"\\\"\\n logger.info(\\\"plotting {}\\\".format(task_name))\\n task = Draw3DSkeletonState(task_name=task_name, skeleton_state=skeleton_state)\\n plotter = Matplotlib3DPlotter(task)\\n plotter.show()\"\n },\n {\n \"identifier\": \"plot_skeleton_motion_interactive\",\n \"path\": \"poselib/poselib/visualization/common.py\",\n \"snippet\": \"def plot_skeleton_motion_interactive(skeleton_motion, task_name=\\\"\\\"):\\n \\\"\\\"\\\"\\n Visualize a skeleton motion along its first dimension interactively.\\n\\n :param skeleton_motion:\\n :param task_name:\\n :type skeleton_motion: SkeletonMotion\\n :type task_name: string, optional\\n \\\"\\\"\\\"\\n for _ in plot_skeleton_motion_interactive_base(skeleton_motion, task_name):\\n pass\"\n },\n {\n \"identifier\": \"Matplotlib3DPlotter\",\n \"path\": \"poselib/poselib/visualization/plt_plotter.py\",\n \"snippet\": \"class Matplotlib3DPlotter(BasePlotter):\\n _fig: plt.figure # plt figure\\n _ax: p3.Axes3D # plt 3d axis\\n # stores artist objects for each task (task name as the key)\\n _artist_cache: Dict[str, Any]\\n # callables for each task primitives\\n _create_impl_callables: Dict[str, Callable]\\n _update_impl_callables: Dict[str, Callable]\\n\\n def __init__(self, task: \\\"BasePlotterTask\\\") -> None:\\n self._fig = plt.figure()\\n self._ax = p3.Axes3D(self._fig)\\n self._artist_cache = {}\\n\\n self._create_impl_callables = {\\n \\\"Draw3DLines\\\": self._lines_create_impl,\\n \\\"Draw3DDots\\\": self._dots_create_impl,\\n \\\"Draw3DTrail\\\": self._trail_create_impl,\\n }\\n self._update_impl_callables = {\\n \\\"Draw3DLines\\\": self._lines_update_impl,\\n \\\"Draw3DDots\\\": self._dots_update_impl,\\n \\\"Draw3DTrail\\\": self._trail_update_impl,\\n }\\n self._init_lim()\\n super().__init__(task)\\n\\n @property\\n def ax(self):\\n return self._ax\\n\\n @property\\n def fig(self):\\n return self._fig\\n\\n def show(self):\\n plt.show()\\n\\n def _min(self, x, y):\\n if x is None:\\n return y\\n if y is None:\\n return x\\n return min(x, y)\\n\\n def _max(self, x, y):\\n if x is None:\\n return y\\n if y is None:\\n return x\\n return max(x, y)\\n\\n def _init_lim(self):\\n self._curr_x_min = None\\n self._curr_y_min = None\\n self._curr_z_min = None\\n self._curr_x_max = None\\n self._curr_y_max = None\\n self._curr_z_max = None\\n\\n def _update_lim(self, xs, ys, zs):\\n self._curr_x_min = self._min(np.min(xs), self._curr_x_min)\\n self._curr_y_min = self._min(np.min(ys), self._curr_y_min)\\n self._curr_z_min = self._min(np.min(zs), self._curr_z_min)\\n self._curr_x_max = self._max(np.max(xs), self._curr_x_max)\\n self._curr_y_max = self._max(np.max(ys), self._curr_y_max)\\n self._curr_z_max = self._max(np.max(zs), self._curr_z_max)\\n\\n def _set_lim(self):\\n if not (\\n self._curr_x_min is None\\n or self._curr_x_max is None\\n or self._curr_y_min is None\\n or self._curr_y_max is None\\n or self._curr_z_min is None\\n or self._curr_z_max is None\\n ):\\n self._ax.set_xlim3d(self._curr_x_min, self._curr_x_max)\\n self._ax.set_ylim3d(self._curr_y_min, self._curr_y_max)\\n self._ax.set_zlim3d(self._curr_z_min, self._curr_z_max)\\n self._init_lim()\\n\\n @staticmethod\\n def _lines_extract_xyz_impl(index, lines_task):\\n return lines_task[index, :, 0], lines_task[index, :, 1], lines_task[index, :, 2]\\n\\n @staticmethod\\n def _trail_extract_xyz_impl(index, trail_task):\\n return (\\n trail_task[index : index + 2, 0],\\n trail_task[index : index + 2, 1],\\n trail_task[index : index + 2, 2],\\n )\\n\\n def _lines_create_impl(self, lines_task):\\n color = lines_task.color\\n self._artist_cache[lines_task.task_name] = [\\n self._ax.plot(\\n *Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task),\\n color=color,\\n linewidth=lines_task.line_width,\\n alpha=lines_task.alpha\\n )[0]\\n for i in range(len(lines_task))\\n ]\\n\\n def _lines_update_impl(self, lines_task):\\n lines_artists = self._artist_cache[lines_task.task_name]\\n for i in range(len(lines_task)):\\n artist = lines_artists[i]\\n xs, ys, zs = Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task)\\n artist.set_data(xs, ys)\\n artist.set_3d_properties(zs)\\n if lines_task.influence_lim:\\n self._update_lim(xs, ys, zs)\\n\\n def _dots_create_impl(self, dots_task):\\n color = dots_task.color\\n self._artist_cache[dots_task.task_name] = self._ax.plot(\\n dots_task[:, 0],\\n dots_task[:, 1],\\n dots_task[:, 2],\\n c=color,\\n linestyle=\\\"\\\",\\n marker=\\\".\\\",\\n markersize=dots_task.marker_size,\\n alpha=dots_task.alpha,\\n )[0]\\n\\n def _dots_update_impl(self, dots_task):\\n dots_artist = self._artist_cache[dots_task.task_name]\\n dots_artist.set_data(dots_task[:, 0], dots_task[:, 1])\\n dots_artist.set_3d_properties(dots_task[:, 2])\\n if dots_task.influence_lim:\\n self._update_lim(dots_task[:, 0], dots_task[:, 1], dots_task[:, 2])\\n\\n def _trail_create_impl(self, trail_task):\\n color = trail_task.color\\n trail_length = len(trail_task) - 1\\n self._artist_cache[trail_task.task_name] = [\\n self._ax.plot(\\n *Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task),\\n color=trail_task.color,\\n linewidth=trail_task.line_width,\\n alpha=trail_task.alpha * (1.0 - i / (trail_length - 1))\\n )[0]\\n for i in range(trail_length)\\n ]\\n\\n def _trail_update_impl(self, trail_task):\\n trails_artists = self._artist_cache[trail_task.task_name]\\n for i in range(len(trail_task) - 1):\\n artist = trails_artists[i]\\n xs, ys, zs = Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task)\\n artist.set_data(xs, ys)\\n artist.set_3d_properties(zs)\\n if trail_task.influence_lim:\\n self._update_lim(xs, ys, zs)\\n\\n def _create_impl(self, task_list):\\n for task in task_list:\\n self._create_impl_callables[task.task_type](task)\\n self._draw()\\n\\n def _update_impl(self, task_list):\\n for task in task_list:\\n self._update_impl_callables[task.task_type](task)\\n self._draw()\\n\\n def _set_aspect_equal_3d(self):\\n xlim = self._ax.get_xlim3d()\\n ylim = self._ax.get_ylim3d()\\n zlim = self._ax.get_zlim3d()\\n\\n xmean = np.mean(xlim)\\n ymean = np.mean(ylim)\\n zmean = np.mean(zlim)\\n\\n plot_radius = max(\\n [\\n abs(lim - mean_)\\n for lims, mean_ in ((xlim, xmean), (ylim, ymean), (zlim, zmean))\\n for lim in lims\\n ]\\n )\\n\\n self._ax.set_xlim3d([xmean - plot_radius, xmean + plot_radius])\\n self._ax.set_ylim3d([ymean - plot_radius, ymean + plot_radius])\\n self._ax.set_zlim3d([zmean - plot_radius, zmean + plot_radius])\\n\\n def _draw(self):\\n self._set_lim()\\n self._set_aspect_equal_3d()\\n self._fig.canvas.draw()\\n self._fig.canvas.flush_events()\\n plt.pause(0.00001)\"\n },\n {\n \"identifier\": \"Draw3DSkeletonMotion\",\n \"path\": \"poselib/poselib/visualization/skeleton_plotter_tasks.py\",\n \"snippet\": \"class Draw3DSkeletonMotion(BasePlotterTask):\\n def __init__(\\n self,\\n task_name: str,\\n skeleton_motion,\\n frame_index=None,\\n joints_color=\\\"red\\\",\\n lines_color=\\\"blue\\\",\\n velocity_color=\\\"green\\\",\\n angular_velocity_color=\\\"purple\\\",\\n trail_color=\\\"black\\\",\\n trail_length=10,\\n alpha=1.0,\\n ) -> None:\\n super().__init__(task_name=task_name, task_type=\\\"3DSkeletonMotion\\\")\\n self._trail_length = trail_length\\n self._skeleton_motion = skeleton_motion\\n # if frame_index is None:\\n curr_skeleton_motion = self._skeleton_motion.clone()\\n if frame_index is not None:\\n curr_skeleton_motion.tensor = self._skeleton_motion.tensor[frame_index, :]\\n # else:\\n # curr_skeleton_motion = self._skeleton_motion[frame_index, :]\\n self._skeleton_state_task = Draw3DSkeletonState(\\n self.get_scoped_name(\\\"skeleton_state\\\"),\\n curr_skeleton_motion,\\n joints_color=joints_color,\\n lines_color=lines_color,\\n alpha=alpha,\\n )\\n vel_lines, avel_lines = Draw3DSkeletonMotion._get_vel_and_avel(\\n curr_skeleton_motion\\n )\\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\\n np.newaxis, ...\\n ].repeat(trail_length, axis=0)\\n self._vel_task = Draw3DLines(\\n self.get_scoped_name(\\\"velocity\\\"),\\n vel_lines,\\n velocity_color,\\n influence_lim=False,\\n alpha=alpha,\\n )\\n self._avel_task = Draw3DLines(\\n self.get_scoped_name(\\\"angular_velocity\\\"),\\n avel_lines,\\n angular_velocity_color,\\n influence_lim=False,\\n alpha=alpha,\\n )\\n self._com_trail_task = Draw3DTrail(\\n self.get_scoped_name(\\\"com_trail\\\"),\\n self._com_pos,\\n trail_color,\\n marker_size=2,\\n influence_lim=True,\\n alpha=alpha,\\n )\\n\\n @property\\n def name(self):\\n return \\\"3DSkeletonMotion\\\"\\n\\n def update(self, frame_index=None, reset_trail=False, skeleton_motion=None) -> None:\\n if skeleton_motion is not None:\\n self._skeleton_motion = skeleton_motion\\n\\n curr_skeleton_motion = self._skeleton_motion.clone()\\n if frame_index is not None:\\n curr_skeleton_motion.tensor = curr_skeleton_motion.tensor[frame_index, :]\\n if reset_trail:\\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\\n np.newaxis, ...\\n ].repeat(self._trail_length, axis=0)\\n else:\\n self._com_pos = np.concatenate(\\n (\\n curr_skeleton_motion.root_translation.numpy()[np.newaxis, ...],\\n self._com_pos[:-1],\\n ),\\n axis=0,\\n )\\n self._skeleton_state_task.update(curr_skeleton_motion)\\n self._com_trail_task.update(self._com_pos)\\n self._update(*Draw3DSkeletonMotion._get_vel_and_avel(curr_skeleton_motion))\\n\\n @staticmethod\\n def _get_vel_and_avel(skeleton_motion):\\n \\\"\\\"\\\"Get all the velocity and angular velocity lines\\n \\\"\\\"\\\"\\n pos = skeleton_motion.global_translation.numpy()\\n vel = skeleton_motion.global_velocity.numpy()\\n avel = skeleton_motion.global_angular_velocity.numpy()\\n\\n vel_lines = np.stack((pos, pos + vel * 0.02), axis=1)\\n avel_lines = np.stack((pos, pos + avel * 0.01), axis=1)\\n return vel_lines, avel_lines\\n\\n def _update(self, vel_lines, avel_lines) -> None:\\n self._vel_task.update(vel_lines)\\n self._avel_task.update(avel_lines)\\n\\n def __iter__(self):\\n yield from self._skeleton_state_task\\n yield from self._vel_task\\n yield from self._avel_task\\n yield from self._com_trail_task\"\n },\n {\n \"identifier\": \"Draw3DSkeletonState\",\n \"path\": \"poselib/poselib/visualization/skeleton_plotter_tasks.py\",\n \"snippet\": \"class Draw3DSkeletonState(BasePlotterTask):\\n _lines_task: Draw3DLines # sub-task for drawing lines\\n _dots_task: Draw3DDots # sub-task for drawing dots\\n\\n def __init__(\\n self,\\n task_name: str,\\n skeleton_state,\\n joints_color: str = \\\"red\\\",\\n lines_color: str = \\\"blue\\\",\\n alpha=1.0,\\n ) -> None:\\n super().__init__(task_name=task_name, task_type=\\\"3DSkeletonState\\\")\\n lines, dots = Draw3DSkeletonState._get_lines_and_dots(skeleton_state)\\n self._lines_task = Draw3DLines(\\n self.get_scoped_name(\\\"bodies\\\"), lines, joints_color, alpha=alpha\\n )\\n self._dots_task = Draw3DDots(\\n self.get_scoped_name(\\\"joints\\\"), dots, lines_color, alpha=alpha\\n )\\n\\n @property\\n def name(self):\\n return \\\"3DSkeleton\\\"\\n\\n def update(self, skeleton_state) -> None:\\n self._update(*Draw3DSkeletonState._get_lines_and_dots(skeleton_state))\\n\\n @staticmethod\\n def _get_lines_and_dots(skeleton_state):\\n \\\"\\\"\\\"Get all the lines and dots needed to draw the skeleton state\\n \\\"\\\"\\\"\\n assert (\\n len(skeleton_state.tensor.shape) == 1\\n ), \\\"the state has to be zero dimensional\\\"\\n dots = skeleton_state.global_translation.numpy()\\n skeleton_tree = skeleton_state.skeleton_tree\\n parent_indices = skeleton_tree.parent_indices.numpy()\\n lines = []\\n for node_index in range(len(skeleton_tree)):\\n parent_index = parent_indices[node_index]\\n if parent_index != -1:\\n lines.append([dots[node_index], dots[parent_index]])\\n lines = np.array(lines)\\n return lines, dots\\n\\n def _update(self, lines, dots) -> None:\\n self._lines_task.update(lines)\\n self._dots_task.update(dots)\\n\\n def __iter__(self):\\n yield from self._lines_task\\n yield from self._dots_task\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from ...core import *\nfrom ..skeleton3d import SkeletonTree, SkeletonState, SkeletonMotion\nfrom ...visualization.common import (\n plot_skeleton_state,\n plot_skeleton_motion_interactive,\n)\nfrom ...visualization.plt_plotter import Matplotlib3DPlotter\nfrom ...visualization.skeleton_plotter_tasks import (\n Draw3DSkeletonMotion,\n Draw3DSkeletonState,\n)\nimport numpy as np\nimport torch"},"token_num":{"kind":"number","value":18606,"string":"18,606"},"cropped_code":{"kind":"string","value":"# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.\n# NVIDIA CORPORATION and its licensors retain all intellectual property\n# and proprietary rights in and to this software, related documentation\n# and any modifications thereto. Any use, reproduction, disclosure or\n# distribution of this software and related documentation without an express\n# license agreement from NVIDIA CORPORATION is strictly prohibited.\n\n\n\n\n\n\ndef test_skel_tree():\n skel_tree = SkeletonTree.from_mjcf(\n \"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml\",\n backend=\"pytorch\",\n )\n skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend=\"pytorch\")\n # assert skel_tree.to_str() == skel_tree_rec.to_str()\n print(skel_tree.node_names)\n print(skel_tree.local_translation)\n print(skel_tree.parent_indices)\n skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n skel_state = skel_state.drop_nodes_by_names([\"right_hip\", \"left_hip\"])\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n\n\ndef test_skel_motion():\n skel_motion = SkeletonMotion.from_file(\n \"/tmp/tmp.npy\", backend=\"pytorch\", load_context=True\n )\n\n plot_skeleton_motion_interactive(skel_motion)\n\n\ndef test_grad():\n source_motion = SkeletonMotion.from_file(\n \"c:\\\\Users\\\\bmatusch\\\\carbmimic\\\\data\\\\motions\\\\JogFlatTerrain_01_ase.npy\",\n backend=\"pytorch\",\n device=\"cuda:0\",\n )\n source_tpose = SkeletonState.from_file(\n \"c:\\\\Users\\\\bmatusch\\\\carbmimic\\\\data\\\\skeletons\\\\fox_tpose.npy\",\n backend=\"pytorch\",\n device=\"cuda:0\",\n )\n\n target_tpose = SkeletonState.from_file(\n \"c:\\\\Users\\\\bmatusch\\\\carbmimic\\\\data\\\\skeletons\\\\flex_tpose.npy\",\n backend=\"pytorch\",\n device=\"cuda:0\",\n )\n target_skeleton_tree = target_tpose.skeleton_tree\n\n joint_mapping = {\n \"upArm_r\": \"right_shoulder\",\n \"upArm_l\": \"left_shoulder\",\n \"loArm_r\": \"right_elbow\",\n \"loArm_l\": \"left_elbow\",\n \"upLeg_r\": \"right_hip\",\n \"upLeg_l\": \"left_hip\",\n \"loLeg_r\": \"right_knee\",\n \"loLeg_l\": \"left_knee\",\n \"foot_r\": \"right_ankle\",\n \"foot_l\": \"left_ankle\",\n \"hips\": \"pelvis\",\n \"neckA\": \"neck\",\n \"spineA\": \"abdomen\",\n }\n\n rotation_to_target_skeleton = quat_from_angle_axis(\n angle=torch.tensor(90.0).float(),\n axis=torch.tensor([1, 0, 0]).float(),\n degree=True,\n )\n\n target_motion = source_motion.retarget_to(\n joint_mapping=joint_mapping,\n source_tpose_local_rotation=source_tpose.local_rotation,\n source_tpose_root_translation=source_tpose.root_translation,\n target_skeleton_tree=target_skeleton_tree,\n target_tpose_local_rotation=target_tpose.local_rotation,\n target_tpose_root_translation=target_tpose.root_translation,\n rotation_to_target_skeleton=rotation_to_target_skeleton,\n scale_to_target_skeleton=0.01,\n )\n\n target_state = SkeletonState(\n target_motion.tensor[800, :],\n target_motion.skeleton_tree,\n target_motion.is_local,\n )\n\n skeleton_tree = target_state.skeleton_tree\n root_translation = target_state.root_translation\n global_translation = target_state.global_translation\n\n q = np.zeros((len(skeleton_tree), 4), dtype=np.float32)\n q[..., 3] = 1.0\n q = torch.from_numpy(q)\n max_its = 10000\n\n"},"all_code":{"kind":"string","value":"# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.\n# NVIDIA CORPORATION and its licensors retain all intellectual property\n# and proprietary rights in and to this software, related documentation\n# and any modifications thereto. Any use, reproduction, disclosure or\n# distribution of this software and related documentation without an express\n# license agreement from NVIDIA CORPORATION is strictly prohibited.\n\n\n\n\n\n\ndef test_skel_tree():\n skel_tree = SkeletonTree.from_mjcf(\n \"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml\",\n backend=\"pytorch\",\n )\n skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend=\"pytorch\")\n # assert skel_tree.to_str() == skel_tree_rec.to_str()\n print(skel_tree.node_names)\n print(skel_tree.local_translation)\n print(skel_tree.parent_indices)\n skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n skel_state = skel_state.drop_nodes_by_names([\"right_hip\", \"left_hip\"])\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n\n\ndef test_skel_motion():\n skel_motion = SkeletonMotion.from_file(\n \"/tmp/tmp.npy\", backend=\"pytorch\", load_context=True\n )\n\n plot_skeleton_motion_interactive(skel_motion)\n\n\ndef test_grad():\n source_motion = SkeletonMotion.from_file(\n \"c:\\\\Users\\\\bmatusch\\\\carbmimic\\\\data\\\\motions\\\\JogFlatTerrain_01_ase.npy\",\n backend=\"pytorch\",\n device=\"cuda:0\",\n )\n source_tpose = SkeletonState.from_file(\n \"c:\\\\Users\\\\bmatusch\\\\carbmimic\\\\data\\\\skeletons\\\\fox_tpose.npy\",\n backend=\"pytorch\",\n device=\"cuda:0\",\n )\n\n target_tpose = SkeletonState.from_file(\n \"c:\\\\Users\\\\bmatusch\\\\carbmimic\\\\data\\\\skeletons\\\\flex_tpose.npy\",\n backend=\"pytorch\",\n device=\"cuda:0\",\n )\n target_skeleton_tree = target_tpose.skeleton_tree\n\n joint_mapping = {\n \"upArm_r\": \"right_shoulder\",\n \"upArm_l\": \"left_shoulder\",\n \"loArm_r\": \"right_elbow\",\n \"loArm_l\": \"left_elbow\",\n \"upLeg_r\": \"right_hip\",\n \"upLeg_l\": \"left_hip\",\n \"loLeg_r\": \"right_knee\",\n \"loLeg_l\": \"left_knee\",\n \"foot_r\": \"right_ankle\",\n \"foot_l\": \"left_ankle\",\n \"hips\": \"pelvis\",\n \"neckA\": \"neck\",\n \"spineA\": \"abdomen\",\n }\n\n rotation_to_target_skeleton = quat_from_angle_axis(\n angle=torch.tensor(90.0).float(),\n axis=torch.tensor([1, 0, 0]).float(),\n degree=True,\n )\n\n target_motion = source_motion.retarget_to(\n joint_mapping=joint_mapping,\n source_tpose_local_rotation=source_tpose.local_rotation,\n source_tpose_root_translation=source_tpose.root_translation,\n target_skeleton_tree=target_skeleton_tree,\n target_tpose_local_rotation=target_tpose.local_rotation,\n target_tpose_root_translation=target_tpose.root_translation,\n rotation_to_target_skeleton=rotation_to_target_skeleton,\n scale_to_target_skeleton=0.01,\n )\n\n target_state = SkeletonState(\n target_motion.tensor[800, :],\n target_motion.skeleton_tree,\n target_motion.is_local,\n )\n\n skeleton_tree = target_state.skeleton_tree\n root_translation = target_state.root_translation\n global_translation = target_state.global_translation\n\n q = np.zeros((len(skeleton_tree), 4), dtype=np.float32)\n q[..., 3] = 1.0\n q = torch.from_numpy(q)\n max_its = 10000\n"},"next_line":{"kind":"string","value":" task = Draw3DSkeletonState(task_name=\"\", skeleton_state=target_state)"},"gold_snippet_index":{"kind":"number","value":7,"string":"7"},"created_at":{"kind":"string","value":"2023-10-30 20:43:43+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5684,"cells":{"repo_name":{"kind":"string","value":"masked-spacetime-hashing/msth"},"file_path":{"kind":"string","value":"MSTH/SpaceTimeHashing/permute_field.py"},"context":{"kind":"list like","value":[{"identifier":"RaySamples","path":"nerfstudio/cameras/rays.py","snippet":"class RaySamples(TensorDataclass):\n \"\"\"Samples along a ray\"\"\"\n\n frustums: Frustums\n \"\"\"Frustums along ray.\"\"\"\n camera_indices: Optional[TensorType[\"bs\":..., 1]] = None\n \"\"\"Camera index.\"\"\"\n deltas: Optional[TensorType[\"bs\":..., 1]] = None\n \"\"\"\"width\" of each sample.\"\"\"\n spacing_starts: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None\n \"\"\"Start of normalized bin edges along ray [0,1], before warping is applied, ie. linear in disparity sampling.\"\"\"\n spacing_ends: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None\n \"\"\"Start of normalized bin edges along ray [0,1], before warping is applied, ie. linear in disparity sampling.\"\"\"\n spacing_to_euclidean_fn: Optional[Callable] = None\n \"\"\"Function to convert bins to euclidean distance.\"\"\"\n metadata: Optional[Dict[str, TensorType[\"bs\":..., \"latent_dims\"]]] = None\n \"\"\"additional information relevant to generating ray samples\"\"\"\n\n times: Optional[TensorType[..., 1]] = None\n \"\"\"Times at which rays are sampled\"\"\"\n\n def get_transmittance(self, densities: TensorType[..., \"num_samples\", 1]) -> TensorType[..., \"num_samples\", 1]:\n \"\"\"Return weights based on predicted densities\n\n Args:\n densities: Predicted densities for samples along ray\n\n Returns:\n Weights for each sample\n \"\"\"\n\n delta_density = self.deltas * densities\n alphas = 1 - torch.exp(-delta_density)\n\n transmittance = torch.cumsum(delta_density[..., :-1, :], dim=-2)\n transmittance = torch.cat(\n [torch.zeros((*transmittance.shape[:1], 1, 1), device=densities.device), transmittance], dim=-2\n )\n transmittance = torch.exp(-transmittance) # [..., \"num_samples\"]\n transmittance = torch.nan_to_num(transmittance)\n\n return transmittance\n\n def get_weights(self, densities: TensorType[..., \"num_samples\", 1]) -> TensorType[..., \"num_samples\", 1]:\n \"\"\"Return weights based on predicted densities\n\n Args:\n densities: Predicted densities for samples along ray\n\n Returns:\n Weights for each sample\n \"\"\"\n\n delta_density = self.deltas * densities\n alphas = 1 - torch.exp(-delta_density)\n\n transmittance = torch.cumsum(delta_density[..., :-1, :], dim=-2)\n transmittance = torch.cat(\n [torch.zeros((*transmittance.shape[:1], 1, 1), device=densities.device), transmittance], dim=-2\n )\n transmittance = torch.exp(-transmittance) # [..., \"num_samples\"]\n\n weights = alphas * transmittance # [..., \"num_samples\"]\n weights = torch.nan_to_num(weights)\n\n return weights"},{"identifier":"Frustums","path":"nerfstudio/cameras/rays.py","snippet":"class Frustums(TensorDataclass):\n \"\"\"Describes region of space as a frustum.\"\"\"\n\n origins: TensorType[\"bs\":..., 3]\n \"\"\"xyz coordinate for ray origin.\"\"\"\n directions: TensorType[\"bs\":..., 3]\n \"\"\"Direction of ray.\"\"\"\n starts: TensorType[\"bs\":..., 1]\n \"\"\"Where the frustum starts along a ray.\"\"\"\n ends: TensorType[\"bs\":..., 1]\n \"\"\"Where the frustum ends along a ray.\"\"\"\n pixel_area: TensorType[\"bs\":..., 1]\n \"\"\"Projected area of pixel a distance 1 away from origin.\"\"\"\n offsets: Optional[TensorType[\"bs\":..., 3]] = None\n \"\"\"Offsets for each sample position\"\"\"\n\n def get_positions(self) -> TensorType[..., 3]:\n \"\"\"Calculates \"center\" position of frustum. Not weighted by mass.\n\n Returns:\n xyz positions.\n \"\"\"\n pos = self.origins + self.directions * (self.starts + self.ends) / 2\n if self.offsets is not None:\n pos = pos + self.offsets\n return pos\n\n def set_offsets(self, offsets):\n \"\"\"Sets offsets for this frustum for computing positions\"\"\"\n self.offsets = offsets\n\n def get_gaussian_blob(self) -> Gaussians:\n \"\"\"Calculates guassian approximation of conical frustum.\n\n Returns:\n Conical frustums approximated by gaussian distribution.\n \"\"\"\n # Cone radius is set such that the square pixel_area matches the cone area.\n cone_radius = torch.sqrt(self.pixel_area) / 1.7724538509055159 # r = sqrt(pixel_area / pi)\n if self.offsets is not None:\n raise NotImplementedError()\n return conical_frustum_to_gaussian(\n origins=self.origins,\n directions=self.directions,\n starts=self.starts,\n ends=self.ends,\n radius=cone_radius,\n )\n\n @classmethod\n def get_mock_frustum(cls, device: Optional[TORCH_DEVICE] = \"cpu\") -> \"Frustums\":\n \"\"\"Helper function to generate a placeholder frustum.\n\n Returns:\n A size 1 frustum with meaningless values.\n \"\"\"\n return Frustums(\n origins=torch.ones((1, 3)).to(device),\n directions=torch.ones((1, 3)).to(device),\n starts=torch.ones((1, 1)).to(device),\n ends=torch.ones((1, 1)).to(device),\n pixel_area=torch.ones((1, 1)).to(device),\n )"},{"identifier":"RayBundle","path":"nerfstudio/cameras/rays.py","snippet":"class RayBundle(TensorDataclass):\n \"\"\"A bundle of ray parameters.\"\"\"\n\n # TODO(ethan): make sure the sizes with ... are correct\n origins: TensorType[..., 3]\n \"\"\"Ray origins (XYZ)\"\"\"\n directions: TensorType[..., 3]\n \"\"\"Unit ray direction vector\"\"\"\n pixel_area: TensorType[..., 1]\n \"\"\"Projected area of pixel a distance 1 away from origin\"\"\"\n camera_indices: Optional[TensorType[..., 1]] = None\n \"\"\"Camera indices\"\"\"\n nears: Optional[TensorType[..., 1]] = None\n \"\"\"Distance along ray to start sampling\"\"\"\n fars: Optional[TensorType[..., 1]] = None\n \"\"\"Rays Distance along ray to stop sampling\"\"\"\n metadata: Optional[Dict[str, TensorType[\"num_rays\", \"latent_dims\"]]] = None\n \"\"\"Additional metadata or data needed for interpolation, will mimic shape of rays\"\"\"\n times: Optional[TensorType[..., 1]] = None\n \"\"\"Times at which rays are sampled\"\"\"\n\n def set_camera_indices(self, camera_index: int) -> None:\n \"\"\"Sets all of the the camera indices to a specific camera index.\n\n Args:\n camera_index: Camera index.\n \"\"\"\n self.camera_indices = torch.ones_like(self.origins[..., 0:1]).long() * camera_index\n\n def __len__(self) -> int:\n num_rays = torch.numel(self.origins) // self.origins.shape[-1]\n return num_rays\n\n def sample(self, num_rays: int) -> \"RayBundle\":\n \"\"\"Returns a RayBundle as a subset of rays.\n\n Args:\n num_rays: Number of rays in output RayBundle\n\n Returns:\n RayBundle with subset of rays.\n \"\"\"\n assert num_rays <= len(self)\n indices = random.sample(range(len(self)), k=num_rays)\n return self[indices]\n\n def get_row_major_sliced_ray_bundle(self, start_idx: int, end_idx: int) -> \"RayBundle\":\n \"\"\"Flattens RayBundle and extracts chunk given start and end indices.\n\n Args:\n start_idx: Start index of RayBundle chunk.\n end_idx: End index of RayBundle chunk.\n\n Returns:\n Flattened RayBundle with end_idx-start_idx rays.\n\n \"\"\"\n return self.flatten()[start_idx:end_idx]\n\n def get_ray_samples(\n self,\n bin_starts: TensorType[\"bs\":..., \"num_samples\", 1],\n bin_ends: TensorType[\"bs\":..., \"num_samples\", 1],\n spacing_starts: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None,\n spacing_ends: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None,\n spacing_to_euclidean_fn: Optional[Callable] = None,\n ) -> RaySamples:\n \"\"\"Produces samples for each ray by projection points along the ray direction. Currently samples uniformly.\n\n Args:\n bin_starts: Distance from origin to start of bin.\n bin_ends: Distance from origin to end of bin.\n\n Returns:\n Samples projected along ray.\n \"\"\"\n deltas = bin_ends - bin_starts\n if self.camera_indices is not None:\n camera_indices = self.camera_indices[..., None]\n else:\n camera_indices = None\n\n shaped_raybundle_fields = self[..., None]\n\n frustums = Frustums(\n origins=shaped_raybundle_fields.origins, # [..., 1, 3]\n directions=shaped_raybundle_fields.directions, # [..., 1, 3]\n starts=bin_starts, # [..., num_samples, 1]\n ends=bin_ends, # [..., num_samples, 1]\n pixel_area=shaped_raybundle_fields.pixel_area, # [..., 1, 1]\n )\n\n ray_samples = RaySamples(\n frustums=frustums,\n camera_indices=camera_indices, # [..., 1, 1]\n deltas=deltas, # [..., num_samples, 1]\n spacing_starts=spacing_starts, # [..., num_samples, 1]\n spacing_ends=spacing_ends, # [..., num_samples, 1]\n spacing_to_euclidean_fn=spacing_to_euclidean_fn,\n metadata=shaped_raybundle_fields.metadata,\n times=None if self.times is None else self.times[..., None], # [..., 1, 1]\n )\n\n return ray_samples"},{"identifier":"SceneBox","path":"nerfstudio/data/scene_box.py","snippet":"class SceneBox:\n \"\"\"Data to represent the scene box.\"\"\"\n\n aabb: TensorType[2, 3] = None\n \"\"\"aabb: axis-aligned bounding box.\n aabb[0] is the minimum (x,y,z) point.\n aabb[1] is the maximum (x,y,z) point.\"\"\"\n\n def get_diagonal_length(self):\n \"\"\"Returns the longest diagonal length.\"\"\"\n diff = self.aabb[1] - self.aabb[0]\n length = torch.sqrt((diff**2).sum() + 1e-20)\n return length\n\n def get_center(self):\n \"\"\"Returns the center of the box.\"\"\"\n diff = self.aabb[1] - self.aabb[0]\n return self.aabb[0] + diff / 2.0\n\n def get_centered_and_scaled_scene_box(self, scale_factor: Union[float, torch.Tensor] = 1.0):\n \"\"\"Returns a new box that has been shifted and rescaled to be centered\n about the origin.\n\n Args:\n scale_factor: How much to scale the camera origins by.\n \"\"\"\n return SceneBox(aabb=(self.aabb - self.get_center()) * scale_factor)\n\n @staticmethod\n def get_normalized_positions(positions: TensorType[..., 3], aabb: TensorType[2, 3]):\n \"\"\"Return normalized positions in range [0, 1] based on the aabb axis-aligned bounding box.\n\n Args:\n positions: the xyz positions\n aabb: the axis-aligned bounding box\n \"\"\"\n aabb_lengths = aabb[1] - aabb[0]\n normalized_positions = (positions - aabb[0]) / aabb_lengths\n return normalized_positions\n\n def to_json(self) -> Dict:\n \"\"\"Returns a json object from the Python object.\"\"\"\n return {\"type\": \"aabb\", \"min_point\": self.aabb[0].tolist(), \"max_point\": self.aabb[1].tolist()}\n\n @staticmethod\n def from_json(json_: Dict) -> \"SceneBox\":\n \"\"\"Returns the an instance of SceneBox from a json dictionary.\n\n Args:\n json_: the json dictionary containing scene box information\n \"\"\"\n assert json_[\"type\"] == \"aabb\"\n aabb = torch.tensor([json_[0], json_[1]])\n return SceneBox(aabb=aabb)\n\n @staticmethod\n def from_camera_poses(poses: TensorType[..., 3, 4], scale_factor: float) -> \"SceneBox\":\n \"\"\"Returns the instance of SceneBox that fully envelopes a set of poses\n\n Args:\n poses: tensor of camera pose matrices\n scale_factor: How much to scale the camera origins by.\n \"\"\"\n xyzs = poses[..., :3, -1]\n aabb = torch.stack([torch.min(xyzs, dim=0)[0], torch.max(xyzs, dim=0)[0]])\n return SceneBox(aabb=aabb * scale_factor)"},{"identifier":"trunc_exp","path":"nerfstudio/field_components/activations.py","snippet":"class _TruncExp(Function): # pylint: disable=abstract-method\n def forward(ctx, x): # pylint: disable=arguments-differ\n def backward(ctx, g): # pylint: disable=arguments-differ"},{"identifier":"Embedding","path":"nerfstudio/field_components/embedding.py","snippet":"class Embedding(FieldComponent):\n \"\"\"Index into embeddings.\n # TODO: add different types of initializations\n\n Args:\n in_dim: Number of embeddings\n out_dim: Dimension of the embedding vectors\n \"\"\"\n\n def __init__(self, in_dim: int, out_dim: int) -> None:\n super().__init__()\n self.in_dim = in_dim\n self.out_dim = out_dim\n self.build_nn_modules()\n\n def build_nn_modules(self) -> None:\n self.embedding = torch.nn.Embedding(self.in_dim, self.out_dim)\n\n def mean(self, dim=0):\n \"\"\"Return the mean of the embedding weights along a dim.\"\"\"\n return self.embedding.weight.mean(dim)\n\n def forward(self, in_tensor: TensorType[..., \"input_dim\"]) -> TensorType[..., \"output_dim\"]:\n \"\"\"Call forward\n\n Args:\n in_tensor: input tensor to process\n \"\"\"\n return self.embedding(in_tensor)"},{"identifier":"FieldHeadNames","path":"nerfstudio/field_components/field_heads.py","snippet":"class FieldHeadNames(Enum):\n \"\"\"Possible field outputs\"\"\"\n\n RGB = \"rgb\"\n SH = \"sh\"\n DENSITY = \"density\"\n NORMALS = \"normals\"\n PRED_NORMALS = \"pred_normals\"\n UNCERTAINTY = \"uncertainty\"\n TRANSIENT_RGB = \"transient_rgb\"\n TRANSIENT_DENSITY = \"transient_density\"\n SEMANTICS = \"semantics\""},{"identifier":"Field","path":"nerfstudio/fields/base_field.py","snippet":"class Field(nn.Module):\n \"\"\"Base class for fields.\"\"\"\n\n def __init__(self) -> None:\n super().__init__()\n self._sample_locations = None\n self._density_before_activation = None\n\n def density_fn(self, positions: TensorType[\"bs\":..., 3]) -> TensorType[\"bs\":..., 1]:\n \"\"\"Returns only the density. Used primarily with the density grid.\n\n Args:\n positions: the origin of the samples/frustums\n \"\"\"\n # Need to figure out a better way to describe positions with a ray.\n ray_samples = RaySamples(\n frustums=Frustums(\n origins=positions,\n directions=torch.ones_like(positions),\n starts=torch.zeros_like(positions[..., :1]),\n ends=torch.zeros_like(positions[..., :1]),\n pixel_area=torch.ones_like(positions[..., :1]),\n )\n )\n density, _ = self.get_density(ray_samples)\n return density\n\n @abstractmethod\n def get_density(self, ray_samples: RaySamples) -> Tuple[TensorType[..., 1], TensorType[..., \"num_features\"]]:\n \"\"\"Computes and returns the densities. Returns a tensor of densities and a tensor of features.\n\n Args:\n ray_samples: Samples locations to compute density.\n \"\"\"\n\n def get_normals(self) -> TensorType[..., 3]:\n \"\"\"Computes and returns a tensor of normals.\n\n Args:\n density: Tensor of densities.\n \"\"\"\n assert self._sample_locations is not None, \"Sample locations must be set before calling get_normals.\"\n assert self._density_before_activation is not None, \"Density must be set before calling get_normals.\"\n assert (\n self._sample_locations.shape[:-1] == self._density_before_activation.shape[:-1]\n ), \"Sample locations and density must have the same shape besides the last dimension.\"\n\n normals = torch.autograd.grad(\n self._density_before_activation,\n self._sample_locations,\n grad_outputs=torch.ones_like(self._density_before_activation),\n retain_graph=True,\n )[0]\n\n normals = -torch.nn.functional.normalize(normals, dim=-1)\n\n return normals\n\n @abstractmethod\n def get_outputs(\n self, ray_samples: RaySamples, density_embedding: Optional[TensorType] = None\n ) -> Dict[FieldHeadNames, TensorType]:\n \"\"\"Computes and returns the colors. Returns output field values.\n\n Args:\n ray_samples: Samples locations to compute outputs.\n density_embedding: Density embeddings to condition on.\n \"\"\"\n\n def forward(self, ray_samples: RaySamples, compute_normals: bool = False) -> Dict[FieldHeadNames, TensorType]:\n \"\"\"Evaluates the field at points along the ray.\n\n Args:\n ray_samples: Samples to evaluate field on.\n \"\"\"\n if compute_normals:\n with torch.enable_grad():\n density, density_embedding = self.get_density(ray_samples)\n else:\n density, density_embedding = self.get_density(ray_samples)\n\n field_outputs = self.get_outputs(ray_samples, density_embedding=density_embedding)\n field_outputs[FieldHeadNames.DENSITY] = density # type: ignore\n\n if compute_normals:\n with torch.enable_grad():\n normals = self.get_normals()\n field_outputs[FieldHeadNames.NORMALS] = normals # type: ignore\n return field_outputs"},{"identifier":"ProposalNetworkSampler","path":"nerfstudio/model_components/ray_samplers.py","snippet":"class ProposalNetworkSampler(Sampler):\n \"\"\"Sampler that uses a proposal network to generate samples.\n\n Args:\n num_proposal_samples_per_ray: Number of samples to generate per ray for each proposal step.\n num_nerf_samples_per_ray: Number of samples to generate per ray for the NERF model.\n num_proposal_network_iterations: Number of proposal network iterations to run.\n single_jitter: Use a same random jitter for all samples along a ray.\n update_sched: A function that takes the iteration number of steps between updates.\n initial_sampler: Sampler to use for the first iteration. Uses UniformLinDispPiecewise if not set.\n \"\"\"\n\n def __init__(\n self,\n num_proposal_samples_per_ray: Tuple[int] = (64,),\n num_nerf_samples_per_ray: int = 32,\n num_proposal_network_iterations: int = 2,\n single_jitter: bool = False,\n update_sched: Callable = lambda x: 1,\n initial_sampler: Optional[Sampler] = None,\n ) -> None:\n super().__init__()\n self.num_proposal_samples_per_ray = num_proposal_samples_per_ray\n self.num_nerf_samples_per_ray = num_nerf_samples_per_ray\n self.num_proposal_network_iterations = num_proposal_network_iterations\n self.update_sched = update_sched\n if self.num_proposal_network_iterations < 1:\n raise ValueError(\"num_proposal_network_iterations must be >= 1\")\n\n # samplers\n if initial_sampler is None:\n self.initial_sampler = UniformLinDispPiecewiseSampler(single_jitter=single_jitter)\n else:\n self.initial_sampler = initial_sampler\n self.pdf_sampler = PDFSampler(include_original=False, single_jitter=single_jitter)\n\n self._anneal = 1.0\n self._steps_since_update = 0\n self._step = 0\n\n def set_anneal(self, anneal: float) -> None:\n \"\"\"Set the anneal value for the proposal network.\"\"\"\n self._anneal = anneal\n\n def step_cb(self, step):\n \"\"\"Callback to register a training step has passed. This is used to keep track of the sampling schedule\"\"\"\n self._step = step\n self._steps_since_update += 1\n\n def generate_ray_samples(\n self,\n ray_bundle: Optional[RayBundle] = None,\n density_fns: Optional[List[Callable]] = None,\n ) -> Tuple[RaySamples, List, List]:\n assert ray_bundle is not None\n assert density_fns is not None\n\n weights_list = []\n ray_samples_list = []\n\n n = self.num_proposal_network_iterations\n weights = None\n ray_samples = None\n updated = self._steps_since_update > self.update_sched(self._step) or self._step < 10\n for i_level in range(n + 1):\n is_prop = i_level < n\n num_samples = self.num_proposal_samples_per_ray[i_level] if is_prop else self.num_nerf_samples_per_ray\n if i_level == 0:\n # Uniform sampling because we need to start with some samples\n ray_samples = self.initial_sampler(ray_bundle, num_samples=num_samples)\n else:\n # PDF sampling based on the last samples and their weights\n # Perform annealing to the weights. This will be a no-op if self._anneal is 1.0.\n assert weights is not None\n annealed_weights = torch.pow(weights, self._anneal)\n ray_samples = self.pdf_sampler(ray_bundle, ray_samples, annealed_weights, num_samples=num_samples)\n if is_prop:\n if updated:\n # always update on the first step or the inf check in grad scaling crashes\n density = density_fns[i_level](ray_samples.frustums.get_positions())\n else:\n with torch.no_grad():\n density = density_fns[i_level](ray_samples.frustums.get_positions())\n weights = ray_samples.get_weights(density)\n weights_list.append(weights) # (num_rays, num_samples)\n ray_samples_list.append(ray_samples)\n if updated:\n self._steps_since_update = 0\n\n assert ray_samples is not None\n return ray_samples, weights_list, ray_samples_list"},{"identifier":"UniformSampler","path":"nerfstudio/model_components/ray_samplers.py","snippet":"class UniformSampler(SpacedSampler):\n \"\"\"Sample uniformly along a ray\n\n Args:\n num_samples: Number of samples per ray\n train_stratified: Use stratified sampling during training. Defaults to True\n single_jitter: Use a same random jitter for all samples along a ray. Defaults to False\n \"\"\"\n\n def __init__(\n self,\n num_samples: Optional[int] = None,\n train_stratified=True,\n single_jitter=False,\n ) -> None:\n super().__init__(\n num_samples=num_samples,\n spacing_fn=lambda x: x,\n spacing_fn_inv=lambda x: x,\n train_stratified=train_stratified,\n single_jitter=single_jitter,\n )"},{"identifier":"AccumulationRenderer","path":"nerfstudio/model_components/renderers.py","snippet":"class AccumulationRenderer(nn.Module):\n \"\"\"Accumulated value along a ray.\"\"\"\n\n @classmethod\n def forward(\n cls,\n weights: TensorType[\"bs\":..., \"num_samples\", 1],\n ray_indices: Optional[TensorType[\"num_samples\"]] = None,\n num_rays: Optional[int] = None,\n ) -> TensorType[\"bs\":..., 1]:\n \"\"\"Composite samples along ray and calculate accumulation.\n\n Args:\n weights: Weights for each sample\n ray_indices: Ray index for each sample, used when samples are packed.\n num_rays: Number of rays, used when samples are packed.\n\n Returns:\n Outputs of accumulated values.\n \"\"\"\n\n if ray_indices is not None and num_rays is not None:\n # Necessary for packed samples from volumetric ray sampler\n accumulation = nerfacc.accumulate_along_rays(weights, ray_indices, None, num_rays)\n else:\n accumulation = torch.sum(weights, dim=-2)\n return accumulation"},{"identifier":"DepthRenderer","path":"nerfstudio/model_components/renderers.py","snippet":"class DepthRenderer(nn.Module):\n \"\"\"Calculate depth along ray.\n\n Depth Method:\n - median: Depth is set to the distance where the accumulated weight reaches 0.5.\n - expected: Expected depth along ray. Same procedure as rendering rgb, but with depth.\n\n Args:\n method: Depth calculation method.\n \"\"\"\n\n def __init__(self, method: Literal[\"median\", \"expected\"] = \"median\") -> None:\n super().__init__()\n self.method = method\n\n def forward(\n self,\n weights: TensorType[..., \"num_samples\", 1],\n ray_samples: RaySamples,\n ray_indices: Optional[TensorType[\"num_samples\"]] = None,\n num_rays: Optional[int] = None,\n ) -> TensorType[..., 1]:\n \"\"\"Composite samples along ray and calculate depths.\n\n Args:\n weights: Weights for each sample.\n ray_samples: Set of ray samples.\n ray_indices: Ray index for each sample, used when samples are packed.\n num_rays: Number of rays, used when samples are packed.\n\n Returns:\n Outputs of depth values.\n \"\"\"\n\n if self.method == \"median\":\n steps = (ray_samples.frustums.starts + ray_samples.frustums.ends) / 2\n\n if ray_indices is not None and num_rays is not None:\n raise NotImplementedError(\"Median depth calculation is not implemented for packed samples.\")\n cumulative_weights = torch.cumsum(weights[..., 0], dim=-1) # [..., num_samples]\n split = torch.ones((*weights.shape[:-2], 1), device=weights.device) * 0.5 # [..., 1]\n median_index = torch.searchsorted(cumulative_weights, split, side=\"left\") # [..., 1]\n median_index = torch.clamp(median_index, 0, steps.shape[-2] - 1) # [..., 1]\n median_depth = torch.gather(steps[..., 0], dim=-1, index=median_index) # [..., 1]\n return median_depth\n if self.method == \"expected\":\n eps = 1e-10\n steps = (ray_samples.frustums.starts + ray_samples.frustums.ends) / 2\n\n if ray_indices is not None and num_rays is not None:\n # Necessary for packed samples from volumetric ray sampler\n depth = nerfacc.accumulate_along_rays(weights, ray_indices, steps, num_rays)\n accumulation = nerfacc.accumulate_along_rays(weights, ray_indices, None, num_rays)\n depth = depth / (accumulation + eps)\n else:\n depth = torch.sum(weights * steps, dim=-2) / (torch.sum(weights, -2) + eps)\n\n depth = torch.clip(depth, steps.min(), steps.max())\n\n return depth\n\n raise NotImplementedError(f\"Method {self.method} not implemented\")"},{"identifier":"NormalsRenderer","path":"nerfstudio/model_components/renderers.py","snippet":"class NormalsRenderer(nn.Module):\n \"\"\"Calculate normals along the ray.\"\"\"\n\n @classmethod\n def forward(\n cls,\n normals: TensorType[\"bs\":..., \"num_samples\", 3],\n weights: TensorType[\"bs\":..., \"num_samples\", 1],\n normalize: bool = True,\n ) -> TensorType[\"bs\":..., 3]:\n \"\"\"Calculate normals along the ray.\n\n Args:\n normals: Normals for each sample.\n weights: Weights of each sample.\n normalize: Normalize normals.\n \"\"\"\n n = torch.sum(weights * normals, dim=-2)\n if normalize:\n n = safe_normalize(n)\n return n"},{"identifier":"RGBRenderer","path":"nerfstudio/model_components/renderers.py","snippet":"class RGBRenderer(nn.Module):\n \"\"\"Standard volumetric rendering.\n\n Args:\n background_color: Background color as RGB. Uses random colors if None.\n \"\"\"\n\n def __init__(self, background_color: Union[Literal[\"random\", \"last_sample\"], TensorType[3]] = \"random\") -> None:\n super().__init__()\n self.background_color = background_color\n\n @classmethod\n def combine_rgb(\n cls,\n rgb: TensorType[\"bs\":..., \"num_samples\", 3],\n weights: TensorType[\"bs\":..., \"num_samples\", 1],\n background_color: Union[Literal[\"random\", \"white\", \"black\", \"last_sample\"], TensorType[3]] = \"random\",\n ray_indices: Optional[TensorType[\"num_samples\"]] = None,\n num_rays: Optional[int] = None,\n ) -> TensorType[\"bs\":..., 3]:\n \"\"\"Composite samples along ray and render color image\n\n Args:\n rgb: RGB for each sample\n weights: Weights for each sample\n background_color: Background color as RGB.\n ray_indices: Ray index for each sample, used when samples are packed.\n num_rays: Number of rays, used when samples are packed.\n\n Returns:\n Outputs rgb values.\n \"\"\"\n if ray_indices is not None and num_rays is not None:\n # Necessary for packed samples from volumetric ray sampler\n if background_color == \"last_sample\":\n raise NotImplementedError(\"Background color 'last_sample' not implemented for packed samples.\")\n comp_rgb = nerfacc.accumulate_along_rays(weights, ray_indices, rgb, num_rays)\n accumulated_weight = nerfacc.accumulate_along_rays(weights, ray_indices, None, num_rays)\n else:\n comp_rgb = torch.sum(weights * rgb, dim=-2)\n accumulated_weight = torch.sum(weights, dim=-2)\n\n if BACKGROUND_COLOR_OVERRIDE is not None:\n background_color = BACKGROUND_COLOR_OVERRIDE\n if background_color == \"last_sample\":\n background_color = rgb[..., -1, :]\n if background_color == \"random\":\n background_color = torch.rand_like(comp_rgb).to(rgb.device)\n if isinstance(background_color, str) and background_color in colors.COLORS_DICT:\n background_color = colors.COLORS_DICT[background_color].to(rgb.device)\n\n assert isinstance(background_color, torch.Tensor)\n comp_rgb = comp_rgb + background_color.to(weights.device) * (1.0 - accumulated_weight)\n\n return comp_rgb\n\n def forward(\n self,\n rgb: TensorType[\"bs\":..., \"num_samples\", 3],\n weights: TensorType[\"bs\":..., \"num_samples\", 1],\n ray_indices: Optional[TensorType[\"num_samples\"]] = None,\n num_rays: Optional[int] = None,\n ) -> TensorType[\"bs\":..., 3]:\n \"\"\"Composite samples along ray and render color image\n\n Args:\n rgb: RGB for each sample\n weights: Weights for each sample\n ray_indices: Ray index for each sample, used when samples are packed.\n num_rays: Number of rays, used when samples are packed.\n\n Returns:\n Outputs of rgb values.\n \"\"\"\n\n if not self.training:\n rgb = torch.nan_to_num(rgb)\n rgb = self.combine_rgb(\n rgb, weights, background_color=self.background_color, ray_indices=ray_indices, num_rays=num_rays\n )\n if not self.training:\n torch.clamp_(rgb, min=0.0, max=1.0)\n return rgb"},{"identifier":"SceneContraction","path":"nerfstudio/field_components/spatial_distortions.py","snippet":"class SceneContraction(SpatialDistortion):\n \"\"\"Contract unbounded space using the contraction was proposed in MipNeRF-360.\n We use the following contraction equation:\n\n .. math::\n\n f(x) = \\\\begin{cases}\n x & ||x|| \\\\leq 1 \\\\\\\\\n (2 - \\\\frac{1}{||x||})(\\\\frac{x}{||x||}) & ||x|| > 1\n \\\\end{cases}\n\n If the order is not specified, we use the Frobenius norm, this will contract the space to a sphere of\n radius 1. If the order is L_inf (order=float(\"inf\")), we will contract the space to a cube of side length 2.\n If using voxel based encodings such as the Hash encoder, we recommend using the L_inf norm.\n\n Args:\n order: Order of the norm. Default to the Frobenius norm. Must be set to None for Gaussians.\n\n \"\"\"\n\n def __init__(self, order: Optional[Union[float, int]] = None) -> None:\n super().__init__()\n self.order = order\n\n def forward(self, positions):\n def contract(x):\n mag = torch.linalg.norm(x, ord=self.order, dim=-1)[..., None]\n return torch.where(mag < 1, x, (2 - (1 / mag)) * (x / mag))\n\n if isinstance(positions, Gaussians):\n means = contract(positions.mean.clone())\n\n contract = lambda x: (2 - (1 / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True))) * (\n x / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True)\n )\n jc_means = vmap(jacrev(contract))(positions.mean.view(-1, positions.mean.shape[-1]))\n jc_means = jc_means.view(list(positions.mean.shape) + [positions.mean.shape[-1]])\n\n # Only update covariances on positions outside the unit sphere\n mag = positions.mean.norm(dim=-1)\n mask = mag >= 1\n cov = positions.cov.clone()\n cov[mask] = jc_means[mask] @ positions.cov[mask] @ torch.transpose(jc_means[mask], -2, -1)\n\n return Gaussians(mean=means, cov=cov)\n\n return contract(positions)"},{"identifier":"SpatialDistortion","path":"nerfstudio/field_components/spatial_distortions.py","snippet":"class SpatialDistortion(nn.Module):\n \"\"\"Apply spatial distortions\"\"\"\n\n def forward(\n self, positions: Union[TensorType[\"bs\":..., 3], Gaussians]\n ) -> Union[TensorType[\"bs\":..., 3], Gaussians]:\n \"\"\"\n Args:\n positions: Sample to distort\n\n Returns:\n Union: distorted sample\n \"\"\""},{"identifier":"MSELoss","path":"nerfstudio/model_components/losses.py","snippet":"LOSSES = {\"L1\": L1Loss, \"MSE\": MSELoss}\nEPS = 1.0e-7\nURF_SIGMA_SCALE_FACTOR = 3.0\n DS_NERF = 1\n URF = 2\nclass DepthLossType(Enum):\nclass MiDaSMSELoss(nn.Module):\nclass GradientLoss(nn.Module):\nclass ScaleAndShiftInvariantLoss(nn.Module):\ndef outer(\n t0_starts: TensorType[..., \"num_samples_0\"],\n t0_ends: TensorType[..., \"num_samples_0\"],\n t1_starts: TensorType[..., \"num_samples_1\"],\n t1_ends: TensorType[..., \"num_samples_1\"],\n y1: TensorType[..., \"num_samples_1\"],\n) -> TensorType[..., \"num_samples_0\"]:\ndef lossfun_outer(\n t: TensorType[..., \"num_samples+1\"],\n w: TensorType[..., \"num_samples\"],\n t_env: TensorType[..., \"num_samples+1\"],\n w_env: TensorType[..., \"num_samples\"],\n):\ndef ray_samples_to_sdist(ray_samples):\ndef interlevel_loss(weights_list, ray_samples_list):\ndef lossfun_distortion(t, w):\ndef distortion_loss(weights_list, ray_samples_list):\ndef nerfstudio_distortion_loss(\n ray_samples: RaySamples,\n densities: TensorType[\"bs\":..., \"num_samples\", 1] = None,\n weights: TensorType[\"bs\":..., \"num_samples\", 1] = None,\n) -> TensorType[\"bs\":..., 1]:\ndef orientation_loss(\n weights: TensorType[\"bs\":..., \"num_samples\", 1],\n normals: TensorType[\"bs\":..., \"num_samples\", 3],\n viewdirs: TensorType[\"bs\":..., 3],\n):\ndef pred_normal_loss(\n weights: TensorType[\"bs\":..., \"num_samples\", 1],\n normals: TensorType[\"bs\":..., \"num_samples\", 3],\n pred_normals: TensorType[\"bs\":..., \"num_samples\", 3],\n):\ndef ds_nerf_depth_loss(\n weights: TensorType[..., \"num_samples\", 1],\n termination_depth: TensorType[..., 1],\n steps: TensorType[..., \"num_samples\", 1],\n lengths: TensorType[..., \"num_samples\", 1],\n sigma: TensorType[0],\n) -> TensorType[..., 1]:\ndef urban_radiance_field_depth_loss(\n weights: TensorType[..., \"num_samples\", 1],\n termination_depth: TensorType[..., 1],\n predicted_depth: TensorType[..., 1],\n steps: TensorType[..., \"num_samples\", 1],\n sigma: TensorType[0],\n) -> TensorType[..., 1]:\ndef depth_loss(\n weights: TensorType[..., \"num_samples\", 1],\n ray_samples: RaySamples,\n termination_depth: TensorType[..., 1],\n predicted_depth: TensorType[..., 1],\n sigma: TensorType[0],\n directions_norm: TensorType[..., 1],\n is_euclidean: bool,\n depth_loss_type: DepthLossType,\n) -> TensorType[0]:\ndef monosdf_normal_loss(\n normal_pred: TensorType[\"num_samples\", 3], normal_gt: TensorType[\"num_samples\", 3]\n) -> TensorType[0]:\n def __init__(self, reduction_type: Literal[\"image\", \"batch\"] = \"batch\"):\n def forward(\n self, prediction: TensorType[1, 32, \"mult\"], target: TensorType[1, 32, \"mult\"], mask: TensorType[1, 32, \"mult\"]\n ) -> TensorType[0]:\n def __init__(self, scales: int = 4, reduction_type: Literal[\"image\", \"batch\"] = \"batch\"):\n def forward(\n self, prediction: TensorType[1, 32, \"mult\"], target: TensorType[1, 32, \"mult\"], mask: TensorType[1, 32, \"mult\"]\n ) -> TensorType[0]:\n def gradient_loss(\n self, prediction: TensorType[1, 32, \"mult\"], target: TensorType[1, 32, \"mult\"], mask: TensorType[1, 32, \"mult\"]\n ) -> TensorType[0]:\n def __init__(self, alpha: float = 0.5, scales: int = 4, reduction_type: Literal[\"image\", \"batch\"] = \"batch\"):\n def compute_scale_and_shift(\n cls, prediction: TensorType[1, 32, \"mult\"], target: TensorType[1, 32, \"mult\"], mask: TensorType[1, 32, \"mult\"]\n ):\n def forward(\n self, prediction: TensorType[1, 32, \"mult\"], target: TensorType[1, 32, \"mult\"], mask: TensorType[1, 32, \"mult\"]\n ) -> TensorType[0]:\n def __get_prediction_ssi(self):"},{"identifier":"SceneContraction","path":"nerfstudio/field_components/spatial_distortions.py","snippet":"class SceneContraction(SpatialDistortion):\n \"\"\"Contract unbounded space using the contraction was proposed in MipNeRF-360.\n We use the following contraction equation:\n\n .. math::\n\n f(x) = \\\\begin{cases}\n x & ||x|| \\\\leq 1 \\\\\\\\\n (2 - \\\\frac{1}{||x||})(\\\\frac{x}{||x||}) & ||x|| > 1\n \\\\end{cases}\n\n If the order is not specified, we use the Frobenius norm, this will contract the space to a sphere of\n radius 1. If the order is L_inf (order=float(\"inf\")), we will contract the space to a cube of side length 2.\n If using voxel based encodings such as the Hash encoder, we recommend using the L_inf norm.\n\n Args:\n order: Order of the norm. Default to the Frobenius norm. Must be set to None for Gaussians.\n\n \"\"\"\n\n def __init__(self, order: Optional[Union[float, int]] = None) -> None:\n super().__init__()\n self.order = order\n\n def forward(self, positions):\n def contract(x):\n mag = torch.linalg.norm(x, ord=self.order, dim=-1)[..., None]\n return torch.where(mag < 1, x, (2 - (1 / mag)) * (x / mag))\n\n if isinstance(positions, Gaussians):\n means = contract(positions.mean.clone())\n\n contract = lambda x: (2 - (1 / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True))) * (\n x / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True)\n )\n jc_means = vmap(jacrev(contract))(positions.mean.view(-1, positions.mean.shape[-1]))\n jc_means = jc_means.view(list(positions.mean.shape) + [positions.mean.shape[-1]])\n\n # Only update covariances on positions outside the unit sphere\n mag = positions.mean.norm(dim=-1)\n mask = mag >= 1\n cov = positions.cov.clone()\n cov[mask] = jc_means[mask] @ positions.cov[mask] @ torch.transpose(jc_means[mask], -2, -1)\n\n return Gaussians(mean=means, cov=cov)\n\n return contract(positions)"},{"identifier":"HashMLPDensityField","path":"nerfstudio/fields/density_fields.py","snippet":"class HashMLPDensityField(Field):\n \"\"\"A lightweight density field module.\n\n Args:\n aabb: parameters of scene aabb bounds\n num_layers: number of hidden layers\n hidden_dim: dimension of hidden layers\n spatial_distortion: spatial distortion module\n use_linear: whether to skip the MLP and use a single linear layer instead\n \"\"\"\n\n def __init__(\n self,\n aabb: TensorType,\n num_layers: int = 2,\n hidden_dim: int = 64,\n spatial_distortion: Optional[SpatialDistortion] = None,\n use_linear: bool = False,\n num_levels: int = 8,\n max_res: int = 1024,\n base_res: int = 16,\n log2_hashmap_size: int = 18,\n features_per_level: int = 2,\n ) -> None:\n super().__init__()\n self.register_buffer(\"aabb\", aabb)\n self.spatial_distortion = spatial_distortion\n self.use_linear = use_linear\n growth_factor = np.exp((np.log(max_res) - np.log(base_res)) / (num_levels - 1))\n\n self.register_buffer(\"max_res\", torch.tensor(max_res))\n self.register_buffer(\"num_levels\", torch.tensor(num_levels))\n self.register_buffer(\"log2_hashmap_size\", torch.tensor(log2_hashmap_size))\n\n config = {\n \"encoding\": {\n \"otype\": \"HashGrid\",\n \"n_levels\": num_levels,\n \"n_features_per_level\": features_per_level,\n \"log2_hashmap_size\": log2_hashmap_size,\n \"base_resolution\": base_res,\n \"per_level_scale\": growth_factor,\n },\n \"network\": {\n \"otype\": \"FullyFusedMLP\",\n \"activation\": \"ReLU\",\n \"output_activation\": \"None\",\n \"n_neurons\": hidden_dim,\n \"n_hidden_layers\": num_layers - 1,\n },\n }\n\n if not self.use_linear:\n self.mlp_base = tcnn.NetworkWithInputEncoding(\n n_input_dims=3,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n else:\n self.encoding = tcnn.Encoding(n_input_dims=3, encoding_config=config[\"encoding\"])\n self.linear = torch.nn.Linear(self.encoding.n_output_dims, 1)\n\n def get_density(self, ray_samples: RaySamples) -> Tuple[TensorType, None]:\n if self.spatial_distortion is not None:\n positions = self.spatial_distortion(ray_samples.frustums.get_positions())\n positions = (positions + 2.0) / 4.0\n else:\n positions = SceneBox.get_normalized_positions(ray_samples.frustums.get_positions(), self.aabb)\n # Make sure the tcnn gets inputs between 0 and 1.\n selector = ((positions > 0.0) & (positions < 1.0)).all(dim=-1)\n positions = positions * selector[..., None]\n positions_flat = positions.view(-1, 3)\n if not self.use_linear:\n density_before_activation = (\n self.mlp_base(positions_flat).view(*ray_samples.frustums.shape, -1).to(positions)\n )\n else:\n x = self.encoding(positions_flat).to(positions)\n density_before_activation = self.linear(x).view(*ray_samples.frustums.shape, -1)\n\n # Rectifying the density with an exponential is much more stable than a ReLU or\n # softplus, because it enables high post-activation (float32) density outputs\n # from smaller internal (float16) parameters.\n density = trunc_exp(density_before_activation)\n density = density * selector[..., None]\n return density, None\n\n def get_outputs(self, ray_samples: RaySamples, density_embedding: Optional[TensorType] = None) -> dict:\n return {}"},{"identifier":"NearFarCollider","path":"nerfstudio/model_components/scene_colliders.py","snippet":"class NearFarCollider(SceneCollider):\n \"\"\"Sets the nears and fars with fixed values.\n\n Args:\n near_plane: distance to near plane\n far_plane: distance to far plane\n \"\"\"\n\n def __init__(self, near_plane: float, far_plane: float, **kwargs) -> None:\n self.near_plane = near_plane\n self.far_plane = far_plane\n super().__init__(**kwargs)\n\n def set_nears_and_fars(self, ray_bundle: RayBundle) -> RayBundle:\n ones = torch.ones_like(ray_bundle.origins[..., 0:1])\n near_plane = self.near_plane if self.training else 0\n ray_bundle.nears = ones * near_plane\n ray_bundle.fars = ones * self.far_plane\n return ray_bundle"},{"identifier":"NormalsShader","path":"nerfstudio/model_components/shaders.py","snippet":"class NormalsShader(nn.Module):\n \"\"\"Calculate shading for normals.\"\"\"\n\n @classmethod\n def forward(\n cls,\n normals: TensorType[\"bs\":..., 3],\n weights: Optional[TensorType[\"bs\":..., 1]] = None,\n ):\n \"\"\"Applies a rainbow colormap to the normals.\n\n Args:\n normals: Normalized 3D vectors.\n weights: Optional weights to scale to the normal colors. (Can be used for masking)\n\n Returns:\n Colored normals\n \"\"\"\n normals = (normals + 1) / 2\n if weights is not None:\n normals = normals * weights\n return normals"},{"identifier":"Model","path":"nerfstudio/models/base_model.py","snippet":"class Model(nn.Module):\n \"\"\"Model class\n Where everything (Fields, Optimizers, Samplers, Visualization, etc) is linked together. This should be\n subclassed for custom NeRF model.\n\n Args:\n config: configuration for instantiating model\n scene_box: dataset scene box\n \"\"\"\n\n config: ModelConfig\n\n def __init__(\n self,\n config: ModelConfig,\n scene_box: SceneBox,\n num_train_data: int,\n **kwargs,\n ) -> None:\n super().__init__()\n self.config = config\n self.scene_box = scene_box\n self.render_aabb = None # the box that we want to render - should be a subset of scene_box\n self.num_train_data = num_train_data\n self.kwargs = kwargs\n self.collider = None\n\n self.populate_modules() # populate the modules\n self.callbacks = None\n # to keep track of which device the nn.Module is on\n self.device_indicator_param = nn.Parameter(torch.empty(0))\n\n @property\n def device(self):\n \"\"\"Returns the device that the model is on.\"\"\"\n return self.device_indicator_param.device\n\n def get_training_callbacks( # pylint:disable=no-self-use\n self, training_callback_attributes: TrainingCallbackAttributes # pylint: disable=unused-argument\n ) -> List[TrainingCallback]:\n \"\"\"Returns a list of callbacks that run functions at the specified training iterations.\"\"\"\n return []\n\n def populate_modules(self):\n \"\"\"Set the necessary modules to get the network working.\"\"\"\n # default instantiates optional modules that are common among many networks\n # NOTE: call `super().populate_modules()` in subclasses\n\n if self.config.enable_collider:\n self.collider = NearFarCollider(\n near_plane=self.config.collider_params[\"near_plane\"], far_plane=self.config.collider_params[\"far_plane\"]\n )\n\n @abstractmethod\n def get_param_groups(self) -> Dict[str, List[Parameter]]:\n \"\"\"Obtain the parameter groups for the optimizers\n\n Returns:\n Mapping of different parameter groups\n \"\"\"\n\n @abstractmethod\n def get_outputs(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\n \"\"\"Takes in a Ray Bundle and returns a dictionary of outputs.\n\n Args:\n ray_bundle: Input bundle of rays. This raybundle should have all the\n needed information to compute the outputs.\n\n Returns:\n Outputs of model. (ie. rendered colors)\n \"\"\"\n\n def forward(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\n \"\"\"Run forward starting with a ray bundle. This outputs different things depending on the configuration\n of the model and whether or not the batch is provided (whether or not we are training basically)\n\n Args:\n ray_bundle: containing all the information needed to render that ray latents included\n \"\"\"\n\n if self.collider is not None:\n ray_bundle = self.collider(ray_bundle)\n\n return self.get_outputs(ray_bundle)\n\n def get_metrics_dict(self, outputs, batch) -> Dict[str, torch.Tensor]:\n \"\"\"Compute and returns metrics.\n\n Args:\n outputs: the output to compute loss dict to\n batch: ground truth batch corresponding to outputs\n \"\"\"\n # pylint: disable=unused-argument\n # pylint: disable=no-self-use\n return {}\n\n @abstractmethod\n def get_loss_dict(self, outputs, batch, metrics_dict=None) -> Dict[str, torch.Tensor]:\n \"\"\"Computes and returns the losses dict.\n\n Args:\n outputs: the output to compute loss dict to\n batch: ground truth batch corresponding to outputs\n metrics_dict: dictionary of metrics, some of which we can use for loss\n \"\"\"\n\n @torch.no_grad()\n def get_outputs_for_camera_ray_bundle(self, camera_ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\n \"\"\"Takes in camera parameters and computes the output of the model.\n\n Args:\n camera_ray_bundle: ray bundle to calculate outputs over\n \"\"\"\n num_rays_per_chunk = self.config.eval_num_rays_per_chunk\n image_height, image_width = camera_ray_bundle.origins.shape[:2]\n num_rays = len(camera_ray_bundle)\n outputs_lists = defaultdict(list)\n with Timer(\"forwarding\"):\n _t1 = time.time()\n for i in range(0, num_rays, num_rays_per_chunk):\n start_idx = i\n end_idx = i + num_rays_per_chunk\n ray_bundle = camera_ray_bundle.get_row_major_sliced_ray_bundle(start_idx, end_idx)\n outputs = self.forward(ray_bundle=ray_bundle)\n for output_name, output in outputs.items(): # type: ignore\n outputs_lists[output_name].append(output)\n print(f\"forwarding took {time.time() - _t1} seconds\")\n outputs = {}\n for output_name, outputs_list in outputs_lists.items():\n if not torch.is_tensor(outputs_list[0]):\n # TODO: handle lists of tensors as well\n continue\n if output_name == \"mask_val\":\n outputs[\"mask_val\"] = torch.cat(outputs_list, dim=0)\n outputs[output_name] = torch.cat(outputs_list).view(image_height, image_width, -1) # type: ignore\n return outputs\n\n @abstractmethod\n def get_image_metrics_and_images(\n self, outputs: Dict[str, torch.Tensor], batch: Dict[str, torch.Tensor]\n ) -> Tuple[Dict[str, float], Dict[str, torch.Tensor]]:\n \"\"\"Writes the test image outputs.\n TODO: This shouldn't return a loss\n\n Args:\n image_idx: Index of the image.\n step: Current step.\n batch: Batch of data.\n outputs: Outputs of the model.\n\n Returns:\n A dictionary of metrics.\n \"\"\"\n\n def load_model(self, loaded_state: Dict[str, Any]) -> None:\n \"\"\"Load the checkpoint from the given path\n\n Args:\n loaded_state: dictionary of pre-trained model states\n \"\"\"\n state = {key.replace(\"module.\", \"\"): value for key, value in loaded_state[\"model\"].items()}\n self.load_state_dict(state) # type: ignore\n\n def update_to_step(self, step: int) -> None:\n \"\"\"Called when loading a model from a checkpoint. Sets any model parameters that change over\n training to the correct value, based on the training step of the checkpoint.\n\n Args:\n step: training step of the loaded checkpoint\n \"\"\""},{"identifier":"ModelConfig","path":"nerfstudio/models/base_model.py","snippet":"class ModelConfig(InstantiateConfig):\n \"\"\"Configuration for model instantiation\"\"\"\n\n _target: Type = field(default_factory=lambda: Model)\n \"\"\"target class to instantiate\"\"\"\n enable_collider: bool = True\n \"\"\"Whether to create a scene collider to filter rays.\"\"\"\n collider_params: Optional[Dict[str, float]] = to_immutable_dict({\"near_plane\": 2.0, \"far_plane\": 6.0})\n \"\"\"parameters to instantiate scene collider with\"\"\"\n loss_coefficients: Dict[str, float] = to_immutable_dict({\"rgb_loss_coarse\": 1.0, \"rgb_loss_fine\": 1.0})\n \"\"\"parameters to instantiate density field with\"\"\"\n eval_num_rays_per_chunk: int = 4096\n \"\"\"specifies number of rays per chunk during eval\"\"\""},{"identifier":"colormaps","path":"nerfstudio/utils/colormaps.py","snippet":"def apply_colormap(image: TensorType[\"bs\":..., 1], cmap=\"viridis\") -> TensorType[\"bs\":..., \"rgb\":3]:\ndef apply_depth_colormap(\n depth: TensorType[\"bs\":..., 1],\n accumulation: Optional[TensorType[\"bs\":..., 1]] = None,\n near_plane: Optional[float] = None,\n far_plane: Optional[float] = None,\n cmap=\"turbo\",\n) -> TensorType[\"bs\":..., \"rgb\":3]:\ndef apply_boolean_colormap(\n image: TensorType[\"bs\":..., 1, bool],\n true_color: TensorType[\"bs\":..., \"rgb\":3] = colors.WHITE,\n false_color: TensorType[\"bs\":..., \"rgb\":3] = colors.BLACK,\n) -> TensorType[\"bs\":..., \"rgb\":3]:"},{"identifier":"RayBundle","path":"nerfstudio/cameras/rays.py","snippet":"class RayBundle(TensorDataclass):\n \"\"\"A bundle of ray parameters.\"\"\"\n\n # TODO(ethan): make sure the sizes with ... are correct\n origins: TensorType[..., 3]\n \"\"\"Ray origins (XYZ)\"\"\"\n directions: TensorType[..., 3]\n \"\"\"Unit ray direction vector\"\"\"\n pixel_area: TensorType[..., 1]\n \"\"\"Projected area of pixel a distance 1 away from origin\"\"\"\n camera_indices: Optional[TensorType[..., 1]] = None\n \"\"\"Camera indices\"\"\"\n nears: Optional[TensorType[..., 1]] = None\n \"\"\"Distance along ray to start sampling\"\"\"\n fars: Optional[TensorType[..., 1]] = None\n \"\"\"Rays Distance along ray to stop sampling\"\"\"\n metadata: Optional[Dict[str, TensorType[\"num_rays\", \"latent_dims\"]]] = None\n \"\"\"Additional metadata or data needed for interpolation, will mimic shape of rays\"\"\"\n times: Optional[TensorType[..., 1]] = None\n \"\"\"Times at which rays are sampled\"\"\"\n\n def set_camera_indices(self, camera_index: int) -> None:\n \"\"\"Sets all of the the camera indices to a specific camera index.\n\n Args:\n camera_index: Camera index.\n \"\"\"\n self.camera_indices = torch.ones_like(self.origins[..., 0:1]).long() * camera_index\n\n def __len__(self) -> int:\n num_rays = torch.numel(self.origins) // self.origins.shape[-1]\n return num_rays\n\n def sample(self, num_rays: int) -> \"RayBundle\":\n \"\"\"Returns a RayBundle as a subset of rays.\n\n Args:\n num_rays: Number of rays in output RayBundle\n\n Returns:\n RayBundle with subset of rays.\n \"\"\"\n assert num_rays <= len(self)\n indices = random.sample(range(len(self)), k=num_rays)\n return self[indices]\n\n def get_row_major_sliced_ray_bundle(self, start_idx: int, end_idx: int) -> \"RayBundle\":\n \"\"\"Flattens RayBundle and extracts chunk given start and end indices.\n\n Args:\n start_idx: Start index of RayBundle chunk.\n end_idx: End index of RayBundle chunk.\n\n Returns:\n Flattened RayBundle with end_idx-start_idx rays.\n\n \"\"\"\n return self.flatten()[start_idx:end_idx]\n\n def get_ray_samples(\n self,\n bin_starts: TensorType[\"bs\":..., \"num_samples\", 1],\n bin_ends: TensorType[\"bs\":..., \"num_samples\", 1],\n spacing_starts: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None,\n spacing_ends: Optional[TensorType[\"bs\":..., \"num_samples\", 1]] = None,\n spacing_to_euclidean_fn: Optional[Callable] = None,\n ) -> RaySamples:\n \"\"\"Produces samples for each ray by projection points along the ray direction. Currently samples uniformly.\n\n Args:\n bin_starts: Distance from origin to start of bin.\n bin_ends: Distance from origin to end of bin.\n\n Returns:\n Samples projected along ray.\n \"\"\"\n deltas = bin_ends - bin_starts\n if self.camera_indices is not None:\n camera_indices = self.camera_indices[..., None]\n else:\n camera_indices = None\n\n shaped_raybundle_fields = self[..., None]\n\n frustums = Frustums(\n origins=shaped_raybundle_fields.origins, # [..., 1, 3]\n directions=shaped_raybundle_fields.directions, # [..., 1, 3]\n starts=bin_starts, # [..., num_samples, 1]\n ends=bin_ends, # [..., num_samples, 1]\n pixel_area=shaped_raybundle_fields.pixel_area, # [..., 1, 1]\n )\n\n ray_samples = RaySamples(\n frustums=frustums,\n camera_indices=camera_indices, # [..., 1, 1]\n deltas=deltas, # [..., num_samples, 1]\n spacing_starts=spacing_starts, # [..., num_samples, 1]\n spacing_ends=spacing_ends, # [..., num_samples, 1]\n spacing_to_euclidean_fn=spacing_to_euclidean_fn,\n metadata=shaped_raybundle_fields.metadata,\n times=None if self.times is None else self.times[..., None], # [..., 1, 1]\n )\n\n return ray_samples"},{"identifier":"TrainingCallback","path":"nerfstudio/engine/callbacks.py","snippet":"class TrainingCallback:\n \"\"\"Callback class used during training.\n The function 'func' with 'args' and 'kwargs' will be called every 'update_every_num_iters' training iterations,\n including at iteration 0. The function is called after the training iteration.\n\n Args:\n where_to_run: List of locations for when to run callback (before/after iteration)\n func: The function that will be called.\n update_every_num_iters: How often to call the function `func`.\n iters: Tuple of iteration steps to perform callback\n args: args for the function 'func'.\n kwargs: kwargs for the function 'func'.\n \"\"\"\n\n def __init__(\n self,\n where_to_run: List[TrainingCallbackLocation],\n func: Callable,\n update_every_num_iters: Optional[int] = None,\n iters: Optional[Tuple[int, ...]] = None,\n args: Optional[List] = None,\n kwargs: Optional[Dict] = None,\n ):\n assert (\n \"step\" in signature(func).parameters.keys()\n ), f\"'step: int' must be an argument in the callback function 'func': {func.__name__}\"\n self.where_to_run = where_to_run\n self.update_every_num_iters = update_every_num_iters\n self.iters = iters\n self.func = func\n self.args = args if args is not None else []\n self.kwargs = kwargs if kwargs is not None else {}\n\n def run_callback(self, step: int) -> None:\n \"\"\"Callback to run after training step\n\n Args:\n step: current iteration step\n \"\"\"\n if self.update_every_num_iters is not None:\n if step % self.update_every_num_iters == 0:\n self.func(*self.args, **self.kwargs, step=step)\n elif self.iters is not None:\n if step in self.iters:\n self.func(*self.args, **self.kwargs, step=step)\n\n def run_callback_at_location(self, step: int, location: TrainingCallbackLocation) -> None:\n \"\"\"Runs the callback if it's supposed to be run at the given location.\n\n Args:\n step: current iteration step\n location: when to run callback (before/after iteration)\n \"\"\"\n if location in self.where_to_run:\n self.run_callback(step=step)"},{"identifier":"TrainingCallbackAttributes","path":"nerfstudio/engine/callbacks.py","snippet":"class TrainingCallbackAttributes:\n \"\"\"Attributes that can be used to configure training callbacks.\n The callbacks can be specified in the Dataloader or Model implementations.\n Instead of providing access to the entire Trainer object, we only provide these attributes.\n This should be least prone to errors and fairly clean from a user perspective.\"\"\"\n\n # TODO(ethan): type this without circular imports\n optimizers: Optional[InitVar]\n \"\"\"optimizers for training\"\"\"\n grad_scaler: Optional[InitVar]\n \"\"\"gradient scalers\"\"\"\n pipeline: Optional[InitVar]\n \"\"\"reference to training pipeline\"\"\""},{"identifier":"TrainingCallbackLocation","path":"nerfstudio/engine/callbacks.py","snippet":"class TrainingCallbackLocation(Enum):\n \"\"\"Enum for specifying where the training callback should be run.\"\"\"\n\n BEFORE_TRAIN_ITERATION = auto()\n AFTER_TRAIN_ITERATION = auto()"},{"identifier":"ProposalNetworkSamplerSpatial","path":"MSTH/SpaceTimeHashing/ray_samplers.py","snippet":"class ProposalNetworkSamplerSpatial(ProposalNetworkSampler):\n def __init__(\n self,\n num_proposal_samples_per_ray: Tuple[int] = ...,\n num_nerf_samples_per_ray: int = 32,\n num_proposal_network_iterations: int = 2,\n single_jitter: bool = True,\n update_sched: Callable = ...,\n initial_sampler: Optional[Sampler] = None,\n middle_distance: int = 1,\n ) -> None:\n super(Sampler, self).__init__()\n self.num_proposal_samples_per_ray = num_proposal_samples_per_ray\n self.num_nerf_samples_per_ray = num_nerf_samples_per_ray\n self.num_proposal_network_iterations = num_proposal_network_iterations\n self.update_sched = update_sched\n if self.num_proposal_network_iterations < 1:\n raise ValueError(\"num_proposal_network_iterations must be >= 1\")\n\n # samplers\n if initial_sampler is None:\n self.initial_sampler = UniformLinDispPiecewiseSamplerSpatial(\n single_jitter=single_jitter, middle_distance=middle_distance\n )\n else:\n self.initial_sampler = initial_sampler\n self.pdf_sampler = PDFSamplerSpatial(include_original=False, single_jitter=single_jitter)\n\n self._anneal = 1.0\n self._steps_since_update = 0\n self._step = 0\n\n def generate_ray_samples(\n self,\n ray_bundle: Optional[RayBundle] = None,\n density_fns: Optional[List[Callable]] = None,\n ) -> Tuple[RaySamples, List, List, List]:\n with Timer(\"total_ps\"):\n with Timer(\"prep\"):\n assert ray_bundle is not None\n assert density_fns is not None\n\n weights_list = []\n # weights_list_static = []\n ray_samples_list = []\n\n n = self.num_proposal_network_iterations\n weights = None\n weights_static = None\n ray_samples = None\n updated = self._steps_since_update > self.update_sched(self._step) or self._step < 10\n # print(n)\n for i_level in range(n + 1):\n with Timer(\"level\"):\n is_prop = i_level < n\n num_samples = (\n self.num_proposal_samples_per_ray[i_level] if is_prop else self.num_nerf_samples_per_ray\n )\n # print(\"num_samples\", num_samples)\n if i_level == 0:\n # Uniform sampling because we need to start with some samples\n with Timer(\"initial\"):\n ray_samples = self.initial_sampler(ray_bundle, num_samples=num_samples)\n else:\n # PDF sampling based on the last samples and their weights\n # Perform annealing to the weights. This will be a no-op if self._anneal is 1.0.\n assert weights is not None\n with Timer(\"anneal\"):\n annealed_weights = torch.pow(weights, self._anneal)\n self.last_weight = annealed_weights\n with Timer(\"pdf\"):\n ray_samples = self.pdf_sampler(\n ray_bundle, ray_samples, annealed_weights, num_samples=num_samples\n )\n # print(\"ray_samples.shape\", ray_samples.shape)\n if is_prop:\n if updated:\n # always update on the first step or the inf check in grad scaling crashes\n # density = density_fns[i_level](ray_samples.frustums.get_positions())\n with Timer(\"updated density_fn query\"):\n density, density_static = density_fns[i_level](spacetime(ray_samples))\n # print(density.max())\n else:\n with Timer(\"no_updated density_fn query\"):\n with torch.no_grad():\n # density = density_fns[i_level](ray_samples.frustums.get_positions())\n density, density_static = density_fns[i_level](spacetime(ray_samples))\n # print(\"ray_samples.shape\", ray_samples.shape)\n # print(\"density.shape\", density.shape)\n with Timer(\"get weights\"):\n weights = ray_samples.get_weights(density)\n with Timer(\"append\"):\n weights_list.append(weights) # (num_rays, num_samples)\n # weights_static = ray_samples.get_weights(density_static)\n # weights_list_static.append(weights_static) # (num_rays, num_samples)\n ray_samples_list.append(ray_samples)\n if updated:\n self._steps_since_update = 0\n\n assert ray_samples is not None\n return ray_samples, weights_list, ray_samples_list # , weights_list_static"},{"identifier":"spacetime","path":"MSTH/SpaceTimeHashing/ray_samplers.py","snippet":"def spacetime(ray_samples: RaySamples):\n positions = ray_samples.frustums.get_positions()\n assert ray_samples.times is not None, \"ray samples should contain time information\"\n times = ray_samples.times.unsqueeze(1).repeat(1, positions.size(1), 1).to(positions)\n # [num_rays, num_samples, 4]\n return torch.cat([positions, times], dim=-1)"},{"identifier":"spacetime_concat","path":"MSTH/SpaceTimeHashing/ray_samplers.py","snippet":"def spacetime_concat(positions, times):\n # print(positions.shape)\n # print(times.shape)\n if times.dim() < positions.dim():\n times = times.unsqueeze(1).repeat(1, positions.size(1), 1)\n return torch.cat([positions, times.to(positions)], dim=-1)"}],"string":"[\n {\n \"identifier\": \"RaySamples\",\n \"path\": \"nerfstudio/cameras/rays.py\",\n \"snippet\": \"class RaySamples(TensorDataclass):\\n \\\"\\\"\\\"Samples along a ray\\\"\\\"\\\"\\n\\n frustums: Frustums\\n \\\"\\\"\\\"Frustums along ray.\\\"\\\"\\\"\\n camera_indices: Optional[TensorType[\\\"bs\\\":..., 1]] = None\\n \\\"\\\"\\\"Camera index.\\\"\\\"\\\"\\n deltas: Optional[TensorType[\\\"bs\\\":..., 1]] = None\\n \\\"\\\"\\\"\\\"width\\\" of each sample.\\\"\\\"\\\"\\n spacing_starts: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None\\n \\\"\\\"\\\"Start of normalized bin edges along ray [0,1], before warping is applied, ie. linear in disparity sampling.\\\"\\\"\\\"\\n spacing_ends: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None\\n \\\"\\\"\\\"Start of normalized bin edges along ray [0,1], before warping is applied, ie. linear in disparity sampling.\\\"\\\"\\\"\\n spacing_to_euclidean_fn: Optional[Callable] = None\\n \\\"\\\"\\\"Function to convert bins to euclidean distance.\\\"\\\"\\\"\\n metadata: Optional[Dict[str, TensorType[\\\"bs\\\":..., \\\"latent_dims\\\"]]] = None\\n \\\"\\\"\\\"additional information relevant to generating ray samples\\\"\\\"\\\"\\n\\n times: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Times at which rays are sampled\\\"\\\"\\\"\\n\\n def get_transmittance(self, densities: TensorType[..., \\\"num_samples\\\", 1]) -> TensorType[..., \\\"num_samples\\\", 1]:\\n \\\"\\\"\\\"Return weights based on predicted densities\\n\\n Args:\\n densities: Predicted densities for samples along ray\\n\\n Returns:\\n Weights for each sample\\n \\\"\\\"\\\"\\n\\n delta_density = self.deltas * densities\\n alphas = 1 - torch.exp(-delta_density)\\n\\n transmittance = torch.cumsum(delta_density[..., :-1, :], dim=-2)\\n transmittance = torch.cat(\\n [torch.zeros((*transmittance.shape[:1], 1, 1), device=densities.device), transmittance], dim=-2\\n )\\n transmittance = torch.exp(-transmittance) # [..., \\\"num_samples\\\"]\\n transmittance = torch.nan_to_num(transmittance)\\n\\n return transmittance\\n\\n def get_weights(self, densities: TensorType[..., \\\"num_samples\\\", 1]) -> TensorType[..., \\\"num_samples\\\", 1]:\\n \\\"\\\"\\\"Return weights based on predicted densities\\n\\n Args:\\n densities: Predicted densities for samples along ray\\n\\n Returns:\\n Weights for each sample\\n \\\"\\\"\\\"\\n\\n delta_density = self.deltas * densities\\n alphas = 1 - torch.exp(-delta_density)\\n\\n transmittance = torch.cumsum(delta_density[..., :-1, :], dim=-2)\\n transmittance = torch.cat(\\n [torch.zeros((*transmittance.shape[:1], 1, 1), device=densities.device), transmittance], dim=-2\\n )\\n transmittance = torch.exp(-transmittance) # [..., \\\"num_samples\\\"]\\n\\n weights = alphas * transmittance # [..., \\\"num_samples\\\"]\\n weights = torch.nan_to_num(weights)\\n\\n return weights\"\n },\n {\n \"identifier\": \"Frustums\",\n \"path\": \"nerfstudio/cameras/rays.py\",\n \"snippet\": \"class Frustums(TensorDataclass):\\n \\\"\\\"\\\"Describes region of space as a frustum.\\\"\\\"\\\"\\n\\n origins: TensorType[\\\"bs\\\":..., 3]\\n \\\"\\\"\\\"xyz coordinate for ray origin.\\\"\\\"\\\"\\n directions: TensorType[\\\"bs\\\":..., 3]\\n \\\"\\\"\\\"Direction of ray.\\\"\\\"\\\"\\n starts: TensorType[\\\"bs\\\":..., 1]\\n \\\"\\\"\\\"Where the frustum starts along a ray.\\\"\\\"\\\"\\n ends: TensorType[\\\"bs\\\":..., 1]\\n \\\"\\\"\\\"Where the frustum ends along a ray.\\\"\\\"\\\"\\n pixel_area: TensorType[\\\"bs\\\":..., 1]\\n \\\"\\\"\\\"Projected area of pixel a distance 1 away from origin.\\\"\\\"\\\"\\n offsets: Optional[TensorType[\\\"bs\\\":..., 3]] = None\\n \\\"\\\"\\\"Offsets for each sample position\\\"\\\"\\\"\\n\\n def get_positions(self) -> TensorType[..., 3]:\\n \\\"\\\"\\\"Calculates \\\"center\\\" position of frustum. Not weighted by mass.\\n\\n Returns:\\n xyz positions.\\n \\\"\\\"\\\"\\n pos = self.origins + self.directions * (self.starts + self.ends) / 2\\n if self.offsets is not None:\\n pos = pos + self.offsets\\n return pos\\n\\n def set_offsets(self, offsets):\\n \\\"\\\"\\\"Sets offsets for this frustum for computing positions\\\"\\\"\\\"\\n self.offsets = offsets\\n\\n def get_gaussian_blob(self) -> Gaussians:\\n \\\"\\\"\\\"Calculates guassian approximation of conical frustum.\\n\\n Returns:\\n Conical frustums approximated by gaussian distribution.\\n \\\"\\\"\\\"\\n # Cone radius is set such that the square pixel_area matches the cone area.\\n cone_radius = torch.sqrt(self.pixel_area) / 1.7724538509055159 # r = sqrt(pixel_area / pi)\\n if self.offsets is not None:\\n raise NotImplementedError()\\n return conical_frustum_to_gaussian(\\n origins=self.origins,\\n directions=self.directions,\\n starts=self.starts,\\n ends=self.ends,\\n radius=cone_radius,\\n )\\n\\n @classmethod\\n def get_mock_frustum(cls, device: Optional[TORCH_DEVICE] = \\\"cpu\\\") -> \\\"Frustums\\\":\\n \\\"\\\"\\\"Helper function to generate a placeholder frustum.\\n\\n Returns:\\n A size 1 frustum with meaningless values.\\n \\\"\\\"\\\"\\n return Frustums(\\n origins=torch.ones((1, 3)).to(device),\\n directions=torch.ones((1, 3)).to(device),\\n starts=torch.ones((1, 1)).to(device),\\n ends=torch.ones((1, 1)).to(device),\\n pixel_area=torch.ones((1, 1)).to(device),\\n )\"\n },\n {\n \"identifier\": \"RayBundle\",\n \"path\": \"nerfstudio/cameras/rays.py\",\n \"snippet\": \"class RayBundle(TensorDataclass):\\n \\\"\\\"\\\"A bundle of ray parameters.\\\"\\\"\\\"\\n\\n # TODO(ethan): make sure the sizes with ... are correct\\n origins: TensorType[..., 3]\\n \\\"\\\"\\\"Ray origins (XYZ)\\\"\\\"\\\"\\n directions: TensorType[..., 3]\\n \\\"\\\"\\\"Unit ray direction vector\\\"\\\"\\\"\\n pixel_area: TensorType[..., 1]\\n \\\"\\\"\\\"Projected area of pixel a distance 1 away from origin\\\"\\\"\\\"\\n camera_indices: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Camera indices\\\"\\\"\\\"\\n nears: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Distance along ray to start sampling\\\"\\\"\\\"\\n fars: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Rays Distance along ray to stop sampling\\\"\\\"\\\"\\n metadata: Optional[Dict[str, TensorType[\\\"num_rays\\\", \\\"latent_dims\\\"]]] = None\\n \\\"\\\"\\\"Additional metadata or data needed for interpolation, will mimic shape of rays\\\"\\\"\\\"\\n times: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Times at which rays are sampled\\\"\\\"\\\"\\n\\n def set_camera_indices(self, camera_index: int) -> None:\\n \\\"\\\"\\\"Sets all of the the camera indices to a specific camera index.\\n\\n Args:\\n camera_index: Camera index.\\n \\\"\\\"\\\"\\n self.camera_indices = torch.ones_like(self.origins[..., 0:1]).long() * camera_index\\n\\n def __len__(self) -> int:\\n num_rays = torch.numel(self.origins) // self.origins.shape[-1]\\n return num_rays\\n\\n def sample(self, num_rays: int) -> \\\"RayBundle\\\":\\n \\\"\\\"\\\"Returns a RayBundle as a subset of rays.\\n\\n Args:\\n num_rays: Number of rays in output RayBundle\\n\\n Returns:\\n RayBundle with subset of rays.\\n \\\"\\\"\\\"\\n assert num_rays <= len(self)\\n indices = random.sample(range(len(self)), k=num_rays)\\n return self[indices]\\n\\n def get_row_major_sliced_ray_bundle(self, start_idx: int, end_idx: int) -> \\\"RayBundle\\\":\\n \\\"\\\"\\\"Flattens RayBundle and extracts chunk given start and end indices.\\n\\n Args:\\n start_idx: Start index of RayBundle chunk.\\n end_idx: End index of RayBundle chunk.\\n\\n Returns:\\n Flattened RayBundle with end_idx-start_idx rays.\\n\\n \\\"\\\"\\\"\\n return self.flatten()[start_idx:end_idx]\\n\\n def get_ray_samples(\\n self,\\n bin_starts: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n bin_ends: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n spacing_starts: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None,\\n spacing_ends: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None,\\n spacing_to_euclidean_fn: Optional[Callable] = None,\\n ) -> RaySamples:\\n \\\"\\\"\\\"Produces samples for each ray by projection points along the ray direction. Currently samples uniformly.\\n\\n Args:\\n bin_starts: Distance from origin to start of bin.\\n bin_ends: Distance from origin to end of bin.\\n\\n Returns:\\n Samples projected along ray.\\n \\\"\\\"\\\"\\n deltas = bin_ends - bin_starts\\n if self.camera_indices is not None:\\n camera_indices = self.camera_indices[..., None]\\n else:\\n camera_indices = None\\n\\n shaped_raybundle_fields = self[..., None]\\n\\n frustums = Frustums(\\n origins=shaped_raybundle_fields.origins, # [..., 1, 3]\\n directions=shaped_raybundle_fields.directions, # [..., 1, 3]\\n starts=bin_starts, # [..., num_samples, 1]\\n ends=bin_ends, # [..., num_samples, 1]\\n pixel_area=shaped_raybundle_fields.pixel_area, # [..., 1, 1]\\n )\\n\\n ray_samples = RaySamples(\\n frustums=frustums,\\n camera_indices=camera_indices, # [..., 1, 1]\\n deltas=deltas, # [..., num_samples, 1]\\n spacing_starts=spacing_starts, # [..., num_samples, 1]\\n spacing_ends=spacing_ends, # [..., num_samples, 1]\\n spacing_to_euclidean_fn=spacing_to_euclidean_fn,\\n metadata=shaped_raybundle_fields.metadata,\\n times=None if self.times is None else self.times[..., None], # [..., 1, 1]\\n )\\n\\n return ray_samples\"\n },\n {\n \"identifier\": \"SceneBox\",\n \"path\": \"nerfstudio/data/scene_box.py\",\n \"snippet\": \"class SceneBox:\\n \\\"\\\"\\\"Data to represent the scene box.\\\"\\\"\\\"\\n\\n aabb: TensorType[2, 3] = None\\n \\\"\\\"\\\"aabb: axis-aligned bounding box.\\n aabb[0] is the minimum (x,y,z) point.\\n aabb[1] is the maximum (x,y,z) point.\\\"\\\"\\\"\\n\\n def get_diagonal_length(self):\\n \\\"\\\"\\\"Returns the longest diagonal length.\\\"\\\"\\\"\\n diff = self.aabb[1] - self.aabb[0]\\n length = torch.sqrt((diff**2).sum() + 1e-20)\\n return length\\n\\n def get_center(self):\\n \\\"\\\"\\\"Returns the center of the box.\\\"\\\"\\\"\\n diff = self.aabb[1] - self.aabb[0]\\n return self.aabb[0] + diff / 2.0\\n\\n def get_centered_and_scaled_scene_box(self, scale_factor: Union[float, torch.Tensor] = 1.0):\\n \\\"\\\"\\\"Returns a new box that has been shifted and rescaled to be centered\\n about the origin.\\n\\n Args:\\n scale_factor: How much to scale the camera origins by.\\n \\\"\\\"\\\"\\n return SceneBox(aabb=(self.aabb - self.get_center()) * scale_factor)\\n\\n @staticmethod\\n def get_normalized_positions(positions: TensorType[..., 3], aabb: TensorType[2, 3]):\\n \\\"\\\"\\\"Return normalized positions in range [0, 1] based on the aabb axis-aligned bounding box.\\n\\n Args:\\n positions: the xyz positions\\n aabb: the axis-aligned bounding box\\n \\\"\\\"\\\"\\n aabb_lengths = aabb[1] - aabb[0]\\n normalized_positions = (positions - aabb[0]) / aabb_lengths\\n return normalized_positions\\n\\n def to_json(self) -> Dict:\\n \\\"\\\"\\\"Returns a json object from the Python object.\\\"\\\"\\\"\\n return {\\\"type\\\": \\\"aabb\\\", \\\"min_point\\\": self.aabb[0].tolist(), \\\"max_point\\\": self.aabb[1].tolist()}\\n\\n @staticmethod\\n def from_json(json_: Dict) -> \\\"SceneBox\\\":\\n \\\"\\\"\\\"Returns the an instance of SceneBox from a json dictionary.\\n\\n Args:\\n json_: the json dictionary containing scene box information\\n \\\"\\\"\\\"\\n assert json_[\\\"type\\\"] == \\\"aabb\\\"\\n aabb = torch.tensor([json_[0], json_[1]])\\n return SceneBox(aabb=aabb)\\n\\n @staticmethod\\n def from_camera_poses(poses: TensorType[..., 3, 4], scale_factor: float) -> \\\"SceneBox\\\":\\n \\\"\\\"\\\"Returns the instance of SceneBox that fully envelopes a set of poses\\n\\n Args:\\n poses: tensor of camera pose matrices\\n scale_factor: How much to scale the camera origins by.\\n \\\"\\\"\\\"\\n xyzs = poses[..., :3, -1]\\n aabb = torch.stack([torch.min(xyzs, dim=0)[0], torch.max(xyzs, dim=0)[0]])\\n return SceneBox(aabb=aabb * scale_factor)\"\n },\n {\n \"identifier\": \"trunc_exp\",\n \"path\": \"nerfstudio/field_components/activations.py\",\n \"snippet\": \"class _TruncExp(Function): # pylint: disable=abstract-method\\n def forward(ctx, x): # pylint: disable=arguments-differ\\n def backward(ctx, g): # pylint: disable=arguments-differ\"\n },\n {\n \"identifier\": \"Embedding\",\n \"path\": \"nerfstudio/field_components/embedding.py\",\n \"snippet\": \"class Embedding(FieldComponent):\\n \\\"\\\"\\\"Index into embeddings.\\n # TODO: add different types of initializations\\n\\n Args:\\n in_dim: Number of embeddings\\n out_dim: Dimension of the embedding vectors\\n \\\"\\\"\\\"\\n\\n def __init__(self, in_dim: int, out_dim: int) -> None:\\n super().__init__()\\n self.in_dim = in_dim\\n self.out_dim = out_dim\\n self.build_nn_modules()\\n\\n def build_nn_modules(self) -> None:\\n self.embedding = torch.nn.Embedding(self.in_dim, self.out_dim)\\n\\n def mean(self, dim=0):\\n \\\"\\\"\\\"Return the mean of the embedding weights along a dim.\\\"\\\"\\\"\\n return self.embedding.weight.mean(dim)\\n\\n def forward(self, in_tensor: TensorType[..., \\\"input_dim\\\"]) -> TensorType[..., \\\"output_dim\\\"]:\\n \\\"\\\"\\\"Call forward\\n\\n Args:\\n in_tensor: input tensor to process\\n \\\"\\\"\\\"\\n return self.embedding(in_tensor)\"\n },\n {\n \"identifier\": \"FieldHeadNames\",\n \"path\": \"nerfstudio/field_components/field_heads.py\",\n \"snippet\": \"class FieldHeadNames(Enum):\\n \\\"\\\"\\\"Possible field outputs\\\"\\\"\\\"\\n\\n RGB = \\\"rgb\\\"\\n SH = \\\"sh\\\"\\n DENSITY = \\\"density\\\"\\n NORMALS = \\\"normals\\\"\\n PRED_NORMALS = \\\"pred_normals\\\"\\n UNCERTAINTY = \\\"uncertainty\\\"\\n TRANSIENT_RGB = \\\"transient_rgb\\\"\\n TRANSIENT_DENSITY = \\\"transient_density\\\"\\n SEMANTICS = \\\"semantics\\\"\"\n },\n {\n \"identifier\": \"Field\",\n \"path\": \"nerfstudio/fields/base_field.py\",\n \"snippet\": \"class Field(nn.Module):\\n \\\"\\\"\\\"Base class for fields.\\\"\\\"\\\"\\n\\n def __init__(self) -> None:\\n super().__init__()\\n self._sample_locations = None\\n self._density_before_activation = None\\n\\n def density_fn(self, positions: TensorType[\\\"bs\\\":..., 3]) -> TensorType[\\\"bs\\\":..., 1]:\\n \\\"\\\"\\\"Returns only the density. Used primarily with the density grid.\\n\\n Args:\\n positions: the origin of the samples/frustums\\n \\\"\\\"\\\"\\n # Need to figure out a better way to describe positions with a ray.\\n ray_samples = RaySamples(\\n frustums=Frustums(\\n origins=positions,\\n directions=torch.ones_like(positions),\\n starts=torch.zeros_like(positions[..., :1]),\\n ends=torch.zeros_like(positions[..., :1]),\\n pixel_area=torch.ones_like(positions[..., :1]),\\n )\\n )\\n density, _ = self.get_density(ray_samples)\\n return density\\n\\n @abstractmethod\\n def get_density(self, ray_samples: RaySamples) -> Tuple[TensorType[..., 1], TensorType[..., \\\"num_features\\\"]]:\\n \\\"\\\"\\\"Computes and returns the densities. Returns a tensor of densities and a tensor of features.\\n\\n Args:\\n ray_samples: Samples locations to compute density.\\n \\\"\\\"\\\"\\n\\n def get_normals(self) -> TensorType[..., 3]:\\n \\\"\\\"\\\"Computes and returns a tensor of normals.\\n\\n Args:\\n density: Tensor of densities.\\n \\\"\\\"\\\"\\n assert self._sample_locations is not None, \\\"Sample locations must be set before calling get_normals.\\\"\\n assert self._density_before_activation is not None, \\\"Density must be set before calling get_normals.\\\"\\n assert (\\n self._sample_locations.shape[:-1] == self._density_before_activation.shape[:-1]\\n ), \\\"Sample locations and density must have the same shape besides the last dimension.\\\"\\n\\n normals = torch.autograd.grad(\\n self._density_before_activation,\\n self._sample_locations,\\n grad_outputs=torch.ones_like(self._density_before_activation),\\n retain_graph=True,\\n )[0]\\n\\n normals = -torch.nn.functional.normalize(normals, dim=-1)\\n\\n return normals\\n\\n @abstractmethod\\n def get_outputs(\\n self, ray_samples: RaySamples, density_embedding: Optional[TensorType] = None\\n ) -> Dict[FieldHeadNames, TensorType]:\\n \\\"\\\"\\\"Computes and returns the colors. Returns output field values.\\n\\n Args:\\n ray_samples: Samples locations to compute outputs.\\n density_embedding: Density embeddings to condition on.\\n \\\"\\\"\\\"\\n\\n def forward(self, ray_samples: RaySamples, compute_normals: bool = False) -> Dict[FieldHeadNames, TensorType]:\\n \\\"\\\"\\\"Evaluates the field at points along the ray.\\n\\n Args:\\n ray_samples: Samples to evaluate field on.\\n \\\"\\\"\\\"\\n if compute_normals:\\n with torch.enable_grad():\\n density, density_embedding = self.get_density(ray_samples)\\n else:\\n density, density_embedding = self.get_density(ray_samples)\\n\\n field_outputs = self.get_outputs(ray_samples, density_embedding=density_embedding)\\n field_outputs[FieldHeadNames.DENSITY] = density # type: ignore\\n\\n if compute_normals:\\n with torch.enable_grad():\\n normals = self.get_normals()\\n field_outputs[FieldHeadNames.NORMALS] = normals # type: ignore\\n return field_outputs\"\n },\n {\n \"identifier\": \"ProposalNetworkSampler\",\n \"path\": \"nerfstudio/model_components/ray_samplers.py\",\n \"snippet\": \"class ProposalNetworkSampler(Sampler):\\n \\\"\\\"\\\"Sampler that uses a proposal network to generate samples.\\n\\n Args:\\n num_proposal_samples_per_ray: Number of samples to generate per ray for each proposal step.\\n num_nerf_samples_per_ray: Number of samples to generate per ray for the NERF model.\\n num_proposal_network_iterations: Number of proposal network iterations to run.\\n single_jitter: Use a same random jitter for all samples along a ray.\\n update_sched: A function that takes the iteration number of steps between updates.\\n initial_sampler: Sampler to use for the first iteration. Uses UniformLinDispPiecewise if not set.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n num_proposal_samples_per_ray: Tuple[int] = (64,),\\n num_nerf_samples_per_ray: int = 32,\\n num_proposal_network_iterations: int = 2,\\n single_jitter: bool = False,\\n update_sched: Callable = lambda x: 1,\\n initial_sampler: Optional[Sampler] = None,\\n ) -> None:\\n super().__init__()\\n self.num_proposal_samples_per_ray = num_proposal_samples_per_ray\\n self.num_nerf_samples_per_ray = num_nerf_samples_per_ray\\n self.num_proposal_network_iterations = num_proposal_network_iterations\\n self.update_sched = update_sched\\n if self.num_proposal_network_iterations < 1:\\n raise ValueError(\\\"num_proposal_network_iterations must be >= 1\\\")\\n\\n # samplers\\n if initial_sampler is None:\\n self.initial_sampler = UniformLinDispPiecewiseSampler(single_jitter=single_jitter)\\n else:\\n self.initial_sampler = initial_sampler\\n self.pdf_sampler = PDFSampler(include_original=False, single_jitter=single_jitter)\\n\\n self._anneal = 1.0\\n self._steps_since_update = 0\\n self._step = 0\\n\\n def set_anneal(self, anneal: float) -> None:\\n \\\"\\\"\\\"Set the anneal value for the proposal network.\\\"\\\"\\\"\\n self._anneal = anneal\\n\\n def step_cb(self, step):\\n \\\"\\\"\\\"Callback to register a training step has passed. This is used to keep track of the sampling schedule\\\"\\\"\\\"\\n self._step = step\\n self._steps_since_update += 1\\n\\n def generate_ray_samples(\\n self,\\n ray_bundle: Optional[RayBundle] = None,\\n density_fns: Optional[List[Callable]] = None,\\n ) -> Tuple[RaySamples, List, List]:\\n assert ray_bundle is not None\\n assert density_fns is not None\\n\\n weights_list = []\\n ray_samples_list = []\\n\\n n = self.num_proposal_network_iterations\\n weights = None\\n ray_samples = None\\n updated = self._steps_since_update > self.update_sched(self._step) or self._step < 10\\n for i_level in range(n + 1):\\n is_prop = i_level < n\\n num_samples = self.num_proposal_samples_per_ray[i_level] if is_prop else self.num_nerf_samples_per_ray\\n if i_level == 0:\\n # Uniform sampling because we need to start with some samples\\n ray_samples = self.initial_sampler(ray_bundle, num_samples=num_samples)\\n else:\\n # PDF sampling based on the last samples and their weights\\n # Perform annealing to the weights. This will be a no-op if self._anneal is 1.0.\\n assert weights is not None\\n annealed_weights = torch.pow(weights, self._anneal)\\n ray_samples = self.pdf_sampler(ray_bundle, ray_samples, annealed_weights, num_samples=num_samples)\\n if is_prop:\\n if updated:\\n # always update on the first step or the inf check in grad scaling crashes\\n density = density_fns[i_level](ray_samples.frustums.get_positions())\\n else:\\n with torch.no_grad():\\n density = density_fns[i_level](ray_samples.frustums.get_positions())\\n weights = ray_samples.get_weights(density)\\n weights_list.append(weights) # (num_rays, num_samples)\\n ray_samples_list.append(ray_samples)\\n if updated:\\n self._steps_since_update = 0\\n\\n assert ray_samples is not None\\n return ray_samples, weights_list, ray_samples_list\"\n },\n {\n \"identifier\": \"UniformSampler\",\n \"path\": \"nerfstudio/model_components/ray_samplers.py\",\n \"snippet\": \"class UniformSampler(SpacedSampler):\\n \\\"\\\"\\\"Sample uniformly along a ray\\n\\n Args:\\n num_samples: Number of samples per ray\\n train_stratified: Use stratified sampling during training. Defaults to True\\n single_jitter: Use a same random jitter for all samples along a ray. Defaults to False\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n num_samples: Optional[int] = None,\\n train_stratified=True,\\n single_jitter=False,\\n ) -> None:\\n super().__init__(\\n num_samples=num_samples,\\n spacing_fn=lambda x: x,\\n spacing_fn_inv=lambda x: x,\\n train_stratified=train_stratified,\\n single_jitter=single_jitter,\\n )\"\n },\n {\n \"identifier\": \"AccumulationRenderer\",\n \"path\": \"nerfstudio/model_components/renderers.py\",\n \"snippet\": \"class AccumulationRenderer(nn.Module):\\n \\\"\\\"\\\"Accumulated value along a ray.\\\"\\\"\\\"\\n\\n @classmethod\\n def forward(\\n cls,\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n ray_indices: Optional[TensorType[\\\"num_samples\\\"]] = None,\\n num_rays: Optional[int] = None,\\n ) -> TensorType[\\\"bs\\\":..., 1]:\\n \\\"\\\"\\\"Composite samples along ray and calculate accumulation.\\n\\n Args:\\n weights: Weights for each sample\\n ray_indices: Ray index for each sample, used when samples are packed.\\n num_rays: Number of rays, used when samples are packed.\\n\\n Returns:\\n Outputs of accumulated values.\\n \\\"\\\"\\\"\\n\\n if ray_indices is not None and num_rays is not None:\\n # Necessary for packed samples from volumetric ray sampler\\n accumulation = nerfacc.accumulate_along_rays(weights, ray_indices, None, num_rays)\\n else:\\n accumulation = torch.sum(weights, dim=-2)\\n return accumulation\"\n },\n {\n \"identifier\": \"DepthRenderer\",\n \"path\": \"nerfstudio/model_components/renderers.py\",\n \"snippet\": \"class DepthRenderer(nn.Module):\\n \\\"\\\"\\\"Calculate depth along ray.\\n\\n Depth Method:\\n - median: Depth is set to the distance where the accumulated weight reaches 0.5.\\n - expected: Expected depth along ray. Same procedure as rendering rgb, but with depth.\\n\\n Args:\\n method: Depth calculation method.\\n \\\"\\\"\\\"\\n\\n def __init__(self, method: Literal[\\\"median\\\", \\\"expected\\\"] = \\\"median\\\") -> None:\\n super().__init__()\\n self.method = method\\n\\n def forward(\\n self,\\n weights: TensorType[..., \\\"num_samples\\\", 1],\\n ray_samples: RaySamples,\\n ray_indices: Optional[TensorType[\\\"num_samples\\\"]] = None,\\n num_rays: Optional[int] = None,\\n ) -> TensorType[..., 1]:\\n \\\"\\\"\\\"Composite samples along ray and calculate depths.\\n\\n Args:\\n weights: Weights for each sample.\\n ray_samples: Set of ray samples.\\n ray_indices: Ray index for each sample, used when samples are packed.\\n num_rays: Number of rays, used when samples are packed.\\n\\n Returns:\\n Outputs of depth values.\\n \\\"\\\"\\\"\\n\\n if self.method == \\\"median\\\":\\n steps = (ray_samples.frustums.starts + ray_samples.frustums.ends) / 2\\n\\n if ray_indices is not None and num_rays is not None:\\n raise NotImplementedError(\\\"Median depth calculation is not implemented for packed samples.\\\")\\n cumulative_weights = torch.cumsum(weights[..., 0], dim=-1) # [..., num_samples]\\n split = torch.ones((*weights.shape[:-2], 1), device=weights.device) * 0.5 # [..., 1]\\n median_index = torch.searchsorted(cumulative_weights, split, side=\\\"left\\\") # [..., 1]\\n median_index = torch.clamp(median_index, 0, steps.shape[-2] - 1) # [..., 1]\\n median_depth = torch.gather(steps[..., 0], dim=-1, index=median_index) # [..., 1]\\n return median_depth\\n if self.method == \\\"expected\\\":\\n eps = 1e-10\\n steps = (ray_samples.frustums.starts + ray_samples.frustums.ends) / 2\\n\\n if ray_indices is not None and num_rays is not None:\\n # Necessary for packed samples from volumetric ray sampler\\n depth = nerfacc.accumulate_along_rays(weights, ray_indices, steps, num_rays)\\n accumulation = nerfacc.accumulate_along_rays(weights, ray_indices, None, num_rays)\\n depth = depth / (accumulation + eps)\\n else:\\n depth = torch.sum(weights * steps, dim=-2) / (torch.sum(weights, -2) + eps)\\n\\n depth = torch.clip(depth, steps.min(), steps.max())\\n\\n return depth\\n\\n raise NotImplementedError(f\\\"Method {self.method} not implemented\\\")\"\n },\n {\n \"identifier\": \"NormalsRenderer\",\n \"path\": \"nerfstudio/model_components/renderers.py\",\n \"snippet\": \"class NormalsRenderer(nn.Module):\\n \\\"\\\"\\\"Calculate normals along the ray.\\\"\\\"\\\"\\n\\n @classmethod\\n def forward(\\n cls,\\n normals: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 3],\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n normalize: bool = True,\\n ) -> TensorType[\\\"bs\\\":..., 3]:\\n \\\"\\\"\\\"Calculate normals along the ray.\\n\\n Args:\\n normals: Normals for each sample.\\n weights: Weights of each sample.\\n normalize: Normalize normals.\\n \\\"\\\"\\\"\\n n = torch.sum(weights * normals, dim=-2)\\n if normalize:\\n n = safe_normalize(n)\\n return n\"\n },\n {\n \"identifier\": \"RGBRenderer\",\n \"path\": \"nerfstudio/model_components/renderers.py\",\n \"snippet\": \"class RGBRenderer(nn.Module):\\n \\\"\\\"\\\"Standard volumetric rendering.\\n\\n Args:\\n background_color: Background color as RGB. Uses random colors if None.\\n \\\"\\\"\\\"\\n\\n def __init__(self, background_color: Union[Literal[\\\"random\\\", \\\"last_sample\\\"], TensorType[3]] = \\\"random\\\") -> None:\\n super().__init__()\\n self.background_color = background_color\\n\\n @classmethod\\n def combine_rgb(\\n cls,\\n rgb: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 3],\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n background_color: Union[Literal[\\\"random\\\", \\\"white\\\", \\\"black\\\", \\\"last_sample\\\"], TensorType[3]] = \\\"random\\\",\\n ray_indices: Optional[TensorType[\\\"num_samples\\\"]] = None,\\n num_rays: Optional[int] = None,\\n ) -> TensorType[\\\"bs\\\":..., 3]:\\n \\\"\\\"\\\"Composite samples along ray and render color image\\n\\n Args:\\n rgb: RGB for each sample\\n weights: Weights for each sample\\n background_color: Background color as RGB.\\n ray_indices: Ray index for each sample, used when samples are packed.\\n num_rays: Number of rays, used when samples are packed.\\n\\n Returns:\\n Outputs rgb values.\\n \\\"\\\"\\\"\\n if ray_indices is not None and num_rays is not None:\\n # Necessary for packed samples from volumetric ray sampler\\n if background_color == \\\"last_sample\\\":\\n raise NotImplementedError(\\\"Background color 'last_sample' not implemented for packed samples.\\\")\\n comp_rgb = nerfacc.accumulate_along_rays(weights, ray_indices, rgb, num_rays)\\n accumulated_weight = nerfacc.accumulate_along_rays(weights, ray_indices, None, num_rays)\\n else:\\n comp_rgb = torch.sum(weights * rgb, dim=-2)\\n accumulated_weight = torch.sum(weights, dim=-2)\\n\\n if BACKGROUND_COLOR_OVERRIDE is not None:\\n background_color = BACKGROUND_COLOR_OVERRIDE\\n if background_color == \\\"last_sample\\\":\\n background_color = rgb[..., -1, :]\\n if background_color == \\\"random\\\":\\n background_color = torch.rand_like(comp_rgb).to(rgb.device)\\n if isinstance(background_color, str) and background_color in colors.COLORS_DICT:\\n background_color = colors.COLORS_DICT[background_color].to(rgb.device)\\n\\n assert isinstance(background_color, torch.Tensor)\\n comp_rgb = comp_rgb + background_color.to(weights.device) * (1.0 - accumulated_weight)\\n\\n return comp_rgb\\n\\n def forward(\\n self,\\n rgb: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 3],\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n ray_indices: Optional[TensorType[\\\"num_samples\\\"]] = None,\\n num_rays: Optional[int] = None,\\n ) -> TensorType[\\\"bs\\\":..., 3]:\\n \\\"\\\"\\\"Composite samples along ray and render color image\\n\\n Args:\\n rgb: RGB for each sample\\n weights: Weights for each sample\\n ray_indices: Ray index for each sample, used when samples are packed.\\n num_rays: Number of rays, used when samples are packed.\\n\\n Returns:\\n Outputs of rgb values.\\n \\\"\\\"\\\"\\n\\n if not self.training:\\n rgb = torch.nan_to_num(rgb)\\n rgb = self.combine_rgb(\\n rgb, weights, background_color=self.background_color, ray_indices=ray_indices, num_rays=num_rays\\n )\\n if not self.training:\\n torch.clamp_(rgb, min=0.0, max=1.0)\\n return rgb\"\n },\n {\n \"identifier\": \"SceneContraction\",\n \"path\": \"nerfstudio/field_components/spatial_distortions.py\",\n \"snippet\": \"class SceneContraction(SpatialDistortion):\\n \\\"\\\"\\\"Contract unbounded space using the contraction was proposed in MipNeRF-360.\\n We use the following contraction equation:\\n\\n .. math::\\n\\n f(x) = \\\\\\\\begin{cases}\\n x & ||x|| \\\\\\\\leq 1 \\\\\\\\\\\\\\\\\\n (2 - \\\\\\\\frac{1}{||x||})(\\\\\\\\frac{x}{||x||}) & ||x|| > 1\\n \\\\\\\\end{cases}\\n\\n If the order is not specified, we use the Frobenius norm, this will contract the space to a sphere of\\n radius 1. If the order is L_inf (order=float(\\\"inf\\\")), we will contract the space to a cube of side length 2.\\n If using voxel based encodings such as the Hash encoder, we recommend using the L_inf norm.\\n\\n Args:\\n order: Order of the norm. Default to the Frobenius norm. Must be set to None for Gaussians.\\n\\n \\\"\\\"\\\"\\n\\n def __init__(self, order: Optional[Union[float, int]] = None) -> None:\\n super().__init__()\\n self.order = order\\n\\n def forward(self, positions):\\n def contract(x):\\n mag = torch.linalg.norm(x, ord=self.order, dim=-1)[..., None]\\n return torch.where(mag < 1, x, (2 - (1 / mag)) * (x / mag))\\n\\n if isinstance(positions, Gaussians):\\n means = contract(positions.mean.clone())\\n\\n contract = lambda x: (2 - (1 / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True))) * (\\n x / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True)\\n )\\n jc_means = vmap(jacrev(contract))(positions.mean.view(-1, positions.mean.shape[-1]))\\n jc_means = jc_means.view(list(positions.mean.shape) + [positions.mean.shape[-1]])\\n\\n # Only update covariances on positions outside the unit sphere\\n mag = positions.mean.norm(dim=-1)\\n mask = mag >= 1\\n cov = positions.cov.clone()\\n cov[mask] = jc_means[mask] @ positions.cov[mask] @ torch.transpose(jc_means[mask], -2, -1)\\n\\n return Gaussians(mean=means, cov=cov)\\n\\n return contract(positions)\"\n },\n {\n \"identifier\": \"SpatialDistortion\",\n \"path\": \"nerfstudio/field_components/spatial_distortions.py\",\n \"snippet\": \"class SpatialDistortion(nn.Module):\\n \\\"\\\"\\\"Apply spatial distortions\\\"\\\"\\\"\\n\\n def forward(\\n self, positions: Union[TensorType[\\\"bs\\\":..., 3], Gaussians]\\n ) -> Union[TensorType[\\\"bs\\\":..., 3], Gaussians]:\\n \\\"\\\"\\\"\\n Args:\\n positions: Sample to distort\\n\\n Returns:\\n Union: distorted sample\\n \\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"MSELoss\",\n \"path\": \"nerfstudio/model_components/losses.py\",\n \"snippet\": \"LOSSES = {\\\"L1\\\": L1Loss, \\\"MSE\\\": MSELoss}\\nEPS = 1.0e-7\\nURF_SIGMA_SCALE_FACTOR = 3.0\\n DS_NERF = 1\\n URF = 2\\nclass DepthLossType(Enum):\\nclass MiDaSMSELoss(nn.Module):\\nclass GradientLoss(nn.Module):\\nclass ScaleAndShiftInvariantLoss(nn.Module):\\ndef outer(\\n t0_starts: TensorType[..., \\\"num_samples_0\\\"],\\n t0_ends: TensorType[..., \\\"num_samples_0\\\"],\\n t1_starts: TensorType[..., \\\"num_samples_1\\\"],\\n t1_ends: TensorType[..., \\\"num_samples_1\\\"],\\n y1: TensorType[..., \\\"num_samples_1\\\"],\\n) -> TensorType[..., \\\"num_samples_0\\\"]:\\ndef lossfun_outer(\\n t: TensorType[..., \\\"num_samples+1\\\"],\\n w: TensorType[..., \\\"num_samples\\\"],\\n t_env: TensorType[..., \\\"num_samples+1\\\"],\\n w_env: TensorType[..., \\\"num_samples\\\"],\\n):\\ndef ray_samples_to_sdist(ray_samples):\\ndef interlevel_loss(weights_list, ray_samples_list):\\ndef lossfun_distortion(t, w):\\ndef distortion_loss(weights_list, ray_samples_list):\\ndef nerfstudio_distortion_loss(\\n ray_samples: RaySamples,\\n densities: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1] = None,\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1] = None,\\n) -> TensorType[\\\"bs\\\":..., 1]:\\ndef orientation_loss(\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n normals: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 3],\\n viewdirs: TensorType[\\\"bs\\\":..., 3],\\n):\\ndef pred_normal_loss(\\n weights: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n normals: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 3],\\n pred_normals: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 3],\\n):\\ndef ds_nerf_depth_loss(\\n weights: TensorType[..., \\\"num_samples\\\", 1],\\n termination_depth: TensorType[..., 1],\\n steps: TensorType[..., \\\"num_samples\\\", 1],\\n lengths: TensorType[..., \\\"num_samples\\\", 1],\\n sigma: TensorType[0],\\n) -> TensorType[..., 1]:\\ndef urban_radiance_field_depth_loss(\\n weights: TensorType[..., \\\"num_samples\\\", 1],\\n termination_depth: TensorType[..., 1],\\n predicted_depth: TensorType[..., 1],\\n steps: TensorType[..., \\\"num_samples\\\", 1],\\n sigma: TensorType[0],\\n) -> TensorType[..., 1]:\\ndef depth_loss(\\n weights: TensorType[..., \\\"num_samples\\\", 1],\\n ray_samples: RaySamples,\\n termination_depth: TensorType[..., 1],\\n predicted_depth: TensorType[..., 1],\\n sigma: TensorType[0],\\n directions_norm: TensorType[..., 1],\\n is_euclidean: bool,\\n depth_loss_type: DepthLossType,\\n) -> TensorType[0]:\\ndef monosdf_normal_loss(\\n normal_pred: TensorType[\\\"num_samples\\\", 3], normal_gt: TensorType[\\\"num_samples\\\", 3]\\n) -> TensorType[0]:\\n def __init__(self, reduction_type: Literal[\\\"image\\\", \\\"batch\\\"] = \\\"batch\\\"):\\n def forward(\\n self, prediction: TensorType[1, 32, \\\"mult\\\"], target: TensorType[1, 32, \\\"mult\\\"], mask: TensorType[1, 32, \\\"mult\\\"]\\n ) -> TensorType[0]:\\n def __init__(self, scales: int = 4, reduction_type: Literal[\\\"image\\\", \\\"batch\\\"] = \\\"batch\\\"):\\n def forward(\\n self, prediction: TensorType[1, 32, \\\"mult\\\"], target: TensorType[1, 32, \\\"mult\\\"], mask: TensorType[1, 32, \\\"mult\\\"]\\n ) -> TensorType[0]:\\n def gradient_loss(\\n self, prediction: TensorType[1, 32, \\\"mult\\\"], target: TensorType[1, 32, \\\"mult\\\"], mask: TensorType[1, 32, \\\"mult\\\"]\\n ) -> TensorType[0]:\\n def __init__(self, alpha: float = 0.5, scales: int = 4, reduction_type: Literal[\\\"image\\\", \\\"batch\\\"] = \\\"batch\\\"):\\n def compute_scale_and_shift(\\n cls, prediction: TensorType[1, 32, \\\"mult\\\"], target: TensorType[1, 32, \\\"mult\\\"], mask: TensorType[1, 32, \\\"mult\\\"]\\n ):\\n def forward(\\n self, prediction: TensorType[1, 32, \\\"mult\\\"], target: TensorType[1, 32, \\\"mult\\\"], mask: TensorType[1, 32, \\\"mult\\\"]\\n ) -> TensorType[0]:\\n def __get_prediction_ssi(self):\"\n },\n {\n \"identifier\": \"SceneContraction\",\n \"path\": \"nerfstudio/field_components/spatial_distortions.py\",\n \"snippet\": \"class SceneContraction(SpatialDistortion):\\n \\\"\\\"\\\"Contract unbounded space using the contraction was proposed in MipNeRF-360.\\n We use the following contraction equation:\\n\\n .. math::\\n\\n f(x) = \\\\\\\\begin{cases}\\n x & ||x|| \\\\\\\\leq 1 \\\\\\\\\\\\\\\\\\n (2 - \\\\\\\\frac{1}{||x||})(\\\\\\\\frac{x}{||x||}) & ||x|| > 1\\n \\\\\\\\end{cases}\\n\\n If the order is not specified, we use the Frobenius norm, this will contract the space to a sphere of\\n radius 1. If the order is L_inf (order=float(\\\"inf\\\")), we will contract the space to a cube of side length 2.\\n If using voxel based encodings such as the Hash encoder, we recommend using the L_inf norm.\\n\\n Args:\\n order: Order of the norm. Default to the Frobenius norm. Must be set to None for Gaussians.\\n\\n \\\"\\\"\\\"\\n\\n def __init__(self, order: Optional[Union[float, int]] = None) -> None:\\n super().__init__()\\n self.order = order\\n\\n def forward(self, positions):\\n def contract(x):\\n mag = torch.linalg.norm(x, ord=self.order, dim=-1)[..., None]\\n return torch.where(mag < 1, x, (2 - (1 / mag)) * (x / mag))\\n\\n if isinstance(positions, Gaussians):\\n means = contract(positions.mean.clone())\\n\\n contract = lambda x: (2 - (1 / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True))) * (\\n x / torch.linalg.norm(x, ord=self.order, dim=-1, keepdim=True)\\n )\\n jc_means = vmap(jacrev(contract))(positions.mean.view(-1, positions.mean.shape[-1]))\\n jc_means = jc_means.view(list(positions.mean.shape) + [positions.mean.shape[-1]])\\n\\n # Only update covariances on positions outside the unit sphere\\n mag = positions.mean.norm(dim=-1)\\n mask = mag >= 1\\n cov = positions.cov.clone()\\n cov[mask] = jc_means[mask] @ positions.cov[mask] @ torch.transpose(jc_means[mask], -2, -1)\\n\\n return Gaussians(mean=means, cov=cov)\\n\\n return contract(positions)\"\n },\n {\n \"identifier\": \"HashMLPDensityField\",\n \"path\": \"nerfstudio/fields/density_fields.py\",\n \"snippet\": \"class HashMLPDensityField(Field):\\n \\\"\\\"\\\"A lightweight density field module.\\n\\n Args:\\n aabb: parameters of scene aabb bounds\\n num_layers: number of hidden layers\\n hidden_dim: dimension of hidden layers\\n spatial_distortion: spatial distortion module\\n use_linear: whether to skip the MLP and use a single linear layer instead\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n aabb: TensorType,\\n num_layers: int = 2,\\n hidden_dim: int = 64,\\n spatial_distortion: Optional[SpatialDistortion] = None,\\n use_linear: bool = False,\\n num_levels: int = 8,\\n max_res: int = 1024,\\n base_res: int = 16,\\n log2_hashmap_size: int = 18,\\n features_per_level: int = 2,\\n ) -> None:\\n super().__init__()\\n self.register_buffer(\\\"aabb\\\", aabb)\\n self.spatial_distortion = spatial_distortion\\n self.use_linear = use_linear\\n growth_factor = np.exp((np.log(max_res) - np.log(base_res)) / (num_levels - 1))\\n\\n self.register_buffer(\\\"max_res\\\", torch.tensor(max_res))\\n self.register_buffer(\\\"num_levels\\\", torch.tensor(num_levels))\\n self.register_buffer(\\\"log2_hashmap_size\\\", torch.tensor(log2_hashmap_size))\\n\\n config = {\\n \\\"encoding\\\": {\\n \\\"otype\\\": \\\"HashGrid\\\",\\n \\\"n_levels\\\": num_levels,\\n \\\"n_features_per_level\\\": features_per_level,\\n \\\"log2_hashmap_size\\\": log2_hashmap_size,\\n \\\"base_resolution\\\": base_res,\\n \\\"per_level_scale\\\": growth_factor,\\n },\\n \\\"network\\\": {\\n \\\"otype\\\": \\\"FullyFusedMLP\\\",\\n \\\"activation\\\": \\\"ReLU\\\",\\n \\\"output_activation\\\": \\\"None\\\",\\n \\\"n_neurons\\\": hidden_dim,\\n \\\"n_hidden_layers\\\": num_layers - 1,\\n },\\n }\\n\\n if not self.use_linear:\\n self.mlp_base = tcnn.NetworkWithInputEncoding(\\n n_input_dims=3,\\n n_output_dims=1,\\n encoding_config=config[\\\"encoding\\\"],\\n network_config=config[\\\"network\\\"],\\n )\\n else:\\n self.encoding = tcnn.Encoding(n_input_dims=3, encoding_config=config[\\\"encoding\\\"])\\n self.linear = torch.nn.Linear(self.encoding.n_output_dims, 1)\\n\\n def get_density(self, ray_samples: RaySamples) -> Tuple[TensorType, None]:\\n if self.spatial_distortion is not None:\\n positions = self.spatial_distortion(ray_samples.frustums.get_positions())\\n positions = (positions + 2.0) / 4.0\\n else:\\n positions = SceneBox.get_normalized_positions(ray_samples.frustums.get_positions(), self.aabb)\\n # Make sure the tcnn gets inputs between 0 and 1.\\n selector = ((positions > 0.0) & (positions < 1.0)).all(dim=-1)\\n positions = positions * selector[..., None]\\n positions_flat = positions.view(-1, 3)\\n if not self.use_linear:\\n density_before_activation = (\\n self.mlp_base(positions_flat).view(*ray_samples.frustums.shape, -1).to(positions)\\n )\\n else:\\n x = self.encoding(positions_flat).to(positions)\\n density_before_activation = self.linear(x).view(*ray_samples.frustums.shape, -1)\\n\\n # Rectifying the density with an exponential is much more stable than a ReLU or\\n # softplus, because it enables high post-activation (float32) density outputs\\n # from smaller internal (float16) parameters.\\n density = trunc_exp(density_before_activation)\\n density = density * selector[..., None]\\n return density, None\\n\\n def get_outputs(self, ray_samples: RaySamples, density_embedding: Optional[TensorType] = None) -> dict:\\n return {}\"\n },\n {\n \"identifier\": \"NearFarCollider\",\n \"path\": \"nerfstudio/model_components/scene_colliders.py\",\n \"snippet\": \"class NearFarCollider(SceneCollider):\\n \\\"\\\"\\\"Sets the nears and fars with fixed values.\\n\\n Args:\\n near_plane: distance to near plane\\n far_plane: distance to far plane\\n \\\"\\\"\\\"\\n\\n def __init__(self, near_plane: float, far_plane: float, **kwargs) -> None:\\n self.near_plane = near_plane\\n self.far_plane = far_plane\\n super().__init__(**kwargs)\\n\\n def set_nears_and_fars(self, ray_bundle: RayBundle) -> RayBundle:\\n ones = torch.ones_like(ray_bundle.origins[..., 0:1])\\n near_plane = self.near_plane if self.training else 0\\n ray_bundle.nears = ones * near_plane\\n ray_bundle.fars = ones * self.far_plane\\n return ray_bundle\"\n },\n {\n \"identifier\": \"NormalsShader\",\n \"path\": \"nerfstudio/model_components/shaders.py\",\n \"snippet\": \"class NormalsShader(nn.Module):\\n \\\"\\\"\\\"Calculate shading for normals.\\\"\\\"\\\"\\n\\n @classmethod\\n def forward(\\n cls,\\n normals: TensorType[\\\"bs\\\":..., 3],\\n weights: Optional[TensorType[\\\"bs\\\":..., 1]] = None,\\n ):\\n \\\"\\\"\\\"Applies a rainbow colormap to the normals.\\n\\n Args:\\n normals: Normalized 3D vectors.\\n weights: Optional weights to scale to the normal colors. (Can be used for masking)\\n\\n Returns:\\n Colored normals\\n \\\"\\\"\\\"\\n normals = (normals + 1) / 2\\n if weights is not None:\\n normals = normals * weights\\n return normals\"\n },\n {\n \"identifier\": \"Model\",\n \"path\": \"nerfstudio/models/base_model.py\",\n \"snippet\": \"class Model(nn.Module):\\n \\\"\\\"\\\"Model class\\n Where everything (Fields, Optimizers, Samplers, Visualization, etc) is linked together. This should be\\n subclassed for custom NeRF model.\\n\\n Args:\\n config: configuration for instantiating model\\n scene_box: dataset scene box\\n \\\"\\\"\\\"\\n\\n config: ModelConfig\\n\\n def __init__(\\n self,\\n config: ModelConfig,\\n scene_box: SceneBox,\\n num_train_data: int,\\n **kwargs,\\n ) -> None:\\n super().__init__()\\n self.config = config\\n self.scene_box = scene_box\\n self.render_aabb = None # the box that we want to render - should be a subset of scene_box\\n self.num_train_data = num_train_data\\n self.kwargs = kwargs\\n self.collider = None\\n\\n self.populate_modules() # populate the modules\\n self.callbacks = None\\n # to keep track of which device the nn.Module is on\\n self.device_indicator_param = nn.Parameter(torch.empty(0))\\n\\n @property\\n def device(self):\\n \\\"\\\"\\\"Returns the device that the model is on.\\\"\\\"\\\"\\n return self.device_indicator_param.device\\n\\n def get_training_callbacks( # pylint:disable=no-self-use\\n self, training_callback_attributes: TrainingCallbackAttributes # pylint: disable=unused-argument\\n ) -> List[TrainingCallback]:\\n \\\"\\\"\\\"Returns a list of callbacks that run functions at the specified training iterations.\\\"\\\"\\\"\\n return []\\n\\n def populate_modules(self):\\n \\\"\\\"\\\"Set the necessary modules to get the network working.\\\"\\\"\\\"\\n # default instantiates optional modules that are common among many networks\\n # NOTE: call `super().populate_modules()` in subclasses\\n\\n if self.config.enable_collider:\\n self.collider = NearFarCollider(\\n near_plane=self.config.collider_params[\\\"near_plane\\\"], far_plane=self.config.collider_params[\\\"far_plane\\\"]\\n )\\n\\n @abstractmethod\\n def get_param_groups(self) -> Dict[str, List[Parameter]]:\\n \\\"\\\"\\\"Obtain the parameter groups for the optimizers\\n\\n Returns:\\n Mapping of different parameter groups\\n \\\"\\\"\\\"\\n\\n @abstractmethod\\n def get_outputs(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Takes in a Ray Bundle and returns a dictionary of outputs.\\n\\n Args:\\n ray_bundle: Input bundle of rays. This raybundle should have all the\\n needed information to compute the outputs.\\n\\n Returns:\\n Outputs of model. (ie. rendered colors)\\n \\\"\\\"\\\"\\n\\n def forward(self, ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Run forward starting with a ray bundle. This outputs different things depending on the configuration\\n of the model and whether or not the batch is provided (whether or not we are training basically)\\n\\n Args:\\n ray_bundle: containing all the information needed to render that ray latents included\\n \\\"\\\"\\\"\\n\\n if self.collider is not None:\\n ray_bundle = self.collider(ray_bundle)\\n\\n return self.get_outputs(ray_bundle)\\n\\n def get_metrics_dict(self, outputs, batch) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Compute and returns metrics.\\n\\n Args:\\n outputs: the output to compute loss dict to\\n batch: ground truth batch corresponding to outputs\\n \\\"\\\"\\\"\\n # pylint: disable=unused-argument\\n # pylint: disable=no-self-use\\n return {}\\n\\n @abstractmethod\\n def get_loss_dict(self, outputs, batch, metrics_dict=None) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Computes and returns the losses dict.\\n\\n Args:\\n outputs: the output to compute loss dict to\\n batch: ground truth batch corresponding to outputs\\n metrics_dict: dictionary of metrics, some of which we can use for loss\\n \\\"\\\"\\\"\\n\\n @torch.no_grad()\\n def get_outputs_for_camera_ray_bundle(self, camera_ray_bundle: RayBundle) -> Dict[str, torch.Tensor]:\\n \\\"\\\"\\\"Takes in camera parameters and computes the output of the model.\\n\\n Args:\\n camera_ray_bundle: ray bundle to calculate outputs over\\n \\\"\\\"\\\"\\n num_rays_per_chunk = self.config.eval_num_rays_per_chunk\\n image_height, image_width = camera_ray_bundle.origins.shape[:2]\\n num_rays = len(camera_ray_bundle)\\n outputs_lists = defaultdict(list)\\n with Timer(\\\"forwarding\\\"):\\n _t1 = time.time()\\n for i in range(0, num_rays, num_rays_per_chunk):\\n start_idx = i\\n end_idx = i + num_rays_per_chunk\\n ray_bundle = camera_ray_bundle.get_row_major_sliced_ray_bundle(start_idx, end_idx)\\n outputs = self.forward(ray_bundle=ray_bundle)\\n for output_name, output in outputs.items(): # type: ignore\\n outputs_lists[output_name].append(output)\\n print(f\\\"forwarding took {time.time() - _t1} seconds\\\")\\n outputs = {}\\n for output_name, outputs_list in outputs_lists.items():\\n if not torch.is_tensor(outputs_list[0]):\\n # TODO: handle lists of tensors as well\\n continue\\n if output_name == \\\"mask_val\\\":\\n outputs[\\\"mask_val\\\"] = torch.cat(outputs_list, dim=0)\\n outputs[output_name] = torch.cat(outputs_list).view(image_height, image_width, -1) # type: ignore\\n return outputs\\n\\n @abstractmethod\\n def get_image_metrics_and_images(\\n self, outputs: Dict[str, torch.Tensor], batch: Dict[str, torch.Tensor]\\n ) -> Tuple[Dict[str, float], Dict[str, torch.Tensor]]:\\n \\\"\\\"\\\"Writes the test image outputs.\\n TODO: This shouldn't return a loss\\n\\n Args:\\n image_idx: Index of the image.\\n step: Current step.\\n batch: Batch of data.\\n outputs: Outputs of the model.\\n\\n Returns:\\n A dictionary of metrics.\\n \\\"\\\"\\\"\\n\\n def load_model(self, loaded_state: Dict[str, Any]) -> None:\\n \\\"\\\"\\\"Load the checkpoint from the given path\\n\\n Args:\\n loaded_state: dictionary of pre-trained model states\\n \\\"\\\"\\\"\\n state = {key.replace(\\\"module.\\\", \\\"\\\"): value for key, value in loaded_state[\\\"model\\\"].items()}\\n self.load_state_dict(state) # type: ignore\\n\\n def update_to_step(self, step: int) -> None:\\n \\\"\\\"\\\"Called when loading a model from a checkpoint. Sets any model parameters that change over\\n training to the correct value, based on the training step of the checkpoint.\\n\\n Args:\\n step: training step of the loaded checkpoint\\n \\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"ModelConfig\",\n \"path\": \"nerfstudio/models/base_model.py\",\n \"snippet\": \"class ModelConfig(InstantiateConfig):\\n \\\"\\\"\\\"Configuration for model instantiation\\\"\\\"\\\"\\n\\n _target: Type = field(default_factory=lambda: Model)\\n \\\"\\\"\\\"target class to instantiate\\\"\\\"\\\"\\n enable_collider: bool = True\\n \\\"\\\"\\\"Whether to create a scene collider to filter rays.\\\"\\\"\\\"\\n collider_params: Optional[Dict[str, float]] = to_immutable_dict({\\\"near_plane\\\": 2.0, \\\"far_plane\\\": 6.0})\\n \\\"\\\"\\\"parameters to instantiate scene collider with\\\"\\\"\\\"\\n loss_coefficients: Dict[str, float] = to_immutable_dict({\\\"rgb_loss_coarse\\\": 1.0, \\\"rgb_loss_fine\\\": 1.0})\\n \\\"\\\"\\\"parameters to instantiate density field with\\\"\\\"\\\"\\n eval_num_rays_per_chunk: int = 4096\\n \\\"\\\"\\\"specifies number of rays per chunk during eval\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"colormaps\",\n \"path\": \"nerfstudio/utils/colormaps.py\",\n \"snippet\": \"def apply_colormap(image: TensorType[\\\"bs\\\":..., 1], cmap=\\\"viridis\\\") -> TensorType[\\\"bs\\\":..., \\\"rgb\\\":3]:\\ndef apply_depth_colormap(\\n depth: TensorType[\\\"bs\\\":..., 1],\\n accumulation: Optional[TensorType[\\\"bs\\\":..., 1]] = None,\\n near_plane: Optional[float] = None,\\n far_plane: Optional[float] = None,\\n cmap=\\\"turbo\\\",\\n) -> TensorType[\\\"bs\\\":..., \\\"rgb\\\":3]:\\ndef apply_boolean_colormap(\\n image: TensorType[\\\"bs\\\":..., 1, bool],\\n true_color: TensorType[\\\"bs\\\":..., \\\"rgb\\\":3] = colors.WHITE,\\n false_color: TensorType[\\\"bs\\\":..., \\\"rgb\\\":3] = colors.BLACK,\\n) -> TensorType[\\\"bs\\\":..., \\\"rgb\\\":3]:\"\n },\n {\n \"identifier\": \"RayBundle\",\n \"path\": \"nerfstudio/cameras/rays.py\",\n \"snippet\": \"class RayBundle(TensorDataclass):\\n \\\"\\\"\\\"A bundle of ray parameters.\\\"\\\"\\\"\\n\\n # TODO(ethan): make sure the sizes with ... are correct\\n origins: TensorType[..., 3]\\n \\\"\\\"\\\"Ray origins (XYZ)\\\"\\\"\\\"\\n directions: TensorType[..., 3]\\n \\\"\\\"\\\"Unit ray direction vector\\\"\\\"\\\"\\n pixel_area: TensorType[..., 1]\\n \\\"\\\"\\\"Projected area of pixel a distance 1 away from origin\\\"\\\"\\\"\\n camera_indices: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Camera indices\\\"\\\"\\\"\\n nears: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Distance along ray to start sampling\\\"\\\"\\\"\\n fars: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Rays Distance along ray to stop sampling\\\"\\\"\\\"\\n metadata: Optional[Dict[str, TensorType[\\\"num_rays\\\", \\\"latent_dims\\\"]]] = None\\n \\\"\\\"\\\"Additional metadata or data needed for interpolation, will mimic shape of rays\\\"\\\"\\\"\\n times: Optional[TensorType[..., 1]] = None\\n \\\"\\\"\\\"Times at which rays are sampled\\\"\\\"\\\"\\n\\n def set_camera_indices(self, camera_index: int) -> None:\\n \\\"\\\"\\\"Sets all of the the camera indices to a specific camera index.\\n\\n Args:\\n camera_index: Camera index.\\n \\\"\\\"\\\"\\n self.camera_indices = torch.ones_like(self.origins[..., 0:1]).long() * camera_index\\n\\n def __len__(self) -> int:\\n num_rays = torch.numel(self.origins) // self.origins.shape[-1]\\n return num_rays\\n\\n def sample(self, num_rays: int) -> \\\"RayBundle\\\":\\n \\\"\\\"\\\"Returns a RayBundle as a subset of rays.\\n\\n Args:\\n num_rays: Number of rays in output RayBundle\\n\\n Returns:\\n RayBundle with subset of rays.\\n \\\"\\\"\\\"\\n assert num_rays <= len(self)\\n indices = random.sample(range(len(self)), k=num_rays)\\n return self[indices]\\n\\n def get_row_major_sliced_ray_bundle(self, start_idx: int, end_idx: int) -> \\\"RayBundle\\\":\\n \\\"\\\"\\\"Flattens RayBundle and extracts chunk given start and end indices.\\n\\n Args:\\n start_idx: Start index of RayBundle chunk.\\n end_idx: End index of RayBundle chunk.\\n\\n Returns:\\n Flattened RayBundle with end_idx-start_idx rays.\\n\\n \\\"\\\"\\\"\\n return self.flatten()[start_idx:end_idx]\\n\\n def get_ray_samples(\\n self,\\n bin_starts: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n bin_ends: TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1],\\n spacing_starts: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None,\\n spacing_ends: Optional[TensorType[\\\"bs\\\":..., \\\"num_samples\\\", 1]] = None,\\n spacing_to_euclidean_fn: Optional[Callable] = None,\\n ) -> RaySamples:\\n \\\"\\\"\\\"Produces samples for each ray by projection points along the ray direction. Currently samples uniformly.\\n\\n Args:\\n bin_starts: Distance from origin to start of bin.\\n bin_ends: Distance from origin to end of bin.\\n\\n Returns:\\n Samples projected along ray.\\n \\\"\\\"\\\"\\n deltas = bin_ends - bin_starts\\n if self.camera_indices is not None:\\n camera_indices = self.camera_indices[..., None]\\n else:\\n camera_indices = None\\n\\n shaped_raybundle_fields = self[..., None]\\n\\n frustums = Frustums(\\n origins=shaped_raybundle_fields.origins, # [..., 1, 3]\\n directions=shaped_raybundle_fields.directions, # [..., 1, 3]\\n starts=bin_starts, # [..., num_samples, 1]\\n ends=bin_ends, # [..., num_samples, 1]\\n pixel_area=shaped_raybundle_fields.pixel_area, # [..., 1, 1]\\n )\\n\\n ray_samples = RaySamples(\\n frustums=frustums,\\n camera_indices=camera_indices, # [..., 1, 1]\\n deltas=deltas, # [..., num_samples, 1]\\n spacing_starts=spacing_starts, # [..., num_samples, 1]\\n spacing_ends=spacing_ends, # [..., num_samples, 1]\\n spacing_to_euclidean_fn=spacing_to_euclidean_fn,\\n metadata=shaped_raybundle_fields.metadata,\\n times=None if self.times is None else self.times[..., None], # [..., 1, 1]\\n )\\n\\n return ray_samples\"\n },\n {\n \"identifier\": \"TrainingCallback\",\n \"path\": \"nerfstudio/engine/callbacks.py\",\n \"snippet\": \"class TrainingCallback:\\n \\\"\\\"\\\"Callback class used during training.\\n The function 'func' with 'args' and 'kwargs' will be called every 'update_every_num_iters' training iterations,\\n including at iteration 0. The function is called after the training iteration.\\n\\n Args:\\n where_to_run: List of locations for when to run callback (before/after iteration)\\n func: The function that will be called.\\n update_every_num_iters: How often to call the function `func`.\\n iters: Tuple of iteration steps to perform callback\\n args: args for the function 'func'.\\n kwargs: kwargs for the function 'func'.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n where_to_run: List[TrainingCallbackLocation],\\n func: Callable,\\n update_every_num_iters: Optional[int] = None,\\n iters: Optional[Tuple[int, ...]] = None,\\n args: Optional[List] = None,\\n kwargs: Optional[Dict] = None,\\n ):\\n assert (\\n \\\"step\\\" in signature(func).parameters.keys()\\n ), f\\\"'step: int' must be an argument in the callback function 'func': {func.__name__}\\\"\\n self.where_to_run = where_to_run\\n self.update_every_num_iters = update_every_num_iters\\n self.iters = iters\\n self.func = func\\n self.args = args if args is not None else []\\n self.kwargs = kwargs if kwargs is not None else {}\\n\\n def run_callback(self, step: int) -> None:\\n \\\"\\\"\\\"Callback to run after training step\\n\\n Args:\\n step: current iteration step\\n \\\"\\\"\\\"\\n if self.update_every_num_iters is not None:\\n if step % self.update_every_num_iters == 0:\\n self.func(*self.args, **self.kwargs, step=step)\\n elif self.iters is not None:\\n if step in self.iters:\\n self.func(*self.args, **self.kwargs, step=step)\\n\\n def run_callback_at_location(self, step: int, location: TrainingCallbackLocation) -> None:\\n \\\"\\\"\\\"Runs the callback if it's supposed to be run at the given location.\\n\\n Args:\\n step: current iteration step\\n location: when to run callback (before/after iteration)\\n \\\"\\\"\\\"\\n if location in self.where_to_run:\\n self.run_callback(step=step)\"\n },\n {\n \"identifier\": \"TrainingCallbackAttributes\",\n \"path\": \"nerfstudio/engine/callbacks.py\",\n \"snippet\": \"class TrainingCallbackAttributes:\\n \\\"\\\"\\\"Attributes that can be used to configure training callbacks.\\n The callbacks can be specified in the Dataloader or Model implementations.\\n Instead of providing access to the entire Trainer object, we only provide these attributes.\\n This should be least prone to errors and fairly clean from a user perspective.\\\"\\\"\\\"\\n\\n # TODO(ethan): type this without circular imports\\n optimizers: Optional[InitVar]\\n \\\"\\\"\\\"optimizers for training\\\"\\\"\\\"\\n grad_scaler: Optional[InitVar]\\n \\\"\\\"\\\"gradient scalers\\\"\\\"\\\"\\n pipeline: Optional[InitVar]\\n \\\"\\\"\\\"reference to training pipeline\\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"TrainingCallbackLocation\",\n \"path\": \"nerfstudio/engine/callbacks.py\",\n \"snippet\": \"class TrainingCallbackLocation(Enum):\\n \\\"\\\"\\\"Enum for specifying where the training callback should be run.\\\"\\\"\\\"\\n\\n BEFORE_TRAIN_ITERATION = auto()\\n AFTER_TRAIN_ITERATION = auto()\"\n },\n {\n \"identifier\": \"ProposalNetworkSamplerSpatial\",\n \"path\": \"MSTH/SpaceTimeHashing/ray_samplers.py\",\n \"snippet\": \"class ProposalNetworkSamplerSpatial(ProposalNetworkSampler):\\n def __init__(\\n self,\\n num_proposal_samples_per_ray: Tuple[int] = ...,\\n num_nerf_samples_per_ray: int = 32,\\n num_proposal_network_iterations: int = 2,\\n single_jitter: bool = True,\\n update_sched: Callable = ...,\\n initial_sampler: Optional[Sampler] = None,\\n middle_distance: int = 1,\\n ) -> None:\\n super(Sampler, self).__init__()\\n self.num_proposal_samples_per_ray = num_proposal_samples_per_ray\\n self.num_nerf_samples_per_ray = num_nerf_samples_per_ray\\n self.num_proposal_network_iterations = num_proposal_network_iterations\\n self.update_sched = update_sched\\n if self.num_proposal_network_iterations < 1:\\n raise ValueError(\\\"num_proposal_network_iterations must be >= 1\\\")\\n\\n # samplers\\n if initial_sampler is None:\\n self.initial_sampler = UniformLinDispPiecewiseSamplerSpatial(\\n single_jitter=single_jitter, middle_distance=middle_distance\\n )\\n else:\\n self.initial_sampler = initial_sampler\\n self.pdf_sampler = PDFSamplerSpatial(include_original=False, single_jitter=single_jitter)\\n\\n self._anneal = 1.0\\n self._steps_since_update = 0\\n self._step = 0\\n\\n def generate_ray_samples(\\n self,\\n ray_bundle: Optional[RayBundle] = None,\\n density_fns: Optional[List[Callable]] = None,\\n ) -> Tuple[RaySamples, List, List, List]:\\n with Timer(\\\"total_ps\\\"):\\n with Timer(\\\"prep\\\"):\\n assert ray_bundle is not None\\n assert density_fns is not None\\n\\n weights_list = []\\n # weights_list_static = []\\n ray_samples_list = []\\n\\n n = self.num_proposal_network_iterations\\n weights = None\\n weights_static = None\\n ray_samples = None\\n updated = self._steps_since_update > self.update_sched(self._step) or self._step < 10\\n # print(n)\\n for i_level in range(n + 1):\\n with Timer(\\\"level\\\"):\\n is_prop = i_level < n\\n num_samples = (\\n self.num_proposal_samples_per_ray[i_level] if is_prop else self.num_nerf_samples_per_ray\\n )\\n # print(\\\"num_samples\\\", num_samples)\\n if i_level == 0:\\n # Uniform sampling because we need to start with some samples\\n with Timer(\\\"initial\\\"):\\n ray_samples = self.initial_sampler(ray_bundle, num_samples=num_samples)\\n else:\\n # PDF sampling based on the last samples and their weights\\n # Perform annealing to the weights. This will be a no-op if self._anneal is 1.0.\\n assert weights is not None\\n with Timer(\\\"anneal\\\"):\\n annealed_weights = torch.pow(weights, self._anneal)\\n self.last_weight = annealed_weights\\n with Timer(\\\"pdf\\\"):\\n ray_samples = self.pdf_sampler(\\n ray_bundle, ray_samples, annealed_weights, num_samples=num_samples\\n )\\n # print(\\\"ray_samples.shape\\\", ray_samples.shape)\\n if is_prop:\\n if updated:\\n # always update on the first step or the inf check in grad scaling crashes\\n # density = density_fns[i_level](ray_samples.frustums.get_positions())\\n with Timer(\\\"updated density_fn query\\\"):\\n density, density_static = density_fns[i_level](spacetime(ray_samples))\\n # print(density.max())\\n else:\\n with Timer(\\\"no_updated density_fn query\\\"):\\n with torch.no_grad():\\n # density = density_fns[i_level](ray_samples.frustums.get_positions())\\n density, density_static = density_fns[i_level](spacetime(ray_samples))\\n # print(\\\"ray_samples.shape\\\", ray_samples.shape)\\n # print(\\\"density.shape\\\", density.shape)\\n with Timer(\\\"get weights\\\"):\\n weights = ray_samples.get_weights(density)\\n with Timer(\\\"append\\\"):\\n weights_list.append(weights) # (num_rays, num_samples)\\n # weights_static = ray_samples.get_weights(density_static)\\n # weights_list_static.append(weights_static) # (num_rays, num_samples)\\n ray_samples_list.append(ray_samples)\\n if updated:\\n self._steps_since_update = 0\\n\\n assert ray_samples is not None\\n return ray_samples, weights_list, ray_samples_list # , weights_list_static\"\n },\n {\n \"identifier\": \"spacetime\",\n \"path\": \"MSTH/SpaceTimeHashing/ray_samplers.py\",\n \"snippet\": \"def spacetime(ray_samples: RaySamples):\\n positions = ray_samples.frustums.get_positions()\\n assert ray_samples.times is not None, \\\"ray samples should contain time information\\\"\\n times = ray_samples.times.unsqueeze(1).repeat(1, positions.size(1), 1).to(positions)\\n # [num_rays, num_samples, 4]\\n return torch.cat([positions, times], dim=-1)\"\n },\n {\n \"identifier\": \"spacetime_concat\",\n \"path\": \"MSTH/SpaceTimeHashing/ray_samplers.py\",\n \"snippet\": \"def spacetime_concat(positions, times):\\n # print(positions.shape)\\n # print(times.shape)\\n if times.dim() < positions.dim():\\n times = times.unsqueeze(1).repeat(1, positions.size(1), 1)\\n return torch.cat([positions, times.to(positions)], dim=-1)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import torch\nimport numpy as np\nimport tinycudann as tcnn\nfrom typing import *\nfrom nerfacc import ContractionType, contract\nfrom torch.nn.parameter import Parameter\nfrom torchtyping import TensorType\nfrom dataclasses import dataclass, field\nfrom nerfstudio.cameras.rays import RaySamples, Frustums, RayBundle\nfrom nerfstudio.data.scene_box import SceneBox\nfrom nerfstudio.field_components.activations import trunc_exp\nfrom nerfstudio.field_components.embedding import Embedding\nfrom nerfstudio.field_components.field_heads import FieldHeadNames\nfrom nerfstudio.fields.base_field import Field\nfrom nerfstudio.model_components.ray_samplers import (\n ProposalNetworkSampler,\n UniformSampler,\n)\nfrom nerfstudio.model_components.renderers import (\n AccumulationRenderer,\n DepthRenderer,\n NormalsRenderer,\n RGBRenderer,\n)\nfrom nerfstudio.field_components.spatial_distortions import (\n SceneContraction,\n SpatialDistortion,\n)\nfrom nerfstudio.model_components.losses import (\n MSELoss,\n distortion_loss,\n interlevel_loss,\n orientation_loss,\n pred_normal_loss,\n)\nfrom torchmetrics import PeakSignalNoiseRatio\nfrom torchmetrics.functional import structural_similarity_index_measure\nfrom torchmetrics.image.lpip import LearnedPerceptualImagePatchSimilarity\nfrom nerfstudio.field_components.spatial_distortions import SceneContraction\nfrom nerfstudio.fields.density_fields import HashMLPDensityField\nfrom nerfstudio.model_components.scene_colliders import NearFarCollider\nfrom nerfstudio.model_components.shaders import NormalsShader\nfrom nerfstudio.models.base_model import Model, ModelConfig\nfrom nerfstudio.utils import colormaps\nfrom nerfstudio.cameras.rays import RayBundle\nfrom nerfstudio.engine.callbacks import (\n TrainingCallback,\n TrainingCallbackAttributes,\n TrainingCallbackLocation,\n)\nfrom MSTH.SpaceTimeHashing.ray_samplers import ProposalNetworkSamplerSpatial, spacetime, spacetime_concat\nfrom rich.console import Console"},"token_num":{"kind":"number","value":17600,"string":"17,600"},"cropped_code":{"kind":"string","value":"\n\nCONSOLE = Console(width=120)\n\nclass SpaceTimeDensityFieldWithPermutation(Field):\n def __init__(\n self,\n aabb: TensorType,\n num_layers: int = 2,\n hidden_dim: int = 64,\n spatial_distortion: Optional[SpatialDistortion] = None,\n use_linear: bool = False,\n num_levels: int = 8,\n max_res: int = 1024,\n base_res: int = 16,\n log2_hashmap_size: int = 18,\n features_per_level: int = 2,\n ) -> None:\n super().__init__()\n self.register_buffer(\"aabb\", aabb)\n self.spatial_distortion = spatial_distortion\n self.use_linear = use_linear\n growth_factor = np.exp((np.log(max_res) - np.log(base_res)) / (num_levels - 1))\n\n self.register_buffer(\"max_res\", torch.tensor(max_res))\n self.register_buffer(\"num_levels\", torch.tensor(num_levels))\n self.register_buffer(\"log2_hashmap_size\", torch.tensor(log2_hashmap_size))\n\n config = {\n \"encoding\": {\n \"otype\": \"HashGrid\",\n \"n_levels\": num_levels,\n \"n_features_per_level\": features_per_level,\n \"log2_hashmap_size\": log2_hashmap_size,\n \"base_resolution\": base_res,\n \"per_level_scale\": growth_factor,\n },\n \"network\": {\n \"otype\": \"FullyFusedMLP\",\n \"activation\": \"ReLU\",\n \"output_activation\": \"None\",\n \"n_neurons\": hidden_dim,\n \"n_hidden_layers\": num_layers - 1,\n },\n }\n\n if not self.use_linear:\n self.mlp_base = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.spatial_mlp_base = tcnn.NetworkWithInputEncoding(\n n_input_dims=3,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.xyzt = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.xtyz = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.xytz = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.txyz = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n \n else:\n self.encoding = tcnn.Encoding(n_input_dims=4, encoding_config=config[\"encoding\"])\n self.linear = torch.nn.Linear(self.encoding.n_output_dims, 1)\n\n"},"all_code":{"kind":"string","value":"\n\nCONSOLE = Console(width=120)\n\nclass SpaceTimeDensityFieldWithPermutation(Field):\n def __init__(\n self,\n aabb: TensorType,\n num_layers: int = 2,\n hidden_dim: int = 64,\n spatial_distortion: Optional[SpatialDistortion] = None,\n use_linear: bool = False,\n num_levels: int = 8,\n max_res: int = 1024,\n base_res: int = 16,\n log2_hashmap_size: int = 18,\n features_per_level: int = 2,\n ) -> None:\n super().__init__()\n self.register_buffer(\"aabb\", aabb)\n self.spatial_distortion = spatial_distortion\n self.use_linear = use_linear\n growth_factor = np.exp((np.log(max_res) - np.log(base_res)) / (num_levels - 1))\n\n self.register_buffer(\"max_res\", torch.tensor(max_res))\n self.register_buffer(\"num_levels\", torch.tensor(num_levels))\n self.register_buffer(\"log2_hashmap_size\", torch.tensor(log2_hashmap_size))\n\n config = {\n \"encoding\": {\n \"otype\": \"HashGrid\",\n \"n_levels\": num_levels,\n \"n_features_per_level\": features_per_level,\n \"log2_hashmap_size\": log2_hashmap_size,\n \"base_resolution\": base_res,\n \"per_level_scale\": growth_factor,\n },\n \"network\": {\n \"otype\": \"FullyFusedMLP\",\n \"activation\": \"ReLU\",\n \"output_activation\": \"None\",\n \"n_neurons\": hidden_dim,\n \"n_hidden_layers\": num_layers - 1,\n },\n }\n\n if not self.use_linear:\n self.mlp_base = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.spatial_mlp_base = tcnn.NetworkWithInputEncoding(\n n_input_dims=3,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.xyzt = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.xtyz = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.xytz = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n self.txyz = tcnn.NetworkWithInputEncoding(\n n_input_dims=4,\n n_output_dims=1,\n encoding_config=config[\"encoding\"],\n network_config=config[\"network\"],\n )\n \n else:\n self.encoding = tcnn.Encoding(n_input_dims=4, encoding_config=config[\"encoding\"])\n self.linear = torch.nn.Linear(self.encoding.n_output_dims, 1)\n"},"next_line":{"kind":"string","value":" def get_density(self, ray_samples: RaySamples) -> Tuple[TensorType, None]:"},"gold_snippet_index":{"kind":"number","value":0,"string":"0"},"created_at":{"kind":"string","value":"2023-10-26 04:39:15+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5685,"cells":{"repo_name":{"kind":"string","value":"chenruduan/OAReactDiff"},"file_path":{"kind":"string","value":"oa_reactdiff/trainer/pl_trainer.py"},"context":{"kind":"list like","value":[{"identifier":"ProcessedQM9","path":"oa_reactdiff/dataset/qm9.py","snippet":"class ProcessedQM9(BaseQM9):\n def __init__(\n self,\n npz_path,\n center=True,\n pad_fragments=2,\n device=\"cpu\",\n zero_charge=False,\n remove_h=False,\n **kwargs,\n ):\n super().__init__(\n npz_path=npz_path,\n center=center,\n device=device,\n zero_charge=zero_charge,\n remove_h=remove_h,\n )\n\n self.n_fragments = pad_fragments + 1\n self.device = torch.device(device)\n\n n_samples = len(self.raw_dataset[\"charges\"])\n self.n_samples = n_samples\n\n self.data = {}\n self.process_molecules(\"raw_dataset\", n_samples, idx=0)\n\n for idx in range(pad_fragments):\n self.patch_dummy_molecules(idx + 1)\n\n self.data[\"condition\"] = [\n torch.zeros(\n size=(1, 1),\n dtype=torch.int64,\n device=self.device,\n )\n for _ in range(self.n_samples)\n ]"},{"identifier":"ProcessedDoubleQM9","path":"oa_reactdiff/dataset/qm9.py","snippet":"class ProcessedDoubleQM9(BaseQM9):\n def __init__(\n self,\n npz_path,\n center=True,\n pad_fragments=1,\n device=\"cpu\",\n zero_charge=False,\n remove_h=False,\n **kwargs,\n ):\n super().__init__(\n npz_path=npz_path,\n center=center,\n device=device,\n zero_charge=zero_charge,\n remove_h=remove_h,\n )\n\n self.n_fragments = pad_fragments + 2\n self.device = torch.device(device)\n n_samples = len(self.raw_dataset[\"charges\"])\n self.n_samples = len(self.raw_dataset[\"charges\"])\n\n self.get_subsets()\n self.get_pairs()\n\n self.data = {}\n self.process_molecules(\"frag1_data\", n_samples, idx=0)\n self.process_molecules(\"frag2_data\", n_samples, idx=1)\n\n for idx in range(pad_fragments):\n self.patch_dummy_molecules(idx + 2)\n\n self.data[\"condition\"] = [\n torch.zeros(\n size=(1, 1),\n dtype=torch.int64,\n device=self.device,\n )\n for _ in range(self.n_samples)\n ]\n\n def get_pairs(self):\n self.frag1_data, self.frag2_data = {}, {}\n frag1_O_idx_1sthalf = np.random.choice(\n len(self.hasO_set[\"charges\"]),\n int(self.n_samples / 2),\n replace=True,\n )\n frag2_N_idx_1sthalf = np.random.choice(\n len(self.hasN_set[\"charges\"]),\n int(self.n_samples / 2),\n replace=True,\n )\n frag1_N_idx_2ndhalf = np.random.choice(\n len(self.hasN_set[\"charges\"]),\n int(self.n_samples / 2),\n replace=True,\n )\n frag2_O_idx_2ndhalf = np.random.choice(\n len(self.hasO_set[\"charges\"]),\n int(self.n_samples / 2),\n replace=True,\n )\n self.frag1_data = {\n key: np.concatenate(\n [\n self.hasO_set[key][frag1_O_idx_1sthalf],\n self.hasN_set[key][frag1_N_idx_2ndhalf],\n ],\n axis=0,\n )\n for key in self.raw_dataset\n }\n self.frag2_data = {\n key: np.concatenate(\n [\n self.hasN_set[key][frag2_N_idx_1sthalf],\n self.hasO_set[key][frag2_O_idx_2ndhalf],\n ],\n axis=0,\n )\n for key in self.raw_dataset\n }"},{"identifier":"ProcessedTripleQM9","path":"oa_reactdiff/dataset/qm9.py","snippet":"class ProcessedTripleQM9(BaseQM9):\n def __init__(\n self,\n npz_path,\n center=True,\n pad_fragments=0,\n device=\"cpu\",\n zero_charge=False,\n remove_h=False,\n **kwargs,\n ):\n super().__init__(\n npz_path=npz_path,\n center=center,\n device=device,\n zero_charge=zero_charge,\n remove_h=remove_h,\n )\n\n self.n_fragments = pad_fragments + 3\n self.device = torch.device(device)\n n_samples = len(self.raw_dataset[\"charges\"])\n self.n_samples = len(self.raw_dataset[\"charges\"])\n\n self.get_subsets()\n self.get_pairs()\n\n self.data = {}\n self.process_molecules(\"frag1_data\", n_samples, idx=0)\n self.process_molecules(\"frag2_data\", n_samples, idx=1)\n self.process_molecules(\"frag3_data\", n_samples, idx=2)\n\n for idx in range(pad_fragments):\n self.patch_dummy_molecules(idx + 3)\n\n self.data[\"condition\"] = [\n torch.zeros(\n size=(1, 1),\n dtype=torch.int64,\n device=self.device,\n )\n for _ in range(self.n_samples)\n ]\n\n def get_pairs(self):\n n1 = int(self.n_samples / 3)\n n2 = int(self.n_samples / 3)\n n3 = self.n_samples - n1 - n2\n self.frag1_data, self.frag2_data = {}, {}\n frag1_O_idx_1_3 = np.random.choice(\n len(self.hasO_set[\"charges\"]),\n n1,\n replace=True,\n )\n frag2_N_idx_1_3 = np.random.choice(\n len(self.hasN_set[\"charges\"]),\n n1,\n replace=True,\n )\n frag3_F_idx_1_3 = np.random.choice(\n len(self.hasF_set[\"charges\"]),\n n1,\n replace=True,\n )\n frag1_F_idx_2_3 = np.random.choice(\n len(self.hasF_set[\"charges\"]),\n n2,\n replace=True,\n )\n frag2_O_idx_2_3 = np.random.choice(\n len(self.hasO_set[\"charges\"]),\n n2,\n replace=True,\n )\n frag3_N_idx_2_3 = np.random.choice(\n len(self.hasN_set[\"charges\"]),\n n2,\n replace=True,\n )\n frag1_N_idx_3_3 = np.random.choice(\n len(self.hasN_set[\"charges\"]),\n n3,\n replace=True,\n )\n frag2_F_idx_3_3 = np.random.choice(\n len(self.hasF_set[\"charges\"]),\n n3,\n replace=True,\n )\n frag3_O_idx_3_3 = np.random.choice(\n len(self.hasO_set[\"charges\"]),\n n3,\n replace=True,\n )\n self.frag1_data = {\n key: np.concatenate(\n [\n self.hasO_set[key][frag1_O_idx_1_3],\n self.hasF_set[key][frag1_F_idx_2_3],\n self.hasN_set[key][frag1_N_idx_3_3],\n ],\n axis=0,\n )\n for key in self.raw_dataset\n }\n self.frag2_data = {\n key: np.concatenate(\n [\n self.hasN_set[key][frag2_N_idx_1_3],\n self.hasO_set[key][frag2_O_idx_2_3],\n self.hasF_set[key][frag2_F_idx_3_3],\n ],\n axis=0,\n )\n for key in self.raw_dataset\n }\n self.frag3_data = {\n key: np.concatenate(\n [\n self.hasF_set[key][frag3_F_idx_1_3],\n self.hasN_set[key][frag3_N_idx_2_3],\n self.hasO_set[key][frag3_O_idx_3_3],\n ],\n axis=0,\n )\n for key in self.raw_dataset\n }"},{"identifier":"ProcessedTS1x","path":"oa_reactdiff/dataset/transition1x.py","snippet":"class ProcessedTS1x(BaseDataset):\n def __init__(\n self,\n npz_path,\n center=True,\n pad_fragments=0,\n device=\"cpu\",\n zero_charge=False,\n remove_h=False,\n single_frag_only=True,\n swapping_react_prod=False,\n append_frag=False,\n reflection=False,\n use_by_ind=False,\n only_ts=False,\n confidence_model=False,\n position_key=\"positions\",\n ediff=None,\n **kwargs,\n ):\n super().__init__(\n npz_path=npz_path,\n center=center,\n device=device,\n zero_charge=zero_charge,\n remove_h=remove_h,\n )\n if confidence_model:\n use_by_ind = False\n if remove_h:\n print(\"remove_h is ignored because it is not reasonble for TS.\")\n if single_frag_only:\n single_frag_inds = np.where(\n np.array(self.raw_dataset[\"single_fragment\"]) == 1\n )[0]\n else:\n single_frag_inds = np.array(range(len(self.raw_dataset[\"single_fragment\"])))\n if use_by_ind:\n use_inds = self.raw_dataset[\"use_ind\"]\n else:\n use_inds = range(len(self.raw_dataset[\"single_fragment\"]))\n single_frag_inds = list(set(single_frag_inds).intersection(set(use_inds)))\n\n data_duplicated = copy.deepcopy(self.raw_dataset)\n for k, mapped_k in FRAG_MAPPING.items():\n for v, val in data_duplicated[k].items():\n self.raw_dataset[k][v] = [val[ii] for ii in single_frag_inds]\n if swapping_react_prod:\n mapped_val = data_duplicated[mapped_k][v]\n self.raw_dataset[k][v] += [\n mapped_val[ii] for ii in single_frag_inds\n ]\n if reflection:\n for k, mapped_k in FRAG_MAPPING.items():\n for v, val in self.raw_dataset[k].items():\n if v in [\"wB97x_6-31G(d).forces\", position_key]:\n self.raw_dataset[k][v] += [reflect_z(_val) for _val in val]\n else:\n self.raw_dataset[k][v] += val\n\n self.reactant = self.raw_dataset[\"reactant\"]\n self.transition_state = self.raw_dataset[\"transition_state\"]\n self.product = self.raw_dataset[\"product\"]\n\n self.n_fragments = pad_fragments + 3\n self.device = torch.device(device)\n n_samples = len(self.reactant[\"charges\"])\n self.n_samples = len(self.reactant[\"charges\"])\n\n self.data = {}\n repeat = 2 if swapping_react_prod else 1\n if confidence_model:\n self.data[\"target\"] = torch.tensor(\n self.raw_dataset[\"target\"] * repeat\n ).unsqueeze(1)\n self.data[\"rmsd\"] = torch.tensor(\n self.raw_dataset[\"rmsd\"] * repeat\n ).unsqueeze(1)\n if ediff is not None:\n self.data[\"ediff\"] = torch.tensor(\n self.raw_dataset[ediff][\"ediff\"] * repeat\n ).unsqueeze(1)\n if not only_ts:\n if not append_frag:\n self.process_molecules(\n \"reactant\", n_samples, idx=0, position_key=position_key\n )\n self.process_molecules(\"transition_state\", n_samples, idx=1)\n self.process_molecules(\n \"product\", n_samples, idx=2, position_key=position_key\n )\n else:\n self.process_molecules(\n \"reactant\",\n n_samples,\n idx=0,\n append_charge=0,\n position_key=position_key,\n )\n self.process_molecules(\n \"transition_state\", n_samples, idx=1, append_charge=1\n )\n self.process_molecules(\n \"product\",\n n_samples,\n idx=2,\n append_charge=0,\n position_key=position_key,\n )\n\n for idx in range(pad_fragments):\n self.patch_dummy_molecules(idx + 3)\n else:\n if not append_frag:\n self.process_molecules(\"transition_state\", n_samples, idx=0)\n else:\n self.process_molecules(\n \"transition_state\", n_samples, idx=0, append_charge=1\n )\n # for idx in range(2):\n # self.patch_dummy_molecules(idx + 1)\n\n self.data[\"condition\"] = [\n torch.zeros(\n size=(1, 1),\n dtype=torch.int64,\n device=self.device,\n )\n for _ in range(self.n_samples)\n ]"},{"identifier":"EGNNDynamics","path":"oa_reactdiff/dynamics/egnn_dynamics.py","snippet":"class EGNNDynamics(BaseDynamics):\n def __init__(\n self,\n model_config: Dict,\n fragment_names: List[str],\n node_nfs: List[int],\n edge_nf: int,\n condition_nf: int = 0,\n pos_dim: int = 3,\n update_pocket_coords: bool = True,\n condition_time: bool = True,\n edge_cutoff: Optional[float] = None,\n model: nn.Module = EGNN,\n device: torch.device = torch.device(\"cuda\"),\n enforce_same_encoding: Optional[List] = None,\n source: Optional[Dict] = None,\n ) -> None:\n r\"\"\"Base dynamics class set up for denoising process.\n\n Args:\n model_config (Dict): config for the equivariant model.\n fragment_names (List[str]): list of names for fragments\n node_nfs (List[int]): list of number of input node attributues.\n edge_nf (int): number of input edge attributes.\n condition_nf (int): number of attributes for conditional generation.\n Defaults to 0.\n pos_dim (int): dimension for position vector. Defaults to 3.\n update_pocket_coords (bool): whether to update positions of everything.\n Defaults to True.\n condition_time (bool): whether to condition on time. Defaults to True.\n edge_cutoff (Optional[float]): cutoff for building intra-fragment edges.\n Defaults to None.\n model (Optional[nn.Module]): Module for equivariant model. Defaults to None.\n \"\"\"\n super().__init__(\n model_config,\n fragment_names,\n node_nfs,\n edge_nf,\n condition_nf,\n pos_dim,\n update_pocket_coords,\n condition_time,\n edge_cutoff,\n model,\n device,\n enforce_same_encoding,\n source=source,\n )\n\n def forward(\n self,\n xh: List[Tensor],\n edge_index: Tensor,\n t: Tensor,\n conditions: Tensor,\n n_frag_switch: Tensor,\n combined_mask: Tensor,\n edge_attr: Optional[Tensor] = None,\n ) -> Tuple[List[Tensor], Tensor]:\n r\"\"\"predict noise /mu.\n\n Args:\n xh (List[Tensor]): list of concatenated tensors for pos and h\n edge_index (Tensor): [n_edge, 2]\n t (Tensor): time tensor. If dim is 1, same for all samples;\n otherwise different t for different samples\n conditions (Tensor): condition tensors\n n_frag_switch (Tensor): [n_nodes], fragment index for each nodes\n combined_mask (Tensor): [n_nodes], sample index for each node\n edge_attr (Optional[Tensor]): [n_edge, dim_edge_attribute]. Defaults to None.\n\n Raises:\n NotImplementedError: The fragement-position-fixed mode is not implement.\n\n Returns:\n Tuple[List[Tensor], Tensor]: updated pos-h and edge attributes\n \"\"\"\n pos = torch.concat(\n [_xh[:, : self.pos_dim].clone() for _xh in xh],\n dim=0,\n )\n h = torch.concat(\n [\n self.encoders[ii](xh[ii][:, self.pos_dim :].clone())\n for ii, name in enumerate(self.fragment_names)\n ],\n dim=0,\n )\n if self.edge_encoder is not None:\n edge_attr = self.edge_encoder(edge_attr)\n\n condition_dim = 0\n if self.condition_time:\n if len(t.size()) == 1:\n # t is the same for all elements in batch.\n h_time = torch.empty_like(h[:, 0:1]).fill_(t.item())\n else:\n # t is different over the batch dimension.\n h_time = t[combined_mask]\n h = torch.cat([h, h_time], dim=1)\n condition_dim += 1\n\n if self.condition_nf > 0:\n h_condition = conditions[combined_mask]\n h = torch.cat([h, h_condition], dim=1)\n condition_dim += self.condition_nf\n\n subgraph_mask = get_subgraph_mask(edge_index, n_frag_switch)\n if self.update_pocket_coords:\n update_coords_mask = None\n else:\n raise NotImplementedError # no need to mask pos for inpainting mode.\n\n h_final, pos_final, edge_attr_final = self.model(\n h,\n pos,\n edge_index,\n edge_attr,\n node_mask=None,\n edge_mask=None,\n update_coords_mask=update_coords_mask,\n subgraph_mask=subgraph_mask[:, None],\n )\n vel = pos_final - pos\n if torch.any(torch.isnan(vel)):\n print(\"Warning: detected nan in pos, resetting EGNN output to randn.\")\n vel = torch.randn_like(vel)\n if torch.any(torch.isnan(vel)):\n print(\"Warning: detected nan in h, resetting EGNN output to randn.\")\n h_final = torch.randn_like(h_final)\n\n h_final = h_final[:, :-condition_dim]\n\n frag_index = self.compute_frag_index(n_frag_switch)\n xh_final = [\n torch.cat(\n [\n self.remove_mean_batch(\n vel[frag_index[ii] : frag_index[ii + 1]],\n combined_mask[frag_index[ii] : frag_index[ii + 1]],\n ),\n self.decoders[ii](h_final[frag_index[ii] : frag_index[ii + 1]]),\n ],\n dim=-1,\n )\n for ii, name in enumerate(self.fragment_names)\n ]\n\n # xh_final = self.enpose_pbc(xh_final)\n\n if edge_attr_final is None or edge_attr_final.size(1) <= max(1, self.dist_dim):\n edge_attr_final = None\n else:\n edge_attr_final = self.edge_decoder(edge_attr_final)\n return xh_final, edge_attr_final\n\n @staticmethod\n def enpose_pbc(xh: List[Tensor], magnitude=10.0) -> List[Tensor]:\n xrange = magnitude * 2\n xh = [torch.remainder(_xh + magnitude, xrange) - magnitude for _xh in xh]\n return xh\n\n @staticmethod\n def compute_frag_index(n_frag_switch: Tensor) -> np.ndarray:\n counts = [\n torch.where(n_frag_switch == ii)[0].numel()\n for ii in torch.unique(n_frag_switch)\n ]\n return np.concatenate([np.array([0]), np.cumsum(counts)])\n\n @torch.no_grad()\n def adjust_edge_attr_on_new_eij(\n self,\n edge_index: Tensor,\n edge_attr: Tensor,\n edge_index_new: Tensor,\n ) -> Tensor:\n r\"\"\"Get ready new edge attributes (e_ij) given old {ij, e_ij} and new {ij}\n\n Args:\n edge_index (Tensor): ij\n edge_attr (Tensor): e_ij\n edge_index_new (Tensor): new ij\n\n Raises:\n ValueError: finding multiple entries for the same ij pair\n\n Returns:\n Tensor: new e_ij\n \"\"\"\n edge_index_T = torch.transpose(edge_index, 1, 0)\n edge_index_new_T = torch.transpose(edge_index_new, 1, 0)\n\n edge_attr_new = []\n for _ind, ij in enumerate(edge_index_new_T):\n ind = torch.where((ij == edge_index_T).all(dim=1))[0]\n if ind.size(0) > 1:\n raise ValueError(f\"ind should only be 0 or 1, getting {ind}\")\n\n if ind.size(0) == 0:\n self.create_new_edge_attr(\n ind_new=_ind,\n ij_new=ij,\n edge_index_new_T=edge_index_new_T,\n edge_attr_new=edge_attr_new,\n edge_attr=edge_attr,\n )\n else:\n edge_attr_new.append(edge_attr[ind.item()].detach())\n return torch.stack(edge_attr_new, dim=0)\n\n @staticmethod\n def init_edge_attr(sample_edge_attr):\n r\"\"\"initialize edge attributes.\"\"\"\n return torch.rand_like(sample_edge_attr)\n\n def create_new_edge_attr(\n self,\n ind_new: Tensor,\n ij_new: Tensor,\n edge_index_new_T: Tensor,\n edge_attr_new: List[Tensor],\n edge_attr: Tensor,\n ) -> List[Tensor]:\n r\"\"\"Create new edge attrbution for ij that is not present in old connections\n\n Args:\n ind_new (Tensor): natural index of new ij\n ij_new (Tensor): new ij\n edge_index_new_T (Tensor): new edge indexes, [n_edge, 2]\n edge_attr_new (List[Tensor]): list of new edge attributes\n edge_attr (Tensor): old edge attributes\n\n Raises:\n ValueError: not ji found for ij in new indexes\n\n Returns:\n List[Tensor]: list of new edge attributes\n \"\"\"\n ij_new_reverse = ij_new[torch.tensor([1, 0])]\n ind_new_reverse = torch.where((ij_new_reverse == edge_index_new_T).all(dim=1))[\n 0\n ]\n print(ind_new_reverse)\n if ind_new_reverse.size(0) == 0:\n raise ValueError(f\"should always find a reverse ind.\")\n # print(ij_new, ind_new, ind_new_reverse)\n if ind_new_reverse.item() >= ind_new:\n edge_attr_new.append(self.init_edge_attr(edge_attr[0]))\n else:\n edge_attr_new.append(edge_attr_new[ind_new_reverse.item()])\n return edge_attr_new\n\n @staticmethod\n def remove_mean_batch(x, indices):\n mean = scatter_mean(x, indices, dim=0)\n x = x - mean[indices]\n return x"},{"identifier":"Confidence","path":"oa_reactdiff/dynamics/confidence.py","snippet":"class Confidence(BaseDynamics):\n def __init__(\n self,\n model_config: Dict,\n fragment_names: List[str],\n node_nfs: List[int],\n edge_nf: int,\n condition_nf: int = 0,\n pos_dim: int = 3,\n edge_cutoff: Optional[float] = None,\n model: nn.Module = EGNN,\n device: torch.device = torch.device(\"cuda\"),\n enforce_same_encoding: Optional[List] = None,\n source: Optional[Dict] = None,\n **kwargs,\n ) -> None:\n r\"\"\"Confindence score for generated samples.\n\n Args:\n model_config (Dict): config for the equivariant model.\n fragment_names (List[str]): list of names for fragments\n node_nfs (List[int]): list of number of input node attributues.\n edge_nf (int): number of input edge attributes.\n condition_nf (int): number of attributes for conditional generation.\n Defaults to 0.\n pos_dim (int): dimension for position vector. Defaults to 3.\n update_pocket_coords (bool): whether to update positions of everything.\n Defaults to True.\n condition_time (bool): whether to condition on time. Defaults to True.\n edge_cutoff (Optional[float]): cutoff for building intra-fragment edges.\n Defaults to None.\n model (Optional[nn.Module]): Module for equivariant model. Defaults to None.\n \"\"\"\n model_config.update({\"for_conf\": True})\n update_pocket_coords = True\n condition_time = (True,)\n super().__init__(\n model_config,\n fragment_names,\n node_nfs,\n edge_nf,\n condition_nf,\n pos_dim,\n update_pocket_coords,\n condition_time,\n edge_cutoff,\n model,\n device,\n enforce_same_encoding,\n source=source,\n )\n\n hidden_channels = model_config[\"hidden_channels\"]\n self.readout = GatedMLP(\n in_dim=hidden_channels,\n out_dims=[hidden_channels, hidden_channels, 1],\n activation=\"swish\",\n bias=True,\n last_layer_no_activation=True,\n )\n\n def _forward(\n self,\n xh: List[Tensor],\n edge_index: Tensor,\n t: Tensor,\n conditions: Tensor,\n n_frag_switch: Tensor,\n combined_mask: Tensor,\n edge_attr: Optional[Tensor] = None,\n ) -> Tensor:\n r\"\"\"predict confidence.\n\n Args:\n xh (List[Tensor]): list of concatenated tensors for pos and h\n edge_index (Tensor): [n_edge, 2]\n t (Tensor): time tensor. If dim is 1, same for all samples;\n otherwise different t for different samples\n conditions (Tensor): condition tensors\n n_frag_switch (Tensor): [n_nodes], fragment index for each nodes\n combined_mask (Tensor): [n_nodes], sample index for each node\n edge_attr (Optional[Tensor]): [n_edge, dim_edge_attribute]. Defaults to None.\n\n Raises:\n NotImplementedError: The fragement-position-fixed mode is not implement.\n\n Returns:\n Tensor: binary probability of confidence fo each graph.\n \"\"\"\n pos = torch.concat(\n [_xh[:, : self.pos_dim].clone() for _xh in xh],\n dim=0,\n )\n h = torch.concat(\n [\n self.encoders[ii](xh[ii][:, self.pos_dim :].clone())\n for ii, name in enumerate(self.fragment_names)\n ],\n dim=0,\n )\n if self.edge_encoder is not None:\n edge_attr = self.edge_encoder(edge_attr)\n\n condition_dim = 0\n if self.condition_time:\n if len(t.size()) == 1:\n # t is the same for all elements in batch.\n h_time = torch.empty_like(h[:, 0:1]).fill_(t.item())\n else:\n # t is different over the batch dimension.\n h_time = t[combined_mask]\n h = torch.cat([h, h_time], dim=1)\n condition_dim += 1\n\n if self.condition_nf > 0:\n h_condition = conditions[combined_mask]\n h = torch.cat([h, h_condition], dim=1)\n condition_dim += self.condition_nf\n\n subgraph_mask = get_subgraph_mask(edge_index, n_frag_switch)\n if self.update_pocket_coords:\n update_coords_mask = None\n else:\n raise NotImplementedError # no need to mask pos for inpainting mode.\n\n node_features = self.model(\n h,\n pos,\n edge_index,\n edge_attr,\n node_mask=None,\n edge_mask=None,\n update_coords_mask=update_coords_mask,\n subgraph_mask=subgraph_mask[:, None],\n ) # (n_node, n_hidden)\n\n graph_features = scatter_mean(\n node_features,\n index=combined_mask,\n dim=0,\n ) # (n_system, n_hidden)\n conf = self.readout(graph_features)\n return conf.squeeze()\n\n def forward(\n self,\n representations: List[Dict],\n conditions: Tensor,\n ):\n masks = [repre[\"mask\"] for repre in representations]\n combined_mask = torch.cat(masks)\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\n fragments_nodes = [repr[\"size\"] for repr in representations]\n n_frag_switch = get_n_frag_switch(fragments_nodes)\n\n xh = [\n torch.cat(\n [repre[feature_type] for feature_type in FEATURE_MAPPING],\n dim=1,\n )\n for repre in representations\n ]\n\n pred = self._forward(\n xh=xh,\n edge_index=edge_index,\n t=torch.tensor([0]),\n conditions=conditions,\n n_frag_switch=n_frag_switch,\n combined_mask=combined_mask,\n edge_attr=None,\n )\n return pred"},{"identifier":"DiffSchedule","path":"oa_reactdiff/diffusion/_schedule.py","snippet":"class DiffSchedule(nn.Module):\n def __init__(self, gamma_module: nn.Module, norm_values: Tuple[float]) -> None:\n super().__init__()\n self.gamma_module = gamma_module\n self.norm_values = norm_values\n self.check_issues_norm_values()\n\n @staticmethod\n def inflate_batch_array(array, target):\n r\"\"\"\n Inflates the batch array (array) with only a single axis\n (i.e. shape = (batch_size,), or possibly more empty axes\n (i.e. shape (batch_size, 1, ..., 1)) to match the target shape.\n \"\"\"\n target_shape = (array.size(0),) + (1,) * (len(target.size()) - 1)\n return array.view(target_shape)\n\n def sigma(self, gamma, target_tensor):\n r\"\"\"Computes sigma given gamma.\"\"\"\n return self.inflate_batch_array(torch.sqrt(torch.sigmoid(gamma)), target_tensor)\n\n def alpha(self, gamma, target_tensor):\n r\"\"\"Computes alpha given gamma.\"\"\"\n return self.inflate_batch_array(\n torch.sqrt(torch.sigmoid(-gamma)), target_tensor\n )\n\n @staticmethod\n def SNR(gamma):\n r\"\"\"Computes signal to noise ratio (alpha^2/sigma^2) given gamma.\"\"\"\n return torch.exp(-gamma)\n\n def sigma_and_alpha_t_given_s(\n self, gamma_t: Tensor, gamma_s: Tensor, target_tensor: Tensor\n ) -> tuple[Tensor, Tensor, Tensor]:\n r\"\"\"\n Computes sigma t given s, using gamma_t and gamma_s. Used during sampling.\n These are defined as:\n alpha t given s = alpha t / alpha s,\n sigma t given s = sqrt(1 - (alpha t given s) ^2 ).\n \"\"\"\n sigma2_t_given_s = self.inflate_batch_array(\n -torch.expm1(F.softplus(gamma_s) - F.softplus(gamma_t)), target_tensor\n )\n\n # alpha_t_given_s = alpha_t / alpha_s\n log_alpha2_t = F.logsigmoid(-gamma_t)\n log_alpha2_s = F.logsigmoid(-gamma_s)\n log_alpha2_t_given_s = log_alpha2_t - log_alpha2_s\n\n alpha_t_given_s = torch.exp(0.5 * log_alpha2_t_given_s)\n alpha_t_given_s = self.inflate_batch_array(alpha_t_given_s, target_tensor)\n\n sigma_t_given_s = torch.sqrt(sigma2_t_given_s)\n\n return sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s\n\n def check_issues_norm_values(self, num_stdevs=8):\n zeros = torch.zeros((1, 1))\n gamma_0 = self.gamma_module(zeros)\n sigma_0 = self.sigma(gamma_0, target_tensor=zeros).item()\n\n # Checked if 1 / norm_value is still larger than 10 * standard\n # deviation.\n norm_value = self.norm_values[1]\n\n if sigma_0 * num_stdevs > 1.0 / norm_value:\n raise ValueError(\n f\"Value for normalization value {norm_value} probably too \"\n f\"large with sigma_0 {sigma_0:.5f} and \"\n f\"1 / norm_value = {1. / norm_value}\"\n )"},{"identifier":"PredefinedNoiseSchedule","path":"oa_reactdiff/diffusion/_schedule.py","snippet":"class PredefinedNoiseSchedule(nn.Module):\n r\"\"\"\n Predefined noise schedule. Essentially creates a lookup array for predefined\n (non-learned) noise schedules.\n \"\"\"\n\n def __init__(\n self,\n noise_schedule: str,\n timesteps: int,\n precision: float,\n ):\n super().__init__()\n self.timesteps = timesteps\n\n if \"cosine\" in noise_schedule:\n splits = noise_schedule.split(\"_\")\n assert len(splits) <= 2\n power = 1 if len(splits) == 1 else float(splits[1])\n alphas2 = cosine_beta_schedule(timesteps, raise_to_power=power)\n elif \"polynomial\" in noise_schedule:\n splits = noise_schedule.split(\"_\")\n assert len(splits) == 2\n power = float(splits[1])\n alphas2 = polynomial_schedule(timesteps, s=precision, power=power)\n elif \"csin\" in noise_schedule:\n splits = noise_schedule.split(\"_\")\n assert len(splits) == 4\n start, end, tau = float(splits[1]), float(splits[2]), float(splits[3])\n alphas2 = ccosine_schedule(timesteps, start=start, end=end, tau=tau)\n elif \"linear\" in noise_schedule:\n alphas2 = linear_schedule(timesteps)\n else:\n raise ValueError(noise_schedule)\n\n # print(\"alphas2\", alphas2)\n\n sigmas2 = 1 - alphas2\n\n log_alphas2 = np.log(alphas2)\n log_sigmas2 = np.log(sigmas2)\n\n log_alphas2_to_sigmas2 = log_alphas2 - log_sigmas2\n\n # print(\"gamma\", -log_alphas2_to_sigmas2)\n\n self.gamma = torch.nn.Parameter(\n torch.from_numpy(-log_alphas2_to_sigmas2).float(), requires_grad=False\n )\n\n def forward(self, t):\n t_int = torch.round(t * self.timesteps).long()\n return self.gamma[t_int]"},{"identifier":"Normalizer","path":"oa_reactdiff/diffusion/_normalizer.py","snippet":"class Normalizer(nn.Module):\n def __init__(\n self,\n norm_values: Tuple = (1.0, 1.0, 1.0),\n norm_biases: Tuple = (0.0, 0.0, 0.0),\n pos_dim: int = 3,\n ) -> None:\n super().__init__()\n self.norm_values = norm_values\n self.norm_biases = norm_biases\n self.pos_dim = pos_dim\n\n def normalize(self, representations: List[Dict]) -> List[Dict]:\n for ii in range(len(representations)):\n for jj, feature_type in enumerate(FEATURE_MAPPING):\n representations[ii][feature_type] = (\n representations[ii][feature_type] - self.norm_biases[jj]\n ) / self.norm_values[jj]\n return representations\n\n def unnormalize(self, x: Tensor, ind: int) -> Tensor:\n return x * self.norm_values[ind] + self.norm_biases[ind]\n\n def unnormalize_z(self, z_combined: List[Tensor]) -> List[Tensor]:\n for ii in range(len(z_combined)):\n z_combined[ii][:, : self.pos_dim] = self.unnormalize(\n z_combined[ii][:, : self.pos_dim], 0\n )\n z_combined[ii][:, self.pos_dim : -1] = self.unnormalize(\n z_combined[ii][:, self.pos_dim : -1], 1\n )\n z_combined[ii][:, -1:] = self.unnormalize(z_combined[ii][:, -1:], 2)\n return z_combined"},{"identifier":"FEATURE_MAPPING","path":"oa_reactdiff/diffusion/_normalizer.py","snippet":"FEATURE_MAPPING = [\"pos\", \"one_hot\", \"charge\"]"},{"identifier":"EnVariationalDiffusion","path":"oa_reactdiff/diffusion/en_diffusion.py","snippet":"class EnVariationalDiffusion(nn.Module):\n \"\"\"\n The E(n) Diffusion Module.\n \"\"\"\n\n def __init__(\n self,\n dynamics: EGNNDynamics,\n schdule: DiffSchedule,\n normalizer: Normalizer,\n size_histogram: Optional[Dict] = None,\n loss_type: str = \"l2\",\n pos_only: bool = False,\n fixed_idx: Optional[List] = None,\n ):\n super().__init__()\n assert loss_type in {\"vlb\", \"l2\"}\n\n self.dynamics = dynamics\n self.schedule = schdule\n self.normalizer = normalizer\n self.size_histogram = size_histogram\n self.loss_type = loss_type\n self.pos_only = pos_only\n self.fixed_idx = fixed_idx or []\n\n self.pos_dim = dynamics.pos_dim\n self.node_nfs = dynamics.node_nfs\n self.fragment_names = dynamics.fragment_names\n self.T = schdule.gamma_module.timesteps\n self.norm_values = normalizer.norm_values\n self.norm_biases = normalizer.norm_biases\n\n # ------ FORWARD PASS ------\n\n def forward(\n self,\n representations: List[Dict],\n conditions: Tensor,\n return_pred: bool = False,\n ):\n r\"\"\"\n Computes the loss and NLL terms.\n\n #TODO: edge_attr not considered at all\n \"\"\"\n num_sample = representations[0][\"size\"].size(0)\n n_nodes = torch.stack(\n [repr[\"size\"] for repr in representations],\n dim=0,\n ).sum(dim=0)\n device = representations[0][\"pos\"].device\n masks = [repre[\"mask\"] for repre in representations]\n combined_mask = torch.cat(masks)\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\n fragments_nodes = [repr[\"size\"] for repr in representations]\n n_frag_switch = get_n_frag_switch(fragments_nodes)\n\n # Normalize data, take into account volume change in x.\n representations = self.normalizer.normalize(representations)\n\n # Likelihood change due to normalization\n delta_log_px = self.delta_log_px(n_nodes.sum())\n\n # Sample a timestep t for each example in batch\n # At evaluation time, loss_0 will be computed separately to decrease\n # variance in the estimator (costs two forward passes)\n lowest_t = 0 if self.training else 1\n t_int = torch.randint(\n lowest_t, self.T + 1, size=(num_sample, 1), device=device\n ).float()\n s_int = t_int - 1 # previous timestep\n\n # Masks: important to compute log p(x | z0).\n t_is_zero = (t_int == 0).float()\n t_is_not_zero = 1 - t_is_zero\n\n # Normalize t to [0, 1]. Note that the negative\n # step of s will never be used, since then p(x | z0) is computed.\n s = s_int / self.T\n t = t_int / self.T\n\n # Compute gamma_s and gamma_t via the network.\n gamma_s = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(s), representations[0][\"pos\"]\n )\n gamma_t = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(t), representations[0][\"pos\"]\n )\n\n # Concatenate x, and h[categorical].\n xh = [\n torch.cat(\n [repre[feature_type] for feature_type in FEATURE_MAPPING],\n dim=1,\n )\n for repre in representations\n ]\n\n # Find noised representation\n z_t, eps_xh = self.noised_representation(xh, masks, gamma_t)\n\n # Neural net prediction.\n net_eps_xh, net_eps_edge_attr = self.dynamics(\n xh=z_t,\n edge_index=edge_index,\n t=t,\n conditions=conditions,\n n_frag_switch=n_frag_switch,\n combined_mask=combined_mask,\n edge_attr=None, # TODO: no edge_attr is considered now\n )\n\n if return_pred:\n return eps_xh, net_eps_xh\n\n # TODO: LJ term not implemented\n # xh_lig_hat = self.xh_given_zt_and_epsilon(z_t_lig, net_out_lig, gamma_t,\n # ligand['mask'])\n if self.pos_only:\n for ii in range(len(masks)):\n net_eps_xh[ii][:, self.pos_dim :] = torch.zeros_like(\n net_eps_xh[ii][:, self.pos_dim :],\n device=device,\n )\n # Compute the L2 error.\n error_t: List[Tensor] = [\n utils.sum_except_batch(\n (eps_xh[ii] - net_eps_xh[ii]) ** 2,\n masks[ii],\n dim_size=num_sample,\n )\n for ii in range(len(masks))\n ] # TODO: no edge_attr contribution\n\n # Compute weighting with SNR: (1 - SNR(s-t)) for epsilon parametrization\n SNR_weight = (1 - self.schedule.SNR(gamma_s - gamma_t)).squeeze(1)\n assert error_t[0].size() == SNR_weight.size()\n\n # The _constants_ depending on sigma_0 from the\n # cross entropy term E_q(z0 | x) [log p(x | z0)].\n neg_log_constants = -self.log_constants_p_x_given_z0(\n n_nodes=n_nodes, device=device\n )\n\n # The KL between q(zT | x) and p(zT) = Normal(0, 1).\n # Should be close to zero.\n # kl_prior = self.kl_prior_with_pocket(\n # xh_lig, xh_pocket, ligand['mask'], pocket['mask'],\n # ligand['size'] + pocket['size'])\n # TODO: approximate KL prior with zero now, which should not influence training.\n kl_prior = torch.zeros_like(neg_log_constants)\n\n if self.training:\n # Computes the L_0 term (even if gamma_t is not actually gamma_0)\n # and this will later be selected via masking.\n log_p_h_given_z0 = self.log_pxh_given_z0_without_constants(\n representations=representations,\n z_t=z_t,\n eps_xh=eps_xh,\n net_eps_xh=net_eps_xh,\n gamma_t=gamma_t,\n epsilon=1e-10,\n )\n loss_0_x = [\n -_log_p_fragment * t_is_zero.squeeze()\n for _log_p_fragment in log_p_h_given_z0[0]\n ]\n loss_0_cat = [\n -_log_p_fragment * t_is_zero.squeeze()\n for _log_p_fragment in log_p_h_given_z0[1]\n ]\n loss_0_charge = [\n -_log_p_fragment * t_is_zero.squeeze()\n for _log_p_fragment in log_p_h_given_z0[2]\n ]\n\n # apply t_is_zero mask\n error_t = [_error_t * t_is_not_zero.squeeze() for _error_t in error_t]\n\n else:\n # Compute noise values for t = 0.\n t_zeros = torch.zeros_like(s)\n gamma_0 = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(t_zeros), representations[0][\"pos\"]\n )\n\n # Sample z_0 given x, h for timestep t, from q(z_t | x, h)\n z_0, eps_0_xh = self.noised_representation(xh, masks, gamma_0)\n net_eps_0_xh, net_eps_0_edge_attr = self.dynamics(\n xh=z_0,\n edge_index=edge_index,\n t=t_zeros,\n conditions=conditions,\n n_frag_switch=n_frag_switch,\n combined_mask=combined_mask,\n edge_attr=None, # TODO: no edge_attr is considered now\n )\n\n log_p_h_given_z0 = self.log_pxh_given_z0_without_constants(\n representations=representations,\n z_t=z_0,\n eps_xh=eps_0_xh,\n net_eps_xh=net_eps_0_xh,\n gamma_t=gamma_0,\n epsilon=1e-10,\n )\n loss_0_x = [-_log_p_fragment for _log_p_fragment in log_p_h_given_z0[0]]\n loss_0_cat = [-_log_p_fragment for _log_p_fragment in log_p_h_given_z0[1]]\n loss_0_charge = [\n -_log_p_fragment for _log_p_fragment in log_p_h_given_z0[2]\n ]\n\n loss_terms = {\n \"delta_log_px\": delta_log_px,\n \"error_t\": error_t,\n \"SNR_weight\": SNR_weight,\n \"loss_0_x\": loss_0_x,\n \"loss_0_cat\": loss_0_cat,\n \"loss_0_charge\": loss_0_charge,\n \"neg_log_constants\": neg_log_constants,\n \"kl_prior\": kl_prior,\n \"log_pN\": torch.zeros_like(kl_prior),\n \"t_int\": t_int.squeeze(),\n \"net_eps_xh\": net_eps_xh,\n \"eps_xh\": eps_xh,\n }\n return loss_terms\n\n def delta_log_px(self, num_nodes):\n return -self.subspace_dimensionality(num_nodes) * np.log(self.norm_values[0])\n\n def subspace_dimensionality(self, input_size):\n r\"\"\"\n Compute the dimensionality on translation-invariant linear subspace\n where distributions on x are defined.\n \"\"\"\n return (input_size - 1) * self.pos_dim\n\n def noised_representation(\n self,\n xh: List[Tensor],\n masks: List[Tensor],\n gamma_t: Tensor,\n ) -> Tuple[List[Tensor], List[Tensor]]:\n # Compute alpha_t and sigma_t from gamma.\n alpha_t = self.schedule.alpha(gamma_t, xh[0])\n sigma_t = self.schedule.sigma(gamma_t, xh[0])\n\n # Sample zt ~ Normal(alpha_t x, sigma_t)\n eps_xh = self.sample_combined_position_feature_noise(masks)\n\n # Sample z_t given x, h for timestep t, from q(z_t | x, h)\n z_t = [\n alpha_t[masks[ii]] * xh[ii] + sigma_t[masks[ii]] * eps_xh[ii]\n for ii in range(len(masks))\n ]\n\n return z_t, eps_xh\n\n def sample_combined_position_feature_noise(\n self,\n masks: List[Tensor],\n ) -> List[Tensor]:\n r\"\"\"\n Samples mean-centered normal noise for z_x, and standard normal noise for z_h.\n Note that we only need to put the center of gravity of *each fragment* to the origin.\n \"\"\"\n eps_xh = []\n for ii, mask in enumerate(masks):\n _eps_x = utils.sample_center_gravity_zero_gaussian_batch(\n size=(len(mask), self.pos_dim),\n indices=[mask],\n )\n _eps_h = utils.sample_gaussian(\n size=(len(mask), self.node_nfs[ii] - self.pos_dim),\n device=mask.device,\n )\n if self.pos_only:\n _eps_h = torch.zeros_like(_eps_h, device=mask.device)\n eps_xh.append(torch.cat([_eps_x, _eps_h], dim=1))\n for idx in self.fixed_idx:\n eps_xh[idx] = torch.zeros_like(eps_xh[idx], device=mask.device)\n return eps_xh\n\n def log_constants_p_x_given_z0(self, n_nodes, device):\n r\"\"\"Computes p(x|z0).\"\"\"\n\n batch_size = len(n_nodes)\n degrees_of_freedom_x = self.subspace_dimensionality(n_nodes).to(device)\n\n zeros = torch.zeros((batch_size, 1), device=device)\n gamma_0 = self.schedule.gamma_module(zeros)\n\n # Recall that sigma_x = sqrt(sigma_0^2 / alpha_0^2) = SNR(-0.5 gamma_0).\n log_sigma_x = 0.5 * gamma_0.view(batch_size)\n return degrees_of_freedom_x * (-log_sigma_x - 0.5 * np.log(2 * np.pi))\n\n def kl_prior(self):\n return NotImplementedError\n\n @staticmethod\n def gaussian_KL(q_mu_minus_p_mu_squared, q_sigma, p_sigma, d):\n \"\"\"Computes the KL distance between two normal distributions.\n Args:\n q_mu_minus_p_mu_squared: Squared difference between mean of\n distribution q and distribution p: ||mu_q - mu_p||^2\n q_sigma: Standard deviation of distribution q.\n p_sigma: Standard deviation of distribution p.\n d: dimension\n Returns:\n The KL distance\n \"\"\"\n return (\n d * torch.log(p_sigma / q_sigma)\n + 0.5 * (d * q_sigma**2 + q_mu_minus_p_mu_squared) / (p_sigma**2)\n - 0.5 * d\n )\n\n def log_pxh_given_z0_without_constants(\n self,\n representations: List[Dict],\n z_t: List[Tensor],\n eps_xh: List[Tensor],\n net_eps_xh: List[Tensor],\n gamma_t: Tensor,\n epsilon: float = 1e-10,\n ) -> List[List[Tensor]]:\n # Compute sigma_0 and rescale to the integer scale of the data.\n # for pos\n log_p_x_given_z0_without_constants = [\n -0.5\n * (\n utils.sum_except_batch(\n (eps_xh[ii][:, : self.pos_dim] - net_eps_xh[ii][:, : self.pos_dim])\n ** 2,\n representations[ii][\"mask\"],\n dim_size=representations[0][\"size\"].size(0),\n )\n )\n for ii in range(len(representations))\n ]\n\n # only keep first several elements\n z_t = [_z_t[:, : 3 + 5 + 1] for _z_t in z_t]\n for ii, repr in enumerate(representations):\n representations[ii][\"charge\"] = representations[ii][\"charge\"][:, :1]\n # for ohe of atom types\n sigma_0 = self.schedule.sigma(gamma_t, target_tensor=z_t[0])\n sigma_0_cat = sigma_0 * self.normalizer.norm_values[1]\n atoms = [\n self.normalizer.unnormalize(repr[\"one_hot\"], ind=1)\n for repr in representations\n ]\n est_atoms = [\n self.normalizer.unnormalize(_z_t[:, self.pos_dim : -1], ind=1)\n for _z_t in z_t\n ]\n centered_atoms = [_est_atoms - 1 for _est_atoms in est_atoms]\n log_ph_cat_proportionals = [\n torch.log(\n utils.cdf_standard_gaussian(\n (centered_atoms[ii] + 0.5)\n / sigma_0_cat[representations[ii][\"mask\"]]\n )\n - utils.cdf_standard_gaussian(\n (centered_atoms[ii] - 0.5)\n / sigma_0_cat[representations[ii][\"mask\"]]\n )\n + epsilon\n )\n for ii in range(len(representations))\n ]\n log_probabilities = [\n _log_ph_cat_proportionals\n - torch.logsumexp(\n _log_ph_cat_proportionals,\n dim=1,\n keepdim=True,\n )\n for _log_ph_cat_proportionals in log_ph_cat_proportionals\n ]\n log_p_hcat_given_z0 = [\n utils.sum_except_batch(\n log_probabilities[ii] * atoms[ii],\n representations[ii][\"mask\"],\n dim_size=representations[0][\"size\"].size(0),\n )\n for ii in range(len(representations))\n ]\n\n # for atom charge\n sigma_0_charge = sigma_0 * self.normalizer.norm_values[2]\n charges = [\n self.normalizer.unnormalize(repr[\"charge\"], ind=2)\n for repr in representations\n ]\n est_charges = [\n self.normalizer.unnormalize(_z_t[:, -1:], ind=2).long() for _z_t in z_t\n ]\n for ii in range(len(representations)):\n assert charges[ii].size() == est_charges[ii].size()\n centered_charges = [\n charges[ii] - est_charges[ii] for ii in range(len(representations))\n ]\n log_ph_charge_proportionals = [\n torch.log(\n utils.cdf_standard_gaussian(\n (centered_charges[ii] + 0.5)\n / sigma_0_charge[representations[ii][\"mask\"]]\n )\n - utils.cdf_standard_gaussian(\n (centered_charges[ii] - 0.5)\n / sigma_0_charge[representations[ii][\"mask\"]]\n )\n + epsilon\n )\n for ii in range(len(representations))\n ]\n log_p_hcharge_given_z0 = [\n utils.sum_except_batch(\n log_ph_charge_proportionals[ii],\n representations[ii][\"mask\"],\n dim_size=representations[0][\"size\"].size(0),\n )\n for ii in range(len(representations))\n ]\n\n log_p_h_given_z0 = [\n log_p_x_given_z0_without_constants,\n log_p_hcat_given_z0,\n log_p_hcharge_given_z0,\n ]\n return log_p_h_given_z0\n\n # ------ INVERSE PASS ------\n\n @torch.no_grad()\n def sample(\n self,\n n_samples: int,\n fragments_nodes: List[torch.tensor],\n conditions: Optional[Tensor] = None,\n return_frames: int = 1,\n timesteps: Optional[int] = None,\n h0: Optional[List[Tensor]] = None,\n ):\n r\"\"\"\n Draw samples from the generative model. Optionally, return intermediate\n states for visualization purposes.\n \"\"\"\n timesteps = self.T if timesteps is None else timesteps\n assert 0 < return_frames <= timesteps\n assert timesteps % return_frames == 0\n assert h0 is not None if self.pos_only else True\n\n fragments_masks = [\n get_mask_for_frag(natm_nodes) for natm_nodes in fragments_nodes\n ]\n combined_mask = torch.cat(fragments_masks)\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\n n_frag_switch = get_n_frag_switch(fragments_nodes)\n\n zt_xh = self.sample_combined_position_feature_noise(masks=fragments_masks)\n if self.pos_only:\n zt_xh = [\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\n dim=0,\n ),\n combined_mask,\n )\n\n out_samples = [\n [\n torch.zeros((return_frames,) + _zt_xh.size(), device=_zt_xh.device)\n for _zt_xh in zt_xh\n ]\n for _ in range(return_frames)\n ]\n\n # Iteratively sample p(z_s | z_t) for t = 1, ..., T, with s = t - 1.\n for s in reversed(range(0, timesteps)):\n s_array = torch.full((n_samples, 1), fill_value=s, device=zt_xh[0].device)\n t_array = s_array + 1\n s_array = s_array / timesteps\n t_array = t_array / timesteps\n\n # print(s, zt_xh)\n\n zt_xh = self.sample_p_zs_given_zt(\n s=s_array,\n t=t_array,\n zt_xh=zt_xh,\n edge_index=edge_index,\n n_frag_switch=n_frag_switch,\n masks=fragments_masks,\n conditions=conditions,\n fix_noise=False,\n )\n if self.pos_only:\n zt_xh = [\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n\n # save frame\n if (s * return_frames) % timesteps == 0:\n idx = (s * return_frames) // timesteps\n out_samples[idx] = self.normalizer.unnormalize_z(zt_xh)\n\n pos, cat, charge = self.sample_p_xh_given_z0(\n z0_xh=zt_xh,\n edge_index=edge_index,\n n_frag_switch=n_frag_switch,\n masks=fragments_masks,\n batch_size=n_samples,\n conditions=conditions,\n )\n if self.pos_only:\n cat = [_h0[:, :-1] for _h0 in h0]\n charge = [_h0[:, -1:] for _h0 in h0]\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_pos[:, : self.pos_dim] for _pos in pos],\n dim=0,\n ),\n combined_mask,\n )\n\n # Overwrite last frame with the resulting x and h.\n out_samples[0] = [\n torch.cat([pos[ii], cat[ii], charge[ii]], dim=1) for ii in range(len(pos))\n ]\n return out_samples, fragments_masks\n\n def sample_p_zs_given_zt(\n self,\n s: Tensor,\n t: Tensor,\n zt_xh: List[Tensor],\n edge_index: Tensor,\n n_frag_switch: Tensor,\n masks: List[Tensor],\n conditions: Optional[Tensor] = None,\n fix_noise: bool = False,\n ):\n \"\"\"Samples from zs ~ p(zs | zt). Only used during sampling.\"\"\"\n gamma_s = self.schedule.gamma_module(s)\n gamma_t = self.schedule.gamma_module(t)\n\n (\n sigma2_t_given_s,\n sigma_t_given_s,\n alpha_t_given_s,\n ) = self.schedule.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zt_xh[0])\n\n sigma_s = self.schedule.sigma(gamma_s, target_tensor=zt_xh[0])\n sigma_t = self.schedule.sigma(gamma_t, target_tensor=zt_xh[0])\n\n # Neural net prediction.\n combined_mask = torch.cat(masks)\n net_eps_xh, net_eps_edge_attr = self.dynamics(\n xh=zt_xh,\n edge_index=edge_index,\n t=t,\n conditions=conditions,\n n_frag_switch=n_frag_switch,\n combined_mask=combined_mask,\n edge_attr=None, # TODO: no edge_attr is considered now\n )\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\n dim=0,\n ),\n combined_mask,\n )\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_net_eps_xh[:, : self.pos_dim] for _net_eps_xh in net_eps_xh],\n dim=0,\n ),\n combined_mask,\n )\n\n # Note: mu_{t->s} = 1 / alpha_{t|s} z_t - sigma_{t|s}^2 / sigma_t / alpha_{t|s} epsilon\n # follows from the definition of mu_{t->s} and Equ. (7) in the EDM paper\n mu = [\n zt_xh[ii] / alpha_t_given_s[masks[ii]]\n - net_eps_xh[ii] * (sigma2_t_given_s / alpha_t_given_s / sigma_t)[masks[ii]]\n for ii in range(len(zt_xh))\n ]\n\n # Compute sigma for p(zs | zt).\n sigma = sigma_t_given_s * sigma_s / sigma_t\n\n # Sample zs given the paramters derived from zt.\n zs_xh = self.sample_normal(mu=mu, sigma=sigma, masks=masks, fix_noise=fix_noise)\n\n # Project down to avoid numerical runaway of the center of gravity.\n for ii in range(len(masks)):\n zs_xh[ii][:, : self.pos_dim] = utils.remove_mean_batch(\n zs_xh[ii][:, : self.pos_dim],\n masks[ii],\n )\n return zs_xh\n\n def sample_normal(\n self,\n mu: List[Tensor],\n sigma: Tensor,\n masks: List[Tensor],\n fix_noise: bool = False,\n ) -> List[Tensor]:\n r\"\"\"Samples from a Normal distribution.\"\"\"\n if fix_noise:\n # bs = 1 if fix_noise else mu.size(0)\n raise NotImplementedError(\"fix_noise option isn't implemented yet\")\n eps_xh = self.sample_combined_position_feature_noise(masks=masks)\n zs_xh = [mu[ii] + sigma[masks[ii]] * eps_xh[ii] for ii in range(len(masks))]\n return zs_xh\n\n def sample_p_xh_given_z0(\n self,\n z0_xh: List[Tensor],\n edge_index: Tensor,\n n_frag_switch: Tensor,\n masks: List[Tensor],\n batch_size: int,\n conditions: Optional[Tensor] = None,\n fix_noise: bool = False,\n ) -> Tuple[List[Tensor]]:\n \"\"\"Samples x ~ p(x|z0).\"\"\"\n t_zeros = torch.zeros(size=(batch_size, 1), device=z0_xh[0].device)\n gamma_0 = self.schedule.gamma_module(t_zeros)\n # Computes sqrt(sigma_0^2 / alpha_0^2)\n sigma_x = self.schedule.SNR(-0.5 * gamma_0)\n net_eps_xh, net_eps_edge_attr = self.dynamics(\n xh=z0_xh,\n edge_index=edge_index,\n t=t_zeros,\n conditions=conditions,\n n_frag_switch=n_frag_switch,\n combined_mask=torch.cat(masks),\n edge_attr=None, # TODO: no edge_attr is considered now\n )\n\n # Compute mu for p(zs | zt).\n mu_x = self.compute_x_pred(\n net_eps_xh=net_eps_xh,\n zt_xh=z0_xh,\n gamma_t=gamma_0,\n masks=masks,\n )\n x0_xh = self.sample_normal(\n mu=mu_x, sigma=sigma_x, masks=masks, fix_noise=fix_noise\n )\n\n pos_0 = [\n self.normalizer.unnormalize(x0_xh[ii][:, : self.pos_dim], ii)\n for ii in range(len(masks))\n ]\n cat_0 = [\n self.normalizer.unnormalize(x0_xh[ii][:, self.pos_dim : -1], ii)\n for ii in range(len(masks))\n ]\n charge_0 = [\n torch.round(self.normalizer.unnormalize(x0_xh[ii][:, -1:], ii)).long()\n for ii in range(len(masks))\n ]\n\n cat_0 = [\n F.one_hot(torch.argmax(cat_0[ii], dim=1), self.node_nfs[ii] - 4).long()\n for ii in range(len(masks))\n ]\n return pos_0, cat_0, charge_0\n\n def compute_x_pred(\n self,\n net_eps_xh: List[Tensor],\n zt_xh: List[Tensor],\n gamma_t: Tensor,\n masks: List[Tensor],\n ) -> List[Tensor]:\n \"\"\"Commputes x_pred, i.e. the most likely prediction of x.\"\"\"\n sigma_t = self.schedule.sigma(gamma_t, target_tensor=net_eps_xh[0])\n alpha_t = self.schedule.alpha(gamma_t, target_tensor=net_eps_xh[0])\n x_pred = [\n 1.0 / alpha_t[masks[ii]] * (zt_xh[ii] - sigma_t[masks[ii]] * net_eps_xh[ii])\n for ii in range(len(masks))\n ]\n return x_pred\n\n # ------ INPAINT ------\n @torch.no_grad()\n def inpaint(\n self,\n n_samples: int,\n fragments_nodes: List[torch.tensor],\n conditions: Optional[Tensor] = None,\n return_frames: int = 1,\n resamplings: int = 1,\n jump_length: int = 1,\n timesteps: Optional[int] = None,\n xh_fixed: Optional[List[Tensor]] = None,\n frag_fixed: Optional[List] = None,\n ):\n r\"\"\"\n Draw samples from the generative model. Optionally, return intermediate\n states for visualization purposes.\n \"\"\"\n timesteps = self.T if timesteps is None else timesteps\n assert 0 < return_frames <= timesteps\n assert timesteps % return_frames == 0\n assert len(xh_fixed)\n\n fragments_masks = [\n get_mask_for_frag(natm_nodes) for natm_nodes in fragments_nodes\n ]\n combined_mask = torch.cat(fragments_masks)\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\n n_frag_switch = get_n_frag_switch(fragments_nodes)\n\n h0 = [_xh_fixed[:, self.pos_dim :].long() for _xh_fixed in xh_fixed]\n\n for ii, _ in enumerate(xh_fixed):\n xh_fixed[ii][:, : self.pos_dim] = utils.remove_mean_batch(\n xh_fixed[ii][:, : self.pos_dim],\n fragments_masks[ii],\n )\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_xh_fixed[:, : self.pos_dim] for _xh_fixed in xh_fixed],\n dim=0,\n ),\n combined_mask,\n )\n\n zt_xh = self.sample_combined_position_feature_noise(masks=fragments_masks)\n if self.pos_only:\n zt_xh = [\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\n dim=0,\n ),\n combined_mask,\n )\n\n out_samples = [\n [\n torch.zeros((return_frames,) + _zt_xh.size(), device=_zt_xh.device)\n for _zt_xh in zt_xh\n ]\n for _ in range(return_frames)\n ]\n\n schedule = get_repaint_schedule(resamplings, jump_length, timesteps)\n s = timesteps - 1\n for i, n_denoise_steps in enumerate(schedule):\n for j in range(n_denoise_steps):\n s_array = torch.full(\n (n_samples, 1), fill_value=s, device=zt_xh[0].device\n )\n t_array = s_array + 1\n s_array = s_array / timesteps\n t_array = t_array / timesteps\n\n gamma_s = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(s_array), xh_fixed[0]\n )\n\n zt_known, _ = self.noised_representation(\n xh_fixed, fragments_masks, gamma_s\n )\n zt_unknown = self.sample_p_zs_given_zt(\n s=s_array,\n t=t_array,\n zt_xh=zt_xh,\n edge_index=edge_index,\n n_frag_switch=n_frag_switch,\n masks=fragments_masks,\n conditions=conditions,\n fix_noise=False,\n )\n\n if self.pos_only:\n zt_known = [\n torch.cat([zt_known[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n zt_unknown = [\n torch.cat([zt_unknown[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n\n zt_xh = [\n zt_known[ii] if ii in frag_fixed else zt_unknown[ii]\n for ii in range(len(h0))\n ]\n\n # Noise combined representation, i.e., resample\n if j == n_denoise_steps - 1 and i < len(schedule) - 1:\n # Go back jump_length steps\n t = s + jump_length\n t_array = torch.full(\n (n_samples, 1), fill_value=t, device=zt_xh[0].device\n )\n t_array = t_array / timesteps\n\n gamma_s = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(s_array), xh_fixed[0]\n )\n gamma_t = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(t_array), xh_fixed[0]\n )\n\n zt_xh = self.sample_p_zt_given_zs(\n zt_xh, fragments_masks, gamma_t, gamma_s\n )\n s = t\n\n s = s - 1\n\n # # save frame\n # if (s * return_frames) % timesteps == 0:\n # idx = (s * return_frames) // timesteps\n # out_samples[idx] = self.normalizer.unnormalize_z(zt_xh)\n\n pos, cat, charge = self.sample_p_xh_given_z0(\n z0_xh=zt_xh,\n edge_index=edge_index,\n n_frag_switch=n_frag_switch,\n masks=fragments_masks,\n batch_size=n_samples,\n conditions=conditions,\n )\n if self.pos_only:\n cat = [_h0[:, :-1] for _h0 in h0]\n charge = [_h0[:, -1:] for _h0 in h0]\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_pos[:, : self.pos_dim] for _pos in pos],\n dim=0,\n ),\n combined_mask,\n )\n\n # Overwrite last frame with the resulting x and h.\n out_samples[0] = [\n torch.cat([pos[ii], cat[ii], charge[ii]], dim=1) for ii in range(len(pos))\n ]\n return out_samples, fragments_masks\n\n # ------ INPAINT ------\n @torch.no_grad()\n def inpaint_fixed(\n self,\n n_samples: int,\n fragments_nodes: List[torch.tensor],\n conditions: Optional[Tensor] = None,\n return_frames: int = 1,\n resamplings: int = 1,\n jump_length: int = 1,\n timesteps: Optional[int] = None,\n xh_fixed: Optional[List[Tensor]] = None,\n frag_fixed: Optional[List] = None,\n ):\n r\"\"\"\n Draw samples from the generative model. Optionally, return intermediate\n states for visualization purposes.\n \"\"\"\n timesteps = self.T if timesteps is None else timesteps\n assert 0 < return_frames <= timesteps\n assert timesteps % return_frames == 0\n assert len(xh_fixed)\n\n fragments_masks = [\n get_mask_for_frag(natm_nodes) for natm_nodes in fragments_nodes\n ]\n combined_mask = torch.cat(fragments_masks)\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\n n_frag_switch = get_n_frag_switch(fragments_nodes)\n\n h0 = [_xh_fixed[:, self.pos_dim :].long() for _xh_fixed in xh_fixed]\n\n for ii, _ in enumerate(xh_fixed):\n xh_fixed[ii][:, : self.pos_dim] = utils.remove_mean_batch(\n xh_fixed[ii][:, : self.pos_dim],\n fragments_masks[ii],\n )\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_xh_fixed[:, : self.pos_dim] for _xh_fixed in xh_fixed],\n dim=0,\n ),\n combined_mask,\n )\n\n zt_xh = self.sample_combined_position_feature_noise(masks=fragments_masks)\n if self.pos_only:\n zt_xh = [\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\n dim=0,\n ),\n combined_mask,\n )\n\n out_samples = [\n [\n torch.zeros((return_frames,) + _zt_xh.size(), device=_zt_xh.device)\n for _zt_xh in zt_xh\n ]\n for _ in range(return_frames)\n ]\n\n schedule = get_repaint_schedule(resamplings, jump_length, timesteps)\n s = timesteps - 1\n for i, n_denoise_steps in enumerate(schedule):\n for j in range(n_denoise_steps):\n s_array = torch.full(\n (n_samples, 1), fill_value=s, device=zt_xh[0].device\n )\n t_array = s_array + 1\n s_array = s_array / timesteps\n t_array = t_array / timesteps\n\n gamma_s = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(s_array), xh_fixed[0]\n )\n\n zt_known, _ = self.noised_representation(\n xh_fixed, fragments_masks, gamma_s\n )\n zt_unknown = self.sample_p_zs_given_zt(\n s=s_array,\n t=t_array,\n zt_xh=zt_xh,\n edge_index=edge_index,\n n_frag_switch=n_frag_switch,\n masks=fragments_masks,\n conditions=conditions,\n fix_noise=False,\n )\n\n if self.pos_only:\n zt_known = [\n torch.cat([zt_known[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n zt_unknown = [\n torch.cat([zt_unknown[ii][:, : self.pos_dim], h0[ii]], dim=1)\n for ii in range(len(h0))\n ]\n\n zt_xh = [\n zt_known[ii] if ii in frag_fixed else zt_unknown[ii]\n for ii in range(len(h0))\n ]\n\n # Noise combined representation, i.e., resample\n if j == n_denoise_steps - 1 and i < len(schedule) - 1:\n # Go back jump_length steps\n t = s + jump_length\n t_array = torch.full(\n (n_samples, 1), fill_value=t, device=zt_xh[0].device\n )\n t_array = t_array / timesteps\n\n gamma_s = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(s_array), xh_fixed[0]\n )\n gamma_t = self.schedule.inflate_batch_array(\n self.schedule.gamma_module(t_array), xh_fixed[0]\n )\n\n zt_xh = self.sample_p_zt_given_zs(\n zt_xh, fragments_masks, gamma_t, gamma_s\n )\n s = t\n\n s = s - 1\n\n # # save frame\n # if (s * return_frames) % timesteps == 0:\n # idx = (s * return_frames) // timesteps\n # out_samples[idx] = self.normalizer.unnormalize_z(zt_xh)\n\n pos, cat, charge = self.sample_p_xh_given_z0(\n z0_xh=zt_xh,\n edge_index=edge_index,\n n_frag_switch=n_frag_switch,\n masks=fragments_masks,\n batch_size=n_samples,\n conditions=conditions,\n )\n if self.pos_only:\n cat = [_h0[:, :-1] for _h0 in h0]\n charge = [_h0[:, -1:] for _h0 in h0]\n utils.assert_mean_zero_with_mask(\n torch.cat(\n [_pos[:, : self.pos_dim] for _pos in pos],\n dim=0,\n ),\n combined_mask,\n )\n\n # Overwrite last frame with the resulting x and h.\n out_samples[0] = [\n torch.cat([pos[ii], cat[ii], charge[ii]], dim=1) for ii in range(len(pos))\n ]\n return out_samples, fragments_masks\n\n def sample_p_zt_given_zs(\n self,\n zs: List[Tensor],\n masks: List[Tensor],\n gamma_t: Tensor,\n gamma_s: Tensor,\n fix_noise: bool = False,\n ) -> List[Tensor]:\n (\n sigma2_t_given_s,\n sigma_t_given_s,\n alpha_t_given_s,\n ) = self.schedule.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zs[0])\n\n mu = [alpha_t_given_s[masks[ii]] * zs[ii] for ii in range(len(masks))]\n zt = self.sample_normal(\n mu=mu, sigma=sigma_t_given_s, masks=masks, fix_noise=fix_noise\n )\n\n for ii in range(len(masks)):\n zt[ii][:, : self.pos_dim] = utils.remove_mean_batch(\n zt[ii][:, : self.pos_dim],\n masks[ii],\n )\n return zt"},{"identifier":"average_over_batch_metrics","path":"oa_reactdiff/trainer/_metrics.py","snippet":"def average_over_batch_metrics(batch_metrics: List[Dict], allowed: List = []):\n epoch_metrics = {}\n effective_batch = {}\n for ii, out in enumerate(batch_metrics):\n for k, v in out.items():\n if not (k in allowed or len(allowed) == 0):\n continue\n if ii == 0:\n epoch_metrics[k] = v\n effective_batch[k] = 1\n else:\n if not np.isnan(v):\n epoch_metrics[k] += v\n effective_batch[k] += 1\n for k in epoch_metrics:\n epoch_metrics[k] /= effective_batch[k]\n return epoch_metrics"},{"identifier":"pretty_print","path":"oa_reactdiff/trainer/_metrics.py","snippet":"def pretty_print(epoch, metric_dict, prefix=\"Train\"):\n out = f\"{prefix} epoch {epoch} \"\n for k, v in metric_dict.items():\n out += f\"{k} {v:.2f} \"\n print(out)"},{"identifier":"batch_rmsd","path":"oa_reactdiff/analyze/rmsd.py","snippet":"def batch_rmsd(\n fragments_nodes: List[Tensor],\n out_samples: List[Tensor],\n xh: List[Tensor],\n idx: int = 1,\n threshold=0.5,\n):\n rmsds = []\n out_samples_use = out_samples[idx]\n xh_use = xh[idx]\n nodes = fragments_nodes[idx].long().cpu().numpy()\n start_ind, end_ind = 0, 0\n for jj, natoms in enumerate(nodes):\n end_ind += natoms\n mol1 = xh2pmg(out_samples_use[start_ind:end_ind])\n mol2 = xh2pmg(xh_use[start_ind:end_ind])\n try:\n rmsd = pymatgen_rmsd(mol1, mol2, ignore_chirality=True, threshold=threshold)\n except:\n rmsd = 1.0\n rmsds.append(min(rmsd, 1.0))\n start_ind = end_ind\n return rmsds"}],"string":"[\n {\n \"identifier\": \"ProcessedQM9\",\n \"path\": \"oa_reactdiff/dataset/qm9.py\",\n \"snippet\": \"class ProcessedQM9(BaseQM9):\\n def __init__(\\n self,\\n npz_path,\\n center=True,\\n pad_fragments=2,\\n device=\\\"cpu\\\",\\n zero_charge=False,\\n remove_h=False,\\n **kwargs,\\n ):\\n super().__init__(\\n npz_path=npz_path,\\n center=center,\\n device=device,\\n zero_charge=zero_charge,\\n remove_h=remove_h,\\n )\\n\\n self.n_fragments = pad_fragments + 1\\n self.device = torch.device(device)\\n\\n n_samples = len(self.raw_dataset[\\\"charges\\\"])\\n self.n_samples = n_samples\\n\\n self.data = {}\\n self.process_molecules(\\\"raw_dataset\\\", n_samples, idx=0)\\n\\n for idx in range(pad_fragments):\\n self.patch_dummy_molecules(idx + 1)\\n\\n self.data[\\\"condition\\\"] = [\\n torch.zeros(\\n size=(1, 1),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n for _ in range(self.n_samples)\\n ]\"\n },\n {\n \"identifier\": \"ProcessedDoubleQM9\",\n \"path\": \"oa_reactdiff/dataset/qm9.py\",\n \"snippet\": \"class ProcessedDoubleQM9(BaseQM9):\\n def __init__(\\n self,\\n npz_path,\\n center=True,\\n pad_fragments=1,\\n device=\\\"cpu\\\",\\n zero_charge=False,\\n remove_h=False,\\n **kwargs,\\n ):\\n super().__init__(\\n npz_path=npz_path,\\n center=center,\\n device=device,\\n zero_charge=zero_charge,\\n remove_h=remove_h,\\n )\\n\\n self.n_fragments = pad_fragments + 2\\n self.device = torch.device(device)\\n n_samples = len(self.raw_dataset[\\\"charges\\\"])\\n self.n_samples = len(self.raw_dataset[\\\"charges\\\"])\\n\\n self.get_subsets()\\n self.get_pairs()\\n\\n self.data = {}\\n self.process_molecules(\\\"frag1_data\\\", n_samples, idx=0)\\n self.process_molecules(\\\"frag2_data\\\", n_samples, idx=1)\\n\\n for idx in range(pad_fragments):\\n self.patch_dummy_molecules(idx + 2)\\n\\n self.data[\\\"condition\\\"] = [\\n torch.zeros(\\n size=(1, 1),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n for _ in range(self.n_samples)\\n ]\\n\\n def get_pairs(self):\\n self.frag1_data, self.frag2_data = {}, {}\\n frag1_O_idx_1sthalf = np.random.choice(\\n len(self.hasO_set[\\\"charges\\\"]),\\n int(self.n_samples / 2),\\n replace=True,\\n )\\n frag2_N_idx_1sthalf = np.random.choice(\\n len(self.hasN_set[\\\"charges\\\"]),\\n int(self.n_samples / 2),\\n replace=True,\\n )\\n frag1_N_idx_2ndhalf = np.random.choice(\\n len(self.hasN_set[\\\"charges\\\"]),\\n int(self.n_samples / 2),\\n replace=True,\\n )\\n frag2_O_idx_2ndhalf = np.random.choice(\\n len(self.hasO_set[\\\"charges\\\"]),\\n int(self.n_samples / 2),\\n replace=True,\\n )\\n self.frag1_data = {\\n key: np.concatenate(\\n [\\n self.hasO_set[key][frag1_O_idx_1sthalf],\\n self.hasN_set[key][frag1_N_idx_2ndhalf],\\n ],\\n axis=0,\\n )\\n for key in self.raw_dataset\\n }\\n self.frag2_data = {\\n key: np.concatenate(\\n [\\n self.hasN_set[key][frag2_N_idx_1sthalf],\\n self.hasO_set[key][frag2_O_idx_2ndhalf],\\n ],\\n axis=0,\\n )\\n for key in self.raw_dataset\\n }\"\n },\n {\n \"identifier\": \"ProcessedTripleQM9\",\n \"path\": \"oa_reactdiff/dataset/qm9.py\",\n \"snippet\": \"class ProcessedTripleQM9(BaseQM9):\\n def __init__(\\n self,\\n npz_path,\\n center=True,\\n pad_fragments=0,\\n device=\\\"cpu\\\",\\n zero_charge=False,\\n remove_h=False,\\n **kwargs,\\n ):\\n super().__init__(\\n npz_path=npz_path,\\n center=center,\\n device=device,\\n zero_charge=zero_charge,\\n remove_h=remove_h,\\n )\\n\\n self.n_fragments = pad_fragments + 3\\n self.device = torch.device(device)\\n n_samples = len(self.raw_dataset[\\\"charges\\\"])\\n self.n_samples = len(self.raw_dataset[\\\"charges\\\"])\\n\\n self.get_subsets()\\n self.get_pairs()\\n\\n self.data = {}\\n self.process_molecules(\\\"frag1_data\\\", n_samples, idx=0)\\n self.process_molecules(\\\"frag2_data\\\", n_samples, idx=1)\\n self.process_molecules(\\\"frag3_data\\\", n_samples, idx=2)\\n\\n for idx in range(pad_fragments):\\n self.patch_dummy_molecules(idx + 3)\\n\\n self.data[\\\"condition\\\"] = [\\n torch.zeros(\\n size=(1, 1),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n for _ in range(self.n_samples)\\n ]\\n\\n def get_pairs(self):\\n n1 = int(self.n_samples / 3)\\n n2 = int(self.n_samples / 3)\\n n3 = self.n_samples - n1 - n2\\n self.frag1_data, self.frag2_data = {}, {}\\n frag1_O_idx_1_3 = np.random.choice(\\n len(self.hasO_set[\\\"charges\\\"]),\\n n1,\\n replace=True,\\n )\\n frag2_N_idx_1_3 = np.random.choice(\\n len(self.hasN_set[\\\"charges\\\"]),\\n n1,\\n replace=True,\\n )\\n frag3_F_idx_1_3 = np.random.choice(\\n len(self.hasF_set[\\\"charges\\\"]),\\n n1,\\n replace=True,\\n )\\n frag1_F_idx_2_3 = np.random.choice(\\n len(self.hasF_set[\\\"charges\\\"]),\\n n2,\\n replace=True,\\n )\\n frag2_O_idx_2_3 = np.random.choice(\\n len(self.hasO_set[\\\"charges\\\"]),\\n n2,\\n replace=True,\\n )\\n frag3_N_idx_2_3 = np.random.choice(\\n len(self.hasN_set[\\\"charges\\\"]),\\n n2,\\n replace=True,\\n )\\n frag1_N_idx_3_3 = np.random.choice(\\n len(self.hasN_set[\\\"charges\\\"]),\\n n3,\\n replace=True,\\n )\\n frag2_F_idx_3_3 = np.random.choice(\\n len(self.hasF_set[\\\"charges\\\"]),\\n n3,\\n replace=True,\\n )\\n frag3_O_idx_3_3 = np.random.choice(\\n len(self.hasO_set[\\\"charges\\\"]),\\n n3,\\n replace=True,\\n )\\n self.frag1_data = {\\n key: np.concatenate(\\n [\\n self.hasO_set[key][frag1_O_idx_1_3],\\n self.hasF_set[key][frag1_F_idx_2_3],\\n self.hasN_set[key][frag1_N_idx_3_3],\\n ],\\n axis=0,\\n )\\n for key in self.raw_dataset\\n }\\n self.frag2_data = {\\n key: np.concatenate(\\n [\\n self.hasN_set[key][frag2_N_idx_1_3],\\n self.hasO_set[key][frag2_O_idx_2_3],\\n self.hasF_set[key][frag2_F_idx_3_3],\\n ],\\n axis=0,\\n )\\n for key in self.raw_dataset\\n }\\n self.frag3_data = {\\n key: np.concatenate(\\n [\\n self.hasF_set[key][frag3_F_idx_1_3],\\n self.hasN_set[key][frag3_N_idx_2_3],\\n self.hasO_set[key][frag3_O_idx_3_3],\\n ],\\n axis=0,\\n )\\n for key in self.raw_dataset\\n }\"\n },\n {\n \"identifier\": \"ProcessedTS1x\",\n \"path\": \"oa_reactdiff/dataset/transition1x.py\",\n \"snippet\": \"class ProcessedTS1x(BaseDataset):\\n def __init__(\\n self,\\n npz_path,\\n center=True,\\n pad_fragments=0,\\n device=\\\"cpu\\\",\\n zero_charge=False,\\n remove_h=False,\\n single_frag_only=True,\\n swapping_react_prod=False,\\n append_frag=False,\\n reflection=False,\\n use_by_ind=False,\\n only_ts=False,\\n confidence_model=False,\\n position_key=\\\"positions\\\",\\n ediff=None,\\n **kwargs,\\n ):\\n super().__init__(\\n npz_path=npz_path,\\n center=center,\\n device=device,\\n zero_charge=zero_charge,\\n remove_h=remove_h,\\n )\\n if confidence_model:\\n use_by_ind = False\\n if remove_h:\\n print(\\\"remove_h is ignored because it is not reasonble for TS.\\\")\\n if single_frag_only:\\n single_frag_inds = np.where(\\n np.array(self.raw_dataset[\\\"single_fragment\\\"]) == 1\\n )[0]\\n else:\\n single_frag_inds = np.array(range(len(self.raw_dataset[\\\"single_fragment\\\"])))\\n if use_by_ind:\\n use_inds = self.raw_dataset[\\\"use_ind\\\"]\\n else:\\n use_inds = range(len(self.raw_dataset[\\\"single_fragment\\\"]))\\n single_frag_inds = list(set(single_frag_inds).intersection(set(use_inds)))\\n\\n data_duplicated = copy.deepcopy(self.raw_dataset)\\n for k, mapped_k in FRAG_MAPPING.items():\\n for v, val in data_duplicated[k].items():\\n self.raw_dataset[k][v] = [val[ii] for ii in single_frag_inds]\\n if swapping_react_prod:\\n mapped_val = data_duplicated[mapped_k][v]\\n self.raw_dataset[k][v] += [\\n mapped_val[ii] for ii in single_frag_inds\\n ]\\n if reflection:\\n for k, mapped_k in FRAG_MAPPING.items():\\n for v, val in self.raw_dataset[k].items():\\n if v in [\\\"wB97x_6-31G(d).forces\\\", position_key]:\\n self.raw_dataset[k][v] += [reflect_z(_val) for _val in val]\\n else:\\n self.raw_dataset[k][v] += val\\n\\n self.reactant = self.raw_dataset[\\\"reactant\\\"]\\n self.transition_state = self.raw_dataset[\\\"transition_state\\\"]\\n self.product = self.raw_dataset[\\\"product\\\"]\\n\\n self.n_fragments = pad_fragments + 3\\n self.device = torch.device(device)\\n n_samples = len(self.reactant[\\\"charges\\\"])\\n self.n_samples = len(self.reactant[\\\"charges\\\"])\\n\\n self.data = {}\\n repeat = 2 if swapping_react_prod else 1\\n if confidence_model:\\n self.data[\\\"target\\\"] = torch.tensor(\\n self.raw_dataset[\\\"target\\\"] * repeat\\n ).unsqueeze(1)\\n self.data[\\\"rmsd\\\"] = torch.tensor(\\n self.raw_dataset[\\\"rmsd\\\"] * repeat\\n ).unsqueeze(1)\\n if ediff is not None:\\n self.data[\\\"ediff\\\"] = torch.tensor(\\n self.raw_dataset[ediff][\\\"ediff\\\"] * repeat\\n ).unsqueeze(1)\\n if not only_ts:\\n if not append_frag:\\n self.process_molecules(\\n \\\"reactant\\\", n_samples, idx=0, position_key=position_key\\n )\\n self.process_molecules(\\\"transition_state\\\", n_samples, idx=1)\\n self.process_molecules(\\n \\\"product\\\", n_samples, idx=2, position_key=position_key\\n )\\n else:\\n self.process_molecules(\\n \\\"reactant\\\",\\n n_samples,\\n idx=0,\\n append_charge=0,\\n position_key=position_key,\\n )\\n self.process_molecules(\\n \\\"transition_state\\\", n_samples, idx=1, append_charge=1\\n )\\n self.process_molecules(\\n \\\"product\\\",\\n n_samples,\\n idx=2,\\n append_charge=0,\\n position_key=position_key,\\n )\\n\\n for idx in range(pad_fragments):\\n self.patch_dummy_molecules(idx + 3)\\n else:\\n if not append_frag:\\n self.process_molecules(\\\"transition_state\\\", n_samples, idx=0)\\n else:\\n self.process_molecules(\\n \\\"transition_state\\\", n_samples, idx=0, append_charge=1\\n )\\n # for idx in range(2):\\n # self.patch_dummy_molecules(idx + 1)\\n\\n self.data[\\\"condition\\\"] = [\\n torch.zeros(\\n size=(1, 1),\\n dtype=torch.int64,\\n device=self.device,\\n )\\n for _ in range(self.n_samples)\\n ]\"\n },\n {\n \"identifier\": \"EGNNDynamics\",\n \"path\": \"oa_reactdiff/dynamics/egnn_dynamics.py\",\n \"snippet\": \"class EGNNDynamics(BaseDynamics):\\n def __init__(\\n self,\\n model_config: Dict,\\n fragment_names: List[str],\\n node_nfs: List[int],\\n edge_nf: int,\\n condition_nf: int = 0,\\n pos_dim: int = 3,\\n update_pocket_coords: bool = True,\\n condition_time: bool = True,\\n edge_cutoff: Optional[float] = None,\\n model: nn.Module = EGNN,\\n device: torch.device = torch.device(\\\"cuda\\\"),\\n enforce_same_encoding: Optional[List] = None,\\n source: Optional[Dict] = None,\\n ) -> None:\\n r\\\"\\\"\\\"Base dynamics class set up for denoising process.\\n\\n Args:\\n model_config (Dict): config for the equivariant model.\\n fragment_names (List[str]): list of names for fragments\\n node_nfs (List[int]): list of number of input node attributues.\\n edge_nf (int): number of input edge attributes.\\n condition_nf (int): number of attributes for conditional generation.\\n Defaults to 0.\\n pos_dim (int): dimension for position vector. Defaults to 3.\\n update_pocket_coords (bool): whether to update positions of everything.\\n Defaults to True.\\n condition_time (bool): whether to condition on time. Defaults to True.\\n edge_cutoff (Optional[float]): cutoff for building intra-fragment edges.\\n Defaults to None.\\n model (Optional[nn.Module]): Module for equivariant model. Defaults to None.\\n \\\"\\\"\\\"\\n super().__init__(\\n model_config,\\n fragment_names,\\n node_nfs,\\n edge_nf,\\n condition_nf,\\n pos_dim,\\n update_pocket_coords,\\n condition_time,\\n edge_cutoff,\\n model,\\n device,\\n enforce_same_encoding,\\n source=source,\\n )\\n\\n def forward(\\n self,\\n xh: List[Tensor],\\n edge_index: Tensor,\\n t: Tensor,\\n conditions: Tensor,\\n n_frag_switch: Tensor,\\n combined_mask: Tensor,\\n edge_attr: Optional[Tensor] = None,\\n ) -> Tuple[List[Tensor], Tensor]:\\n r\\\"\\\"\\\"predict noise /mu.\\n\\n Args:\\n xh (List[Tensor]): list of concatenated tensors for pos and h\\n edge_index (Tensor): [n_edge, 2]\\n t (Tensor): time tensor. If dim is 1, same for all samples;\\n otherwise different t for different samples\\n conditions (Tensor): condition tensors\\n n_frag_switch (Tensor): [n_nodes], fragment index for each nodes\\n combined_mask (Tensor): [n_nodes], sample index for each node\\n edge_attr (Optional[Tensor]): [n_edge, dim_edge_attribute]. Defaults to None.\\n\\n Raises:\\n NotImplementedError: The fragement-position-fixed mode is not implement.\\n\\n Returns:\\n Tuple[List[Tensor], Tensor]: updated pos-h and edge attributes\\n \\\"\\\"\\\"\\n pos = torch.concat(\\n [_xh[:, : self.pos_dim].clone() for _xh in xh],\\n dim=0,\\n )\\n h = torch.concat(\\n [\\n self.encoders[ii](xh[ii][:, self.pos_dim :].clone())\\n for ii, name in enumerate(self.fragment_names)\\n ],\\n dim=0,\\n )\\n if self.edge_encoder is not None:\\n edge_attr = self.edge_encoder(edge_attr)\\n\\n condition_dim = 0\\n if self.condition_time:\\n if len(t.size()) == 1:\\n # t is the same for all elements in batch.\\n h_time = torch.empty_like(h[:, 0:1]).fill_(t.item())\\n else:\\n # t is different over the batch dimension.\\n h_time = t[combined_mask]\\n h = torch.cat([h, h_time], dim=1)\\n condition_dim += 1\\n\\n if self.condition_nf > 0:\\n h_condition = conditions[combined_mask]\\n h = torch.cat([h, h_condition], dim=1)\\n condition_dim += self.condition_nf\\n\\n subgraph_mask = get_subgraph_mask(edge_index, n_frag_switch)\\n if self.update_pocket_coords:\\n update_coords_mask = None\\n else:\\n raise NotImplementedError # no need to mask pos for inpainting mode.\\n\\n h_final, pos_final, edge_attr_final = self.model(\\n h,\\n pos,\\n edge_index,\\n edge_attr,\\n node_mask=None,\\n edge_mask=None,\\n update_coords_mask=update_coords_mask,\\n subgraph_mask=subgraph_mask[:, None],\\n )\\n vel = pos_final - pos\\n if torch.any(torch.isnan(vel)):\\n print(\\\"Warning: detected nan in pos, resetting EGNN output to randn.\\\")\\n vel = torch.randn_like(vel)\\n if torch.any(torch.isnan(vel)):\\n print(\\\"Warning: detected nan in h, resetting EGNN output to randn.\\\")\\n h_final = torch.randn_like(h_final)\\n\\n h_final = h_final[:, :-condition_dim]\\n\\n frag_index = self.compute_frag_index(n_frag_switch)\\n xh_final = [\\n torch.cat(\\n [\\n self.remove_mean_batch(\\n vel[frag_index[ii] : frag_index[ii + 1]],\\n combined_mask[frag_index[ii] : frag_index[ii + 1]],\\n ),\\n self.decoders[ii](h_final[frag_index[ii] : frag_index[ii + 1]]),\\n ],\\n dim=-1,\\n )\\n for ii, name in enumerate(self.fragment_names)\\n ]\\n\\n # xh_final = self.enpose_pbc(xh_final)\\n\\n if edge_attr_final is None or edge_attr_final.size(1) <= max(1, self.dist_dim):\\n edge_attr_final = None\\n else:\\n edge_attr_final = self.edge_decoder(edge_attr_final)\\n return xh_final, edge_attr_final\\n\\n @staticmethod\\n def enpose_pbc(xh: List[Tensor], magnitude=10.0) -> List[Tensor]:\\n xrange = magnitude * 2\\n xh = [torch.remainder(_xh + magnitude, xrange) - magnitude for _xh in xh]\\n return xh\\n\\n @staticmethod\\n def compute_frag_index(n_frag_switch: Tensor) -> np.ndarray:\\n counts = [\\n torch.where(n_frag_switch == ii)[0].numel()\\n for ii in torch.unique(n_frag_switch)\\n ]\\n return np.concatenate([np.array([0]), np.cumsum(counts)])\\n\\n @torch.no_grad()\\n def adjust_edge_attr_on_new_eij(\\n self,\\n edge_index: Tensor,\\n edge_attr: Tensor,\\n edge_index_new: Tensor,\\n ) -> Tensor:\\n r\\\"\\\"\\\"Get ready new edge attributes (e_ij) given old {ij, e_ij} and new {ij}\\n\\n Args:\\n edge_index (Tensor): ij\\n edge_attr (Tensor): e_ij\\n edge_index_new (Tensor): new ij\\n\\n Raises:\\n ValueError: finding multiple entries for the same ij pair\\n\\n Returns:\\n Tensor: new e_ij\\n \\\"\\\"\\\"\\n edge_index_T = torch.transpose(edge_index, 1, 0)\\n edge_index_new_T = torch.transpose(edge_index_new, 1, 0)\\n\\n edge_attr_new = []\\n for _ind, ij in enumerate(edge_index_new_T):\\n ind = torch.where((ij == edge_index_T).all(dim=1))[0]\\n if ind.size(0) > 1:\\n raise ValueError(f\\\"ind should only be 0 or 1, getting {ind}\\\")\\n\\n if ind.size(0) == 0:\\n self.create_new_edge_attr(\\n ind_new=_ind,\\n ij_new=ij,\\n edge_index_new_T=edge_index_new_T,\\n edge_attr_new=edge_attr_new,\\n edge_attr=edge_attr,\\n )\\n else:\\n edge_attr_new.append(edge_attr[ind.item()].detach())\\n return torch.stack(edge_attr_new, dim=0)\\n\\n @staticmethod\\n def init_edge_attr(sample_edge_attr):\\n r\\\"\\\"\\\"initialize edge attributes.\\\"\\\"\\\"\\n return torch.rand_like(sample_edge_attr)\\n\\n def create_new_edge_attr(\\n self,\\n ind_new: Tensor,\\n ij_new: Tensor,\\n edge_index_new_T: Tensor,\\n edge_attr_new: List[Tensor],\\n edge_attr: Tensor,\\n ) -> List[Tensor]:\\n r\\\"\\\"\\\"Create new edge attrbution for ij that is not present in old connections\\n\\n Args:\\n ind_new (Tensor): natural index of new ij\\n ij_new (Tensor): new ij\\n edge_index_new_T (Tensor): new edge indexes, [n_edge, 2]\\n edge_attr_new (List[Tensor]): list of new edge attributes\\n edge_attr (Tensor): old edge attributes\\n\\n Raises:\\n ValueError: not ji found for ij in new indexes\\n\\n Returns:\\n List[Tensor]: list of new edge attributes\\n \\\"\\\"\\\"\\n ij_new_reverse = ij_new[torch.tensor([1, 0])]\\n ind_new_reverse = torch.where((ij_new_reverse == edge_index_new_T).all(dim=1))[\\n 0\\n ]\\n print(ind_new_reverse)\\n if ind_new_reverse.size(0) == 0:\\n raise ValueError(f\\\"should always find a reverse ind.\\\")\\n # print(ij_new, ind_new, ind_new_reverse)\\n if ind_new_reverse.item() >= ind_new:\\n edge_attr_new.append(self.init_edge_attr(edge_attr[0]))\\n else:\\n edge_attr_new.append(edge_attr_new[ind_new_reverse.item()])\\n return edge_attr_new\\n\\n @staticmethod\\n def remove_mean_batch(x, indices):\\n mean = scatter_mean(x, indices, dim=0)\\n x = x - mean[indices]\\n return x\"\n },\n {\n \"identifier\": \"Confidence\",\n \"path\": \"oa_reactdiff/dynamics/confidence.py\",\n \"snippet\": \"class Confidence(BaseDynamics):\\n def __init__(\\n self,\\n model_config: Dict,\\n fragment_names: List[str],\\n node_nfs: List[int],\\n edge_nf: int,\\n condition_nf: int = 0,\\n pos_dim: int = 3,\\n edge_cutoff: Optional[float] = None,\\n model: nn.Module = EGNN,\\n device: torch.device = torch.device(\\\"cuda\\\"),\\n enforce_same_encoding: Optional[List] = None,\\n source: Optional[Dict] = None,\\n **kwargs,\\n ) -> None:\\n r\\\"\\\"\\\"Confindence score for generated samples.\\n\\n Args:\\n model_config (Dict): config for the equivariant model.\\n fragment_names (List[str]): list of names for fragments\\n node_nfs (List[int]): list of number of input node attributues.\\n edge_nf (int): number of input edge attributes.\\n condition_nf (int): number of attributes for conditional generation.\\n Defaults to 0.\\n pos_dim (int): dimension for position vector. Defaults to 3.\\n update_pocket_coords (bool): whether to update positions of everything.\\n Defaults to True.\\n condition_time (bool): whether to condition on time. Defaults to True.\\n edge_cutoff (Optional[float]): cutoff for building intra-fragment edges.\\n Defaults to None.\\n model (Optional[nn.Module]): Module for equivariant model. Defaults to None.\\n \\\"\\\"\\\"\\n model_config.update({\\\"for_conf\\\": True})\\n update_pocket_coords = True\\n condition_time = (True,)\\n super().__init__(\\n model_config,\\n fragment_names,\\n node_nfs,\\n edge_nf,\\n condition_nf,\\n pos_dim,\\n update_pocket_coords,\\n condition_time,\\n edge_cutoff,\\n model,\\n device,\\n enforce_same_encoding,\\n source=source,\\n )\\n\\n hidden_channels = model_config[\\\"hidden_channels\\\"]\\n self.readout = GatedMLP(\\n in_dim=hidden_channels,\\n out_dims=[hidden_channels, hidden_channels, 1],\\n activation=\\\"swish\\\",\\n bias=True,\\n last_layer_no_activation=True,\\n )\\n\\n def _forward(\\n self,\\n xh: List[Tensor],\\n edge_index: Tensor,\\n t: Tensor,\\n conditions: Tensor,\\n n_frag_switch: Tensor,\\n combined_mask: Tensor,\\n edge_attr: Optional[Tensor] = None,\\n ) -> Tensor:\\n r\\\"\\\"\\\"predict confidence.\\n\\n Args:\\n xh (List[Tensor]): list of concatenated tensors for pos and h\\n edge_index (Tensor): [n_edge, 2]\\n t (Tensor): time tensor. If dim is 1, same for all samples;\\n otherwise different t for different samples\\n conditions (Tensor): condition tensors\\n n_frag_switch (Tensor): [n_nodes], fragment index for each nodes\\n combined_mask (Tensor): [n_nodes], sample index for each node\\n edge_attr (Optional[Tensor]): [n_edge, dim_edge_attribute]. Defaults to None.\\n\\n Raises:\\n NotImplementedError: The fragement-position-fixed mode is not implement.\\n\\n Returns:\\n Tensor: binary probability of confidence fo each graph.\\n \\\"\\\"\\\"\\n pos = torch.concat(\\n [_xh[:, : self.pos_dim].clone() for _xh in xh],\\n dim=0,\\n )\\n h = torch.concat(\\n [\\n self.encoders[ii](xh[ii][:, self.pos_dim :].clone())\\n for ii, name in enumerate(self.fragment_names)\\n ],\\n dim=0,\\n )\\n if self.edge_encoder is not None:\\n edge_attr = self.edge_encoder(edge_attr)\\n\\n condition_dim = 0\\n if self.condition_time:\\n if len(t.size()) == 1:\\n # t is the same for all elements in batch.\\n h_time = torch.empty_like(h[:, 0:1]).fill_(t.item())\\n else:\\n # t is different over the batch dimension.\\n h_time = t[combined_mask]\\n h = torch.cat([h, h_time], dim=1)\\n condition_dim += 1\\n\\n if self.condition_nf > 0:\\n h_condition = conditions[combined_mask]\\n h = torch.cat([h, h_condition], dim=1)\\n condition_dim += self.condition_nf\\n\\n subgraph_mask = get_subgraph_mask(edge_index, n_frag_switch)\\n if self.update_pocket_coords:\\n update_coords_mask = None\\n else:\\n raise NotImplementedError # no need to mask pos for inpainting mode.\\n\\n node_features = self.model(\\n h,\\n pos,\\n edge_index,\\n edge_attr,\\n node_mask=None,\\n edge_mask=None,\\n update_coords_mask=update_coords_mask,\\n subgraph_mask=subgraph_mask[:, None],\\n ) # (n_node, n_hidden)\\n\\n graph_features = scatter_mean(\\n node_features,\\n index=combined_mask,\\n dim=0,\\n ) # (n_system, n_hidden)\\n conf = self.readout(graph_features)\\n return conf.squeeze()\\n\\n def forward(\\n self,\\n representations: List[Dict],\\n conditions: Tensor,\\n ):\\n masks = [repre[\\\"mask\\\"] for repre in representations]\\n combined_mask = torch.cat(masks)\\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\\n fragments_nodes = [repr[\\\"size\\\"] for repr in representations]\\n n_frag_switch = get_n_frag_switch(fragments_nodes)\\n\\n xh = [\\n torch.cat(\\n [repre[feature_type] for feature_type in FEATURE_MAPPING],\\n dim=1,\\n )\\n for repre in representations\\n ]\\n\\n pred = self._forward(\\n xh=xh,\\n edge_index=edge_index,\\n t=torch.tensor([0]),\\n conditions=conditions,\\n n_frag_switch=n_frag_switch,\\n combined_mask=combined_mask,\\n edge_attr=None,\\n )\\n return pred\"\n },\n {\n \"identifier\": \"DiffSchedule\",\n \"path\": \"oa_reactdiff/diffusion/_schedule.py\",\n \"snippet\": \"class DiffSchedule(nn.Module):\\n def __init__(self, gamma_module: nn.Module, norm_values: Tuple[float]) -> None:\\n super().__init__()\\n self.gamma_module = gamma_module\\n self.norm_values = norm_values\\n self.check_issues_norm_values()\\n\\n @staticmethod\\n def inflate_batch_array(array, target):\\n r\\\"\\\"\\\"\\n Inflates the batch array (array) with only a single axis\\n (i.e. shape = (batch_size,), or possibly more empty axes\\n (i.e. shape (batch_size, 1, ..., 1)) to match the target shape.\\n \\\"\\\"\\\"\\n target_shape = (array.size(0),) + (1,) * (len(target.size()) - 1)\\n return array.view(target_shape)\\n\\n def sigma(self, gamma, target_tensor):\\n r\\\"\\\"\\\"Computes sigma given gamma.\\\"\\\"\\\"\\n return self.inflate_batch_array(torch.sqrt(torch.sigmoid(gamma)), target_tensor)\\n\\n def alpha(self, gamma, target_tensor):\\n r\\\"\\\"\\\"Computes alpha given gamma.\\\"\\\"\\\"\\n return self.inflate_batch_array(\\n torch.sqrt(torch.sigmoid(-gamma)), target_tensor\\n )\\n\\n @staticmethod\\n def SNR(gamma):\\n r\\\"\\\"\\\"Computes signal to noise ratio (alpha^2/sigma^2) given gamma.\\\"\\\"\\\"\\n return torch.exp(-gamma)\\n\\n def sigma_and_alpha_t_given_s(\\n self, gamma_t: Tensor, gamma_s: Tensor, target_tensor: Tensor\\n ) -> tuple[Tensor, Tensor, Tensor]:\\n r\\\"\\\"\\\"\\n Computes sigma t given s, using gamma_t and gamma_s. Used during sampling.\\n These are defined as:\\n alpha t given s = alpha t / alpha s,\\n sigma t given s = sqrt(1 - (alpha t given s) ^2 ).\\n \\\"\\\"\\\"\\n sigma2_t_given_s = self.inflate_batch_array(\\n -torch.expm1(F.softplus(gamma_s) - F.softplus(gamma_t)), target_tensor\\n )\\n\\n # alpha_t_given_s = alpha_t / alpha_s\\n log_alpha2_t = F.logsigmoid(-gamma_t)\\n log_alpha2_s = F.logsigmoid(-gamma_s)\\n log_alpha2_t_given_s = log_alpha2_t - log_alpha2_s\\n\\n alpha_t_given_s = torch.exp(0.5 * log_alpha2_t_given_s)\\n alpha_t_given_s = self.inflate_batch_array(alpha_t_given_s, target_tensor)\\n\\n sigma_t_given_s = torch.sqrt(sigma2_t_given_s)\\n\\n return sigma2_t_given_s, sigma_t_given_s, alpha_t_given_s\\n\\n def check_issues_norm_values(self, num_stdevs=8):\\n zeros = torch.zeros((1, 1))\\n gamma_0 = self.gamma_module(zeros)\\n sigma_0 = self.sigma(gamma_0, target_tensor=zeros).item()\\n\\n # Checked if 1 / norm_value is still larger than 10 * standard\\n # deviation.\\n norm_value = self.norm_values[1]\\n\\n if sigma_0 * num_stdevs > 1.0 / norm_value:\\n raise ValueError(\\n f\\\"Value for normalization value {norm_value} probably too \\\"\\n f\\\"large with sigma_0 {sigma_0:.5f} and \\\"\\n f\\\"1 / norm_value = {1. / norm_value}\\\"\\n )\"\n },\n {\n \"identifier\": \"PredefinedNoiseSchedule\",\n \"path\": \"oa_reactdiff/diffusion/_schedule.py\",\n \"snippet\": \"class PredefinedNoiseSchedule(nn.Module):\\n r\\\"\\\"\\\"\\n Predefined noise schedule. Essentially creates a lookup array for predefined\\n (non-learned) noise schedules.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n noise_schedule: str,\\n timesteps: int,\\n precision: float,\\n ):\\n super().__init__()\\n self.timesteps = timesteps\\n\\n if \\\"cosine\\\" in noise_schedule:\\n splits = noise_schedule.split(\\\"_\\\")\\n assert len(splits) <= 2\\n power = 1 if len(splits) == 1 else float(splits[1])\\n alphas2 = cosine_beta_schedule(timesteps, raise_to_power=power)\\n elif \\\"polynomial\\\" in noise_schedule:\\n splits = noise_schedule.split(\\\"_\\\")\\n assert len(splits) == 2\\n power = float(splits[1])\\n alphas2 = polynomial_schedule(timesteps, s=precision, power=power)\\n elif \\\"csin\\\" in noise_schedule:\\n splits = noise_schedule.split(\\\"_\\\")\\n assert len(splits) == 4\\n start, end, tau = float(splits[1]), float(splits[2]), float(splits[3])\\n alphas2 = ccosine_schedule(timesteps, start=start, end=end, tau=tau)\\n elif \\\"linear\\\" in noise_schedule:\\n alphas2 = linear_schedule(timesteps)\\n else:\\n raise ValueError(noise_schedule)\\n\\n # print(\\\"alphas2\\\", alphas2)\\n\\n sigmas2 = 1 - alphas2\\n\\n log_alphas2 = np.log(alphas2)\\n log_sigmas2 = np.log(sigmas2)\\n\\n log_alphas2_to_sigmas2 = log_alphas2 - log_sigmas2\\n\\n # print(\\\"gamma\\\", -log_alphas2_to_sigmas2)\\n\\n self.gamma = torch.nn.Parameter(\\n torch.from_numpy(-log_alphas2_to_sigmas2).float(), requires_grad=False\\n )\\n\\n def forward(self, t):\\n t_int = torch.round(t * self.timesteps).long()\\n return self.gamma[t_int]\"\n },\n {\n \"identifier\": \"Normalizer\",\n \"path\": \"oa_reactdiff/diffusion/_normalizer.py\",\n \"snippet\": \"class Normalizer(nn.Module):\\n def __init__(\\n self,\\n norm_values: Tuple = (1.0, 1.0, 1.0),\\n norm_biases: Tuple = (0.0, 0.0, 0.0),\\n pos_dim: int = 3,\\n ) -> None:\\n super().__init__()\\n self.norm_values = norm_values\\n self.norm_biases = norm_biases\\n self.pos_dim = pos_dim\\n\\n def normalize(self, representations: List[Dict]) -> List[Dict]:\\n for ii in range(len(representations)):\\n for jj, feature_type in enumerate(FEATURE_MAPPING):\\n representations[ii][feature_type] = (\\n representations[ii][feature_type] - self.norm_biases[jj]\\n ) / self.norm_values[jj]\\n return representations\\n\\n def unnormalize(self, x: Tensor, ind: int) -> Tensor:\\n return x * self.norm_values[ind] + self.norm_biases[ind]\\n\\n def unnormalize_z(self, z_combined: List[Tensor]) -> List[Tensor]:\\n for ii in range(len(z_combined)):\\n z_combined[ii][:, : self.pos_dim] = self.unnormalize(\\n z_combined[ii][:, : self.pos_dim], 0\\n )\\n z_combined[ii][:, self.pos_dim : -1] = self.unnormalize(\\n z_combined[ii][:, self.pos_dim : -1], 1\\n )\\n z_combined[ii][:, -1:] = self.unnormalize(z_combined[ii][:, -1:], 2)\\n return z_combined\"\n },\n {\n \"identifier\": \"FEATURE_MAPPING\",\n \"path\": \"oa_reactdiff/diffusion/_normalizer.py\",\n \"snippet\": \"FEATURE_MAPPING = [\\\"pos\\\", \\\"one_hot\\\", \\\"charge\\\"]\"\n },\n {\n \"identifier\": \"EnVariationalDiffusion\",\n \"path\": \"oa_reactdiff/diffusion/en_diffusion.py\",\n \"snippet\": \"class EnVariationalDiffusion(nn.Module):\\n \\\"\\\"\\\"\\n The E(n) Diffusion Module.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n dynamics: EGNNDynamics,\\n schdule: DiffSchedule,\\n normalizer: Normalizer,\\n size_histogram: Optional[Dict] = None,\\n loss_type: str = \\\"l2\\\",\\n pos_only: bool = False,\\n fixed_idx: Optional[List] = None,\\n ):\\n super().__init__()\\n assert loss_type in {\\\"vlb\\\", \\\"l2\\\"}\\n\\n self.dynamics = dynamics\\n self.schedule = schdule\\n self.normalizer = normalizer\\n self.size_histogram = size_histogram\\n self.loss_type = loss_type\\n self.pos_only = pos_only\\n self.fixed_idx = fixed_idx or []\\n\\n self.pos_dim = dynamics.pos_dim\\n self.node_nfs = dynamics.node_nfs\\n self.fragment_names = dynamics.fragment_names\\n self.T = schdule.gamma_module.timesteps\\n self.norm_values = normalizer.norm_values\\n self.norm_biases = normalizer.norm_biases\\n\\n # ------ FORWARD PASS ------\\n\\n def forward(\\n self,\\n representations: List[Dict],\\n conditions: Tensor,\\n return_pred: bool = False,\\n ):\\n r\\\"\\\"\\\"\\n Computes the loss and NLL terms.\\n\\n #TODO: edge_attr not considered at all\\n \\\"\\\"\\\"\\n num_sample = representations[0][\\\"size\\\"].size(0)\\n n_nodes = torch.stack(\\n [repr[\\\"size\\\"] for repr in representations],\\n dim=0,\\n ).sum(dim=0)\\n device = representations[0][\\\"pos\\\"].device\\n masks = [repre[\\\"mask\\\"] for repre in representations]\\n combined_mask = torch.cat(masks)\\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\\n fragments_nodes = [repr[\\\"size\\\"] for repr in representations]\\n n_frag_switch = get_n_frag_switch(fragments_nodes)\\n\\n # Normalize data, take into account volume change in x.\\n representations = self.normalizer.normalize(representations)\\n\\n # Likelihood change due to normalization\\n delta_log_px = self.delta_log_px(n_nodes.sum())\\n\\n # Sample a timestep t for each example in batch\\n # At evaluation time, loss_0 will be computed separately to decrease\\n # variance in the estimator (costs two forward passes)\\n lowest_t = 0 if self.training else 1\\n t_int = torch.randint(\\n lowest_t, self.T + 1, size=(num_sample, 1), device=device\\n ).float()\\n s_int = t_int - 1 # previous timestep\\n\\n # Masks: important to compute log p(x | z0).\\n t_is_zero = (t_int == 0).float()\\n t_is_not_zero = 1 - t_is_zero\\n\\n # Normalize t to [0, 1]. Note that the negative\\n # step of s will never be used, since then p(x | z0) is computed.\\n s = s_int / self.T\\n t = t_int / self.T\\n\\n # Compute gamma_s and gamma_t via the network.\\n gamma_s = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(s), representations[0][\\\"pos\\\"]\\n )\\n gamma_t = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(t), representations[0][\\\"pos\\\"]\\n )\\n\\n # Concatenate x, and h[categorical].\\n xh = [\\n torch.cat(\\n [repre[feature_type] for feature_type in FEATURE_MAPPING],\\n dim=1,\\n )\\n for repre in representations\\n ]\\n\\n # Find noised representation\\n z_t, eps_xh = self.noised_representation(xh, masks, gamma_t)\\n\\n # Neural net prediction.\\n net_eps_xh, net_eps_edge_attr = self.dynamics(\\n xh=z_t,\\n edge_index=edge_index,\\n t=t,\\n conditions=conditions,\\n n_frag_switch=n_frag_switch,\\n combined_mask=combined_mask,\\n edge_attr=None, # TODO: no edge_attr is considered now\\n )\\n\\n if return_pred:\\n return eps_xh, net_eps_xh\\n\\n # TODO: LJ term not implemented\\n # xh_lig_hat = self.xh_given_zt_and_epsilon(z_t_lig, net_out_lig, gamma_t,\\n # ligand['mask'])\\n if self.pos_only:\\n for ii in range(len(masks)):\\n net_eps_xh[ii][:, self.pos_dim :] = torch.zeros_like(\\n net_eps_xh[ii][:, self.pos_dim :],\\n device=device,\\n )\\n # Compute the L2 error.\\n error_t: List[Tensor] = [\\n utils.sum_except_batch(\\n (eps_xh[ii] - net_eps_xh[ii]) ** 2,\\n masks[ii],\\n dim_size=num_sample,\\n )\\n for ii in range(len(masks))\\n ] # TODO: no edge_attr contribution\\n\\n # Compute weighting with SNR: (1 - SNR(s-t)) for epsilon parametrization\\n SNR_weight = (1 - self.schedule.SNR(gamma_s - gamma_t)).squeeze(1)\\n assert error_t[0].size() == SNR_weight.size()\\n\\n # The _constants_ depending on sigma_0 from the\\n # cross entropy term E_q(z0 | x) [log p(x | z0)].\\n neg_log_constants = -self.log_constants_p_x_given_z0(\\n n_nodes=n_nodes, device=device\\n )\\n\\n # The KL between q(zT | x) and p(zT) = Normal(0, 1).\\n # Should be close to zero.\\n # kl_prior = self.kl_prior_with_pocket(\\n # xh_lig, xh_pocket, ligand['mask'], pocket['mask'],\\n # ligand['size'] + pocket['size'])\\n # TODO: approximate KL prior with zero now, which should not influence training.\\n kl_prior = torch.zeros_like(neg_log_constants)\\n\\n if self.training:\\n # Computes the L_0 term (even if gamma_t is not actually gamma_0)\\n # and this will later be selected via masking.\\n log_p_h_given_z0 = self.log_pxh_given_z0_without_constants(\\n representations=representations,\\n z_t=z_t,\\n eps_xh=eps_xh,\\n net_eps_xh=net_eps_xh,\\n gamma_t=gamma_t,\\n epsilon=1e-10,\\n )\\n loss_0_x = [\\n -_log_p_fragment * t_is_zero.squeeze()\\n for _log_p_fragment in log_p_h_given_z0[0]\\n ]\\n loss_0_cat = [\\n -_log_p_fragment * t_is_zero.squeeze()\\n for _log_p_fragment in log_p_h_given_z0[1]\\n ]\\n loss_0_charge = [\\n -_log_p_fragment * t_is_zero.squeeze()\\n for _log_p_fragment in log_p_h_given_z0[2]\\n ]\\n\\n # apply t_is_zero mask\\n error_t = [_error_t * t_is_not_zero.squeeze() for _error_t in error_t]\\n\\n else:\\n # Compute noise values for t = 0.\\n t_zeros = torch.zeros_like(s)\\n gamma_0 = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(t_zeros), representations[0][\\\"pos\\\"]\\n )\\n\\n # Sample z_0 given x, h for timestep t, from q(z_t | x, h)\\n z_0, eps_0_xh = self.noised_representation(xh, masks, gamma_0)\\n net_eps_0_xh, net_eps_0_edge_attr = self.dynamics(\\n xh=z_0,\\n edge_index=edge_index,\\n t=t_zeros,\\n conditions=conditions,\\n n_frag_switch=n_frag_switch,\\n combined_mask=combined_mask,\\n edge_attr=None, # TODO: no edge_attr is considered now\\n )\\n\\n log_p_h_given_z0 = self.log_pxh_given_z0_without_constants(\\n representations=representations,\\n z_t=z_0,\\n eps_xh=eps_0_xh,\\n net_eps_xh=net_eps_0_xh,\\n gamma_t=gamma_0,\\n epsilon=1e-10,\\n )\\n loss_0_x = [-_log_p_fragment for _log_p_fragment in log_p_h_given_z0[0]]\\n loss_0_cat = [-_log_p_fragment for _log_p_fragment in log_p_h_given_z0[1]]\\n loss_0_charge = [\\n -_log_p_fragment for _log_p_fragment in log_p_h_given_z0[2]\\n ]\\n\\n loss_terms = {\\n \\\"delta_log_px\\\": delta_log_px,\\n \\\"error_t\\\": error_t,\\n \\\"SNR_weight\\\": SNR_weight,\\n \\\"loss_0_x\\\": loss_0_x,\\n \\\"loss_0_cat\\\": loss_0_cat,\\n \\\"loss_0_charge\\\": loss_0_charge,\\n \\\"neg_log_constants\\\": neg_log_constants,\\n \\\"kl_prior\\\": kl_prior,\\n \\\"log_pN\\\": torch.zeros_like(kl_prior),\\n \\\"t_int\\\": t_int.squeeze(),\\n \\\"net_eps_xh\\\": net_eps_xh,\\n \\\"eps_xh\\\": eps_xh,\\n }\\n return loss_terms\\n\\n def delta_log_px(self, num_nodes):\\n return -self.subspace_dimensionality(num_nodes) * np.log(self.norm_values[0])\\n\\n def subspace_dimensionality(self, input_size):\\n r\\\"\\\"\\\"\\n Compute the dimensionality on translation-invariant linear subspace\\n where distributions on x are defined.\\n \\\"\\\"\\\"\\n return (input_size - 1) * self.pos_dim\\n\\n def noised_representation(\\n self,\\n xh: List[Tensor],\\n masks: List[Tensor],\\n gamma_t: Tensor,\\n ) -> Tuple[List[Tensor], List[Tensor]]:\\n # Compute alpha_t and sigma_t from gamma.\\n alpha_t = self.schedule.alpha(gamma_t, xh[0])\\n sigma_t = self.schedule.sigma(gamma_t, xh[0])\\n\\n # Sample zt ~ Normal(alpha_t x, sigma_t)\\n eps_xh = self.sample_combined_position_feature_noise(masks)\\n\\n # Sample z_t given x, h for timestep t, from q(z_t | x, h)\\n z_t = [\\n alpha_t[masks[ii]] * xh[ii] + sigma_t[masks[ii]] * eps_xh[ii]\\n for ii in range(len(masks))\\n ]\\n\\n return z_t, eps_xh\\n\\n def sample_combined_position_feature_noise(\\n self,\\n masks: List[Tensor],\\n ) -> List[Tensor]:\\n r\\\"\\\"\\\"\\n Samples mean-centered normal noise for z_x, and standard normal noise for z_h.\\n Note that we only need to put the center of gravity of *each fragment* to the origin.\\n \\\"\\\"\\\"\\n eps_xh = []\\n for ii, mask in enumerate(masks):\\n _eps_x = utils.sample_center_gravity_zero_gaussian_batch(\\n size=(len(mask), self.pos_dim),\\n indices=[mask],\\n )\\n _eps_h = utils.sample_gaussian(\\n size=(len(mask), self.node_nfs[ii] - self.pos_dim),\\n device=mask.device,\\n )\\n if self.pos_only:\\n _eps_h = torch.zeros_like(_eps_h, device=mask.device)\\n eps_xh.append(torch.cat([_eps_x, _eps_h], dim=1))\\n for idx in self.fixed_idx:\\n eps_xh[idx] = torch.zeros_like(eps_xh[idx], device=mask.device)\\n return eps_xh\\n\\n def log_constants_p_x_given_z0(self, n_nodes, device):\\n r\\\"\\\"\\\"Computes p(x|z0).\\\"\\\"\\\"\\n\\n batch_size = len(n_nodes)\\n degrees_of_freedom_x = self.subspace_dimensionality(n_nodes).to(device)\\n\\n zeros = torch.zeros((batch_size, 1), device=device)\\n gamma_0 = self.schedule.gamma_module(zeros)\\n\\n # Recall that sigma_x = sqrt(sigma_0^2 / alpha_0^2) = SNR(-0.5 gamma_0).\\n log_sigma_x = 0.5 * gamma_0.view(batch_size)\\n return degrees_of_freedom_x * (-log_sigma_x - 0.5 * np.log(2 * np.pi))\\n\\n def kl_prior(self):\\n return NotImplementedError\\n\\n @staticmethod\\n def gaussian_KL(q_mu_minus_p_mu_squared, q_sigma, p_sigma, d):\\n \\\"\\\"\\\"Computes the KL distance between two normal distributions.\\n Args:\\n q_mu_minus_p_mu_squared: Squared difference between mean of\\n distribution q and distribution p: ||mu_q - mu_p||^2\\n q_sigma: Standard deviation of distribution q.\\n p_sigma: Standard deviation of distribution p.\\n d: dimension\\n Returns:\\n The KL distance\\n \\\"\\\"\\\"\\n return (\\n d * torch.log(p_sigma / q_sigma)\\n + 0.5 * (d * q_sigma**2 + q_mu_minus_p_mu_squared) / (p_sigma**2)\\n - 0.5 * d\\n )\\n\\n def log_pxh_given_z0_without_constants(\\n self,\\n representations: List[Dict],\\n z_t: List[Tensor],\\n eps_xh: List[Tensor],\\n net_eps_xh: List[Tensor],\\n gamma_t: Tensor,\\n epsilon: float = 1e-10,\\n ) -> List[List[Tensor]]:\\n # Compute sigma_0 and rescale to the integer scale of the data.\\n # for pos\\n log_p_x_given_z0_without_constants = [\\n -0.5\\n * (\\n utils.sum_except_batch(\\n (eps_xh[ii][:, : self.pos_dim] - net_eps_xh[ii][:, : self.pos_dim])\\n ** 2,\\n representations[ii][\\\"mask\\\"],\\n dim_size=representations[0][\\\"size\\\"].size(0),\\n )\\n )\\n for ii in range(len(representations))\\n ]\\n\\n # only keep first several elements\\n z_t = [_z_t[:, : 3 + 5 + 1] for _z_t in z_t]\\n for ii, repr in enumerate(representations):\\n representations[ii][\\\"charge\\\"] = representations[ii][\\\"charge\\\"][:, :1]\\n # for ohe of atom types\\n sigma_0 = self.schedule.sigma(gamma_t, target_tensor=z_t[0])\\n sigma_0_cat = sigma_0 * self.normalizer.norm_values[1]\\n atoms = [\\n self.normalizer.unnormalize(repr[\\\"one_hot\\\"], ind=1)\\n for repr in representations\\n ]\\n est_atoms = [\\n self.normalizer.unnormalize(_z_t[:, self.pos_dim : -1], ind=1)\\n for _z_t in z_t\\n ]\\n centered_atoms = [_est_atoms - 1 for _est_atoms in est_atoms]\\n log_ph_cat_proportionals = [\\n torch.log(\\n utils.cdf_standard_gaussian(\\n (centered_atoms[ii] + 0.5)\\n / sigma_0_cat[representations[ii][\\\"mask\\\"]]\\n )\\n - utils.cdf_standard_gaussian(\\n (centered_atoms[ii] - 0.5)\\n / sigma_0_cat[representations[ii][\\\"mask\\\"]]\\n )\\n + epsilon\\n )\\n for ii in range(len(representations))\\n ]\\n log_probabilities = [\\n _log_ph_cat_proportionals\\n - torch.logsumexp(\\n _log_ph_cat_proportionals,\\n dim=1,\\n keepdim=True,\\n )\\n for _log_ph_cat_proportionals in log_ph_cat_proportionals\\n ]\\n log_p_hcat_given_z0 = [\\n utils.sum_except_batch(\\n log_probabilities[ii] * atoms[ii],\\n representations[ii][\\\"mask\\\"],\\n dim_size=representations[0][\\\"size\\\"].size(0),\\n )\\n for ii in range(len(representations))\\n ]\\n\\n # for atom charge\\n sigma_0_charge = sigma_0 * self.normalizer.norm_values[2]\\n charges = [\\n self.normalizer.unnormalize(repr[\\\"charge\\\"], ind=2)\\n for repr in representations\\n ]\\n est_charges = [\\n self.normalizer.unnormalize(_z_t[:, -1:], ind=2).long() for _z_t in z_t\\n ]\\n for ii in range(len(representations)):\\n assert charges[ii].size() == est_charges[ii].size()\\n centered_charges = [\\n charges[ii] - est_charges[ii] for ii in range(len(representations))\\n ]\\n log_ph_charge_proportionals = [\\n torch.log(\\n utils.cdf_standard_gaussian(\\n (centered_charges[ii] + 0.5)\\n / sigma_0_charge[representations[ii][\\\"mask\\\"]]\\n )\\n - utils.cdf_standard_gaussian(\\n (centered_charges[ii] - 0.5)\\n / sigma_0_charge[representations[ii][\\\"mask\\\"]]\\n )\\n + epsilon\\n )\\n for ii in range(len(representations))\\n ]\\n log_p_hcharge_given_z0 = [\\n utils.sum_except_batch(\\n log_ph_charge_proportionals[ii],\\n representations[ii][\\\"mask\\\"],\\n dim_size=representations[0][\\\"size\\\"].size(0),\\n )\\n for ii in range(len(representations))\\n ]\\n\\n log_p_h_given_z0 = [\\n log_p_x_given_z0_without_constants,\\n log_p_hcat_given_z0,\\n log_p_hcharge_given_z0,\\n ]\\n return log_p_h_given_z0\\n\\n # ------ INVERSE PASS ------\\n\\n @torch.no_grad()\\n def sample(\\n self,\\n n_samples: int,\\n fragments_nodes: List[torch.tensor],\\n conditions: Optional[Tensor] = None,\\n return_frames: int = 1,\\n timesteps: Optional[int] = None,\\n h0: Optional[List[Tensor]] = None,\\n ):\\n r\\\"\\\"\\\"\\n Draw samples from the generative model. Optionally, return intermediate\\n states for visualization purposes.\\n \\\"\\\"\\\"\\n timesteps = self.T if timesteps is None else timesteps\\n assert 0 < return_frames <= timesteps\\n assert timesteps % return_frames == 0\\n assert h0 is not None if self.pos_only else True\\n\\n fragments_masks = [\\n get_mask_for_frag(natm_nodes) for natm_nodes in fragments_nodes\\n ]\\n combined_mask = torch.cat(fragments_masks)\\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\\n n_frag_switch = get_n_frag_switch(fragments_nodes)\\n\\n zt_xh = self.sample_combined_position_feature_noise(masks=fragments_masks)\\n if self.pos_only:\\n zt_xh = [\\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n out_samples = [\\n [\\n torch.zeros((return_frames,) + _zt_xh.size(), device=_zt_xh.device)\\n for _zt_xh in zt_xh\\n ]\\n for _ in range(return_frames)\\n ]\\n\\n # Iteratively sample p(z_s | z_t) for t = 1, ..., T, with s = t - 1.\\n for s in reversed(range(0, timesteps)):\\n s_array = torch.full((n_samples, 1), fill_value=s, device=zt_xh[0].device)\\n t_array = s_array + 1\\n s_array = s_array / timesteps\\n t_array = t_array / timesteps\\n\\n # print(s, zt_xh)\\n\\n zt_xh = self.sample_p_zs_given_zt(\\n s=s_array,\\n t=t_array,\\n zt_xh=zt_xh,\\n edge_index=edge_index,\\n n_frag_switch=n_frag_switch,\\n masks=fragments_masks,\\n conditions=conditions,\\n fix_noise=False,\\n )\\n if self.pos_only:\\n zt_xh = [\\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n\\n # save frame\\n if (s * return_frames) % timesteps == 0:\\n idx = (s * return_frames) // timesteps\\n out_samples[idx] = self.normalizer.unnormalize_z(zt_xh)\\n\\n pos, cat, charge = self.sample_p_xh_given_z0(\\n z0_xh=zt_xh,\\n edge_index=edge_index,\\n n_frag_switch=n_frag_switch,\\n masks=fragments_masks,\\n batch_size=n_samples,\\n conditions=conditions,\\n )\\n if self.pos_only:\\n cat = [_h0[:, :-1] for _h0 in h0]\\n charge = [_h0[:, -1:] for _h0 in h0]\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_pos[:, : self.pos_dim] for _pos in pos],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n # Overwrite last frame with the resulting x and h.\\n out_samples[0] = [\\n torch.cat([pos[ii], cat[ii], charge[ii]], dim=1) for ii in range(len(pos))\\n ]\\n return out_samples, fragments_masks\\n\\n def sample_p_zs_given_zt(\\n self,\\n s: Tensor,\\n t: Tensor,\\n zt_xh: List[Tensor],\\n edge_index: Tensor,\\n n_frag_switch: Tensor,\\n masks: List[Tensor],\\n conditions: Optional[Tensor] = None,\\n fix_noise: bool = False,\\n ):\\n \\\"\\\"\\\"Samples from zs ~ p(zs | zt). Only used during sampling.\\\"\\\"\\\"\\n gamma_s = self.schedule.gamma_module(s)\\n gamma_t = self.schedule.gamma_module(t)\\n\\n (\\n sigma2_t_given_s,\\n sigma_t_given_s,\\n alpha_t_given_s,\\n ) = self.schedule.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zt_xh[0])\\n\\n sigma_s = self.schedule.sigma(gamma_s, target_tensor=zt_xh[0])\\n sigma_t = self.schedule.sigma(gamma_t, target_tensor=zt_xh[0])\\n\\n # Neural net prediction.\\n combined_mask = torch.cat(masks)\\n net_eps_xh, net_eps_edge_attr = self.dynamics(\\n xh=zt_xh,\\n edge_index=edge_index,\\n t=t,\\n conditions=conditions,\\n n_frag_switch=n_frag_switch,\\n combined_mask=combined_mask,\\n edge_attr=None, # TODO: no edge_attr is considered now\\n )\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_net_eps_xh[:, : self.pos_dim] for _net_eps_xh in net_eps_xh],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n # Note: mu_{t->s} = 1 / alpha_{t|s} z_t - sigma_{t|s}^2 / sigma_t / alpha_{t|s} epsilon\\n # follows from the definition of mu_{t->s} and Equ. (7) in the EDM paper\\n mu = [\\n zt_xh[ii] / alpha_t_given_s[masks[ii]]\\n - net_eps_xh[ii] * (sigma2_t_given_s / alpha_t_given_s / sigma_t)[masks[ii]]\\n for ii in range(len(zt_xh))\\n ]\\n\\n # Compute sigma for p(zs | zt).\\n sigma = sigma_t_given_s * sigma_s / sigma_t\\n\\n # Sample zs given the paramters derived from zt.\\n zs_xh = self.sample_normal(mu=mu, sigma=sigma, masks=masks, fix_noise=fix_noise)\\n\\n # Project down to avoid numerical runaway of the center of gravity.\\n for ii in range(len(masks)):\\n zs_xh[ii][:, : self.pos_dim] = utils.remove_mean_batch(\\n zs_xh[ii][:, : self.pos_dim],\\n masks[ii],\\n )\\n return zs_xh\\n\\n def sample_normal(\\n self,\\n mu: List[Tensor],\\n sigma: Tensor,\\n masks: List[Tensor],\\n fix_noise: bool = False,\\n ) -> List[Tensor]:\\n r\\\"\\\"\\\"Samples from a Normal distribution.\\\"\\\"\\\"\\n if fix_noise:\\n # bs = 1 if fix_noise else mu.size(0)\\n raise NotImplementedError(\\\"fix_noise option isn't implemented yet\\\")\\n eps_xh = self.sample_combined_position_feature_noise(masks=masks)\\n zs_xh = [mu[ii] + sigma[masks[ii]] * eps_xh[ii] for ii in range(len(masks))]\\n return zs_xh\\n\\n def sample_p_xh_given_z0(\\n self,\\n z0_xh: List[Tensor],\\n edge_index: Tensor,\\n n_frag_switch: Tensor,\\n masks: List[Tensor],\\n batch_size: int,\\n conditions: Optional[Tensor] = None,\\n fix_noise: bool = False,\\n ) -> Tuple[List[Tensor]]:\\n \\\"\\\"\\\"Samples x ~ p(x|z0).\\\"\\\"\\\"\\n t_zeros = torch.zeros(size=(batch_size, 1), device=z0_xh[0].device)\\n gamma_0 = self.schedule.gamma_module(t_zeros)\\n # Computes sqrt(sigma_0^2 / alpha_0^2)\\n sigma_x = self.schedule.SNR(-0.5 * gamma_0)\\n net_eps_xh, net_eps_edge_attr = self.dynamics(\\n xh=z0_xh,\\n edge_index=edge_index,\\n t=t_zeros,\\n conditions=conditions,\\n n_frag_switch=n_frag_switch,\\n combined_mask=torch.cat(masks),\\n edge_attr=None, # TODO: no edge_attr is considered now\\n )\\n\\n # Compute mu for p(zs | zt).\\n mu_x = self.compute_x_pred(\\n net_eps_xh=net_eps_xh,\\n zt_xh=z0_xh,\\n gamma_t=gamma_0,\\n masks=masks,\\n )\\n x0_xh = self.sample_normal(\\n mu=mu_x, sigma=sigma_x, masks=masks, fix_noise=fix_noise\\n )\\n\\n pos_0 = [\\n self.normalizer.unnormalize(x0_xh[ii][:, : self.pos_dim], ii)\\n for ii in range(len(masks))\\n ]\\n cat_0 = [\\n self.normalizer.unnormalize(x0_xh[ii][:, self.pos_dim : -1], ii)\\n for ii in range(len(masks))\\n ]\\n charge_0 = [\\n torch.round(self.normalizer.unnormalize(x0_xh[ii][:, -1:], ii)).long()\\n for ii in range(len(masks))\\n ]\\n\\n cat_0 = [\\n F.one_hot(torch.argmax(cat_0[ii], dim=1), self.node_nfs[ii] - 4).long()\\n for ii in range(len(masks))\\n ]\\n return pos_0, cat_0, charge_0\\n\\n def compute_x_pred(\\n self,\\n net_eps_xh: List[Tensor],\\n zt_xh: List[Tensor],\\n gamma_t: Tensor,\\n masks: List[Tensor],\\n ) -> List[Tensor]:\\n \\\"\\\"\\\"Commputes x_pred, i.e. the most likely prediction of x.\\\"\\\"\\\"\\n sigma_t = self.schedule.sigma(gamma_t, target_tensor=net_eps_xh[0])\\n alpha_t = self.schedule.alpha(gamma_t, target_tensor=net_eps_xh[0])\\n x_pred = [\\n 1.0 / alpha_t[masks[ii]] * (zt_xh[ii] - sigma_t[masks[ii]] * net_eps_xh[ii])\\n for ii in range(len(masks))\\n ]\\n return x_pred\\n\\n # ------ INPAINT ------\\n @torch.no_grad()\\n def inpaint(\\n self,\\n n_samples: int,\\n fragments_nodes: List[torch.tensor],\\n conditions: Optional[Tensor] = None,\\n return_frames: int = 1,\\n resamplings: int = 1,\\n jump_length: int = 1,\\n timesteps: Optional[int] = None,\\n xh_fixed: Optional[List[Tensor]] = None,\\n frag_fixed: Optional[List] = None,\\n ):\\n r\\\"\\\"\\\"\\n Draw samples from the generative model. Optionally, return intermediate\\n states for visualization purposes.\\n \\\"\\\"\\\"\\n timesteps = self.T if timesteps is None else timesteps\\n assert 0 < return_frames <= timesteps\\n assert timesteps % return_frames == 0\\n assert len(xh_fixed)\\n\\n fragments_masks = [\\n get_mask_for_frag(natm_nodes) for natm_nodes in fragments_nodes\\n ]\\n combined_mask = torch.cat(fragments_masks)\\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\\n n_frag_switch = get_n_frag_switch(fragments_nodes)\\n\\n h0 = [_xh_fixed[:, self.pos_dim :].long() for _xh_fixed in xh_fixed]\\n\\n for ii, _ in enumerate(xh_fixed):\\n xh_fixed[ii][:, : self.pos_dim] = utils.remove_mean_batch(\\n xh_fixed[ii][:, : self.pos_dim],\\n fragments_masks[ii],\\n )\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_xh_fixed[:, : self.pos_dim] for _xh_fixed in xh_fixed],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n zt_xh = self.sample_combined_position_feature_noise(masks=fragments_masks)\\n if self.pos_only:\\n zt_xh = [\\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n out_samples = [\\n [\\n torch.zeros((return_frames,) + _zt_xh.size(), device=_zt_xh.device)\\n for _zt_xh in zt_xh\\n ]\\n for _ in range(return_frames)\\n ]\\n\\n schedule = get_repaint_schedule(resamplings, jump_length, timesteps)\\n s = timesteps - 1\\n for i, n_denoise_steps in enumerate(schedule):\\n for j in range(n_denoise_steps):\\n s_array = torch.full(\\n (n_samples, 1), fill_value=s, device=zt_xh[0].device\\n )\\n t_array = s_array + 1\\n s_array = s_array / timesteps\\n t_array = t_array / timesteps\\n\\n gamma_s = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(s_array), xh_fixed[0]\\n )\\n\\n zt_known, _ = self.noised_representation(\\n xh_fixed, fragments_masks, gamma_s\\n )\\n zt_unknown = self.sample_p_zs_given_zt(\\n s=s_array,\\n t=t_array,\\n zt_xh=zt_xh,\\n edge_index=edge_index,\\n n_frag_switch=n_frag_switch,\\n masks=fragments_masks,\\n conditions=conditions,\\n fix_noise=False,\\n )\\n\\n if self.pos_only:\\n zt_known = [\\n torch.cat([zt_known[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n zt_unknown = [\\n torch.cat([zt_unknown[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n\\n zt_xh = [\\n zt_known[ii] if ii in frag_fixed else zt_unknown[ii]\\n for ii in range(len(h0))\\n ]\\n\\n # Noise combined representation, i.e., resample\\n if j == n_denoise_steps - 1 and i < len(schedule) - 1:\\n # Go back jump_length steps\\n t = s + jump_length\\n t_array = torch.full(\\n (n_samples, 1), fill_value=t, device=zt_xh[0].device\\n )\\n t_array = t_array / timesteps\\n\\n gamma_s = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(s_array), xh_fixed[0]\\n )\\n gamma_t = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(t_array), xh_fixed[0]\\n )\\n\\n zt_xh = self.sample_p_zt_given_zs(\\n zt_xh, fragments_masks, gamma_t, gamma_s\\n )\\n s = t\\n\\n s = s - 1\\n\\n # # save frame\\n # if (s * return_frames) % timesteps == 0:\\n # idx = (s * return_frames) // timesteps\\n # out_samples[idx] = self.normalizer.unnormalize_z(zt_xh)\\n\\n pos, cat, charge = self.sample_p_xh_given_z0(\\n z0_xh=zt_xh,\\n edge_index=edge_index,\\n n_frag_switch=n_frag_switch,\\n masks=fragments_masks,\\n batch_size=n_samples,\\n conditions=conditions,\\n )\\n if self.pos_only:\\n cat = [_h0[:, :-1] for _h0 in h0]\\n charge = [_h0[:, -1:] for _h0 in h0]\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_pos[:, : self.pos_dim] for _pos in pos],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n # Overwrite last frame with the resulting x and h.\\n out_samples[0] = [\\n torch.cat([pos[ii], cat[ii], charge[ii]], dim=1) for ii in range(len(pos))\\n ]\\n return out_samples, fragments_masks\\n\\n # ------ INPAINT ------\\n @torch.no_grad()\\n def inpaint_fixed(\\n self,\\n n_samples: int,\\n fragments_nodes: List[torch.tensor],\\n conditions: Optional[Tensor] = None,\\n return_frames: int = 1,\\n resamplings: int = 1,\\n jump_length: int = 1,\\n timesteps: Optional[int] = None,\\n xh_fixed: Optional[List[Tensor]] = None,\\n frag_fixed: Optional[List] = None,\\n ):\\n r\\\"\\\"\\\"\\n Draw samples from the generative model. Optionally, return intermediate\\n states for visualization purposes.\\n \\\"\\\"\\\"\\n timesteps = self.T if timesteps is None else timesteps\\n assert 0 < return_frames <= timesteps\\n assert timesteps % return_frames == 0\\n assert len(xh_fixed)\\n\\n fragments_masks = [\\n get_mask_for_frag(natm_nodes) for natm_nodes in fragments_nodes\\n ]\\n combined_mask = torch.cat(fragments_masks)\\n edge_index = get_edges_index(combined_mask, remove_self_edge=True)\\n n_frag_switch = get_n_frag_switch(fragments_nodes)\\n\\n h0 = [_xh_fixed[:, self.pos_dim :].long() for _xh_fixed in xh_fixed]\\n\\n for ii, _ in enumerate(xh_fixed):\\n xh_fixed[ii][:, : self.pos_dim] = utils.remove_mean_batch(\\n xh_fixed[ii][:, : self.pos_dim],\\n fragments_masks[ii],\\n )\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_xh_fixed[:, : self.pos_dim] for _xh_fixed in xh_fixed],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n zt_xh = self.sample_combined_position_feature_noise(masks=fragments_masks)\\n if self.pos_only:\\n zt_xh = [\\n torch.cat([zt_xh[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_zt_xh[:, : self.pos_dim] for _zt_xh in zt_xh],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n out_samples = [\\n [\\n torch.zeros((return_frames,) + _zt_xh.size(), device=_zt_xh.device)\\n for _zt_xh in zt_xh\\n ]\\n for _ in range(return_frames)\\n ]\\n\\n schedule = get_repaint_schedule(resamplings, jump_length, timesteps)\\n s = timesteps - 1\\n for i, n_denoise_steps in enumerate(schedule):\\n for j in range(n_denoise_steps):\\n s_array = torch.full(\\n (n_samples, 1), fill_value=s, device=zt_xh[0].device\\n )\\n t_array = s_array + 1\\n s_array = s_array / timesteps\\n t_array = t_array / timesteps\\n\\n gamma_s = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(s_array), xh_fixed[0]\\n )\\n\\n zt_known, _ = self.noised_representation(\\n xh_fixed, fragments_masks, gamma_s\\n )\\n zt_unknown = self.sample_p_zs_given_zt(\\n s=s_array,\\n t=t_array,\\n zt_xh=zt_xh,\\n edge_index=edge_index,\\n n_frag_switch=n_frag_switch,\\n masks=fragments_masks,\\n conditions=conditions,\\n fix_noise=False,\\n )\\n\\n if self.pos_only:\\n zt_known = [\\n torch.cat([zt_known[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n zt_unknown = [\\n torch.cat([zt_unknown[ii][:, : self.pos_dim], h0[ii]], dim=1)\\n for ii in range(len(h0))\\n ]\\n\\n zt_xh = [\\n zt_known[ii] if ii in frag_fixed else zt_unknown[ii]\\n for ii in range(len(h0))\\n ]\\n\\n # Noise combined representation, i.e., resample\\n if j == n_denoise_steps - 1 and i < len(schedule) - 1:\\n # Go back jump_length steps\\n t = s + jump_length\\n t_array = torch.full(\\n (n_samples, 1), fill_value=t, device=zt_xh[0].device\\n )\\n t_array = t_array / timesteps\\n\\n gamma_s = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(s_array), xh_fixed[0]\\n )\\n gamma_t = self.schedule.inflate_batch_array(\\n self.schedule.gamma_module(t_array), xh_fixed[0]\\n )\\n\\n zt_xh = self.sample_p_zt_given_zs(\\n zt_xh, fragments_masks, gamma_t, gamma_s\\n )\\n s = t\\n\\n s = s - 1\\n\\n # # save frame\\n # if (s * return_frames) % timesteps == 0:\\n # idx = (s * return_frames) // timesteps\\n # out_samples[idx] = self.normalizer.unnormalize_z(zt_xh)\\n\\n pos, cat, charge = self.sample_p_xh_given_z0(\\n z0_xh=zt_xh,\\n edge_index=edge_index,\\n n_frag_switch=n_frag_switch,\\n masks=fragments_masks,\\n batch_size=n_samples,\\n conditions=conditions,\\n )\\n if self.pos_only:\\n cat = [_h0[:, :-1] for _h0 in h0]\\n charge = [_h0[:, -1:] for _h0 in h0]\\n utils.assert_mean_zero_with_mask(\\n torch.cat(\\n [_pos[:, : self.pos_dim] for _pos in pos],\\n dim=0,\\n ),\\n combined_mask,\\n )\\n\\n # Overwrite last frame with the resulting x and h.\\n out_samples[0] = [\\n torch.cat([pos[ii], cat[ii], charge[ii]], dim=1) for ii in range(len(pos))\\n ]\\n return out_samples, fragments_masks\\n\\n def sample_p_zt_given_zs(\\n self,\\n zs: List[Tensor],\\n masks: List[Tensor],\\n gamma_t: Tensor,\\n gamma_s: Tensor,\\n fix_noise: bool = False,\\n ) -> List[Tensor]:\\n (\\n sigma2_t_given_s,\\n sigma_t_given_s,\\n alpha_t_given_s,\\n ) = self.schedule.sigma_and_alpha_t_given_s(gamma_t, gamma_s, zs[0])\\n\\n mu = [alpha_t_given_s[masks[ii]] * zs[ii] for ii in range(len(masks))]\\n zt = self.sample_normal(\\n mu=mu, sigma=sigma_t_given_s, masks=masks, fix_noise=fix_noise\\n )\\n\\n for ii in range(len(masks)):\\n zt[ii][:, : self.pos_dim] = utils.remove_mean_batch(\\n zt[ii][:, : self.pos_dim],\\n masks[ii],\\n )\\n return zt\"\n },\n {\n \"identifier\": \"average_over_batch_metrics\",\n \"path\": \"oa_reactdiff/trainer/_metrics.py\",\n \"snippet\": \"def average_over_batch_metrics(batch_metrics: List[Dict], allowed: List = []):\\n epoch_metrics = {}\\n effective_batch = {}\\n for ii, out in enumerate(batch_metrics):\\n for k, v in out.items():\\n if not (k in allowed or len(allowed) == 0):\\n continue\\n if ii == 0:\\n epoch_metrics[k] = v\\n effective_batch[k] = 1\\n else:\\n if not np.isnan(v):\\n epoch_metrics[k] += v\\n effective_batch[k] += 1\\n for k in epoch_metrics:\\n epoch_metrics[k] /= effective_batch[k]\\n return epoch_metrics\"\n },\n {\n \"identifier\": \"pretty_print\",\n \"path\": \"oa_reactdiff/trainer/_metrics.py\",\n \"snippet\": \"def pretty_print(epoch, metric_dict, prefix=\\\"Train\\\"):\\n out = f\\\"{prefix} epoch {epoch} \\\"\\n for k, v in metric_dict.items():\\n out += f\\\"{k} {v:.2f} \\\"\\n print(out)\"\n },\n {\n \"identifier\": \"batch_rmsd\",\n \"path\": \"oa_reactdiff/analyze/rmsd.py\",\n \"snippet\": \"def batch_rmsd(\\n fragments_nodes: List[Tensor],\\n out_samples: List[Tensor],\\n xh: List[Tensor],\\n idx: int = 1,\\n threshold=0.5,\\n):\\n rmsds = []\\n out_samples_use = out_samples[idx]\\n xh_use = xh[idx]\\n nodes = fragments_nodes[idx].long().cpu().numpy()\\n start_ind, end_ind = 0, 0\\n for jj, natoms in enumerate(nodes):\\n end_ind += natoms\\n mol1 = xh2pmg(out_samples_use[start_ind:end_ind])\\n mol2 = xh2pmg(xh_use[start_ind:end_ind])\\n try:\\n rmsd = pymatgen_rmsd(mol1, mol2, ignore_chirality=True, threshold=threshold)\\n except:\\n rmsd = 1.0\\n rmsds.append(min(rmsd, 1.0))\\n start_ind = end_ind\\n return rmsds\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from typing import Dict, List, Optional, Tuple\nfrom pathlib import Path\nfrom torch import nn\nfrom torch.utils.data import DataLoader\nfrom torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, StepLR\nfrom pytorch_lightning import LightningModule\nfrom torchmetrics.classification import (\n BinaryAccuracy,\n BinaryAUROC,\n BinaryF1Score,\n BinaryPrecision,\n BinaryCohenKappa,\n)\nfrom torchmetrics import PearsonCorrCoef, SpearmanCorrCoef, MeanAbsoluteError\nfrom oa_reactdiff.dataset import (\n ProcessedQM9,\n ProcessedDoubleQM9,\n ProcessedTripleQM9,\n ProcessedTS1x,\n)\nfrom oa_reactdiff.dynamics import EGNNDynamics, Confidence\nfrom oa_reactdiff.diffusion._schedule import DiffSchedule, PredefinedNoiseSchedule\nfrom oa_reactdiff.diffusion._normalizer import Normalizer, FEATURE_MAPPING\nfrom oa_reactdiff.diffusion.en_diffusion import EnVariationalDiffusion\nfrom oa_reactdiff.trainer._metrics import average_over_batch_metrics, pretty_print\nfrom oa_reactdiff.analyze.rmsd import batch_rmsd\nimport torch\nimport copy\nimport torch.nn.functional as F\nimport numpy as np\nimport pandas as pd\nimport oa_reactdiff.utils.training_tools as utils"},"token_num":{"kind":"number","value":20037,"string":"20,037"},"cropped_code":{"kind":"string","value":"\n\n\n\nPROCESS_FUNC = {\n \"QM9\": ProcessedQM9,\n \"DoubleQM9\": ProcessedDoubleQM9,\n \"TripleQM9\": ProcessedTripleQM9,\n \"TS1x\": ProcessedTS1x,\n}\nFILE_TYPE = {\n \"QM9\": \".npz\",\n \"DoubleQM9\": \".npz\",\n \"TripleQM9\": \".npz\",\n \"TS1x\": \".pkl\",\n}\nLR_SCHEDULER = {\n \"cos\": CosineAnnealingWarmRestarts,\n \"step\": StepLR,\n}\n\n\nclass DDPMModule(LightningModule):\n def __init__(\n self,\n model_config: Dict,\n optimizer_config: Dict,\n training_config: Dict,\n node_nfs: List[int] = [9] * 3,\n edge_nf: int = 4,\n condition_nf: int = 3,\n fragment_names: List[str] = [\"inorg_node\", \"org_edge\", \"org_node\"],\n pos_dim: int = 3,\n update_pocket_coords: bool = True,\n condition_time: bool = True,\n edge_cutoff: Optional[float] = None,\n norm_values: Tuple = (1.0, 1.0, 1.0),\n norm_biases: Tuple = (0.0, 0.0, 0.0),\n noise_schedule: str = \"polynomial_2\",\n timesteps: int = 1000,\n precision: float = 1e-5,\n loss_type: str = \"l2\",\n pos_only: bool = False,\n process_type: Optional[str] = None,\n model: nn.Module = None,\n enforce_same_encoding: Optional[List] = None,\n scales: List[float] = [1.0, 1.0, 1.0],\n eval_epochs: int = 20,\n source: Optional[Dict] = None,\n fixed_idx: Optional[List] = None,\n ) -> None:\n super().__init__()\n egnn_dynamics = EGNNDynamics(\n model_config=model_config,\n node_nfs=node_nfs,\n edge_nf=edge_nf,\n condition_nf=condition_nf,\n fragment_names=fragment_names,\n pos_dim=pos_dim,\n update_pocket_coords=update_pocket_coords,\n condition_time=condition_time,\n edge_cutoff=edge_cutoff,\n model=model,\n enforce_same_encoding=enforce_same_encoding,\n source=source,\n )\n\n normalizer = Normalizer(\n norm_values=norm_values,\n norm_biases=norm_biases,\n pos_dim=pos_dim,\n )\n\n gamma_module = PredefinedNoiseSchedule(\n noise_schedule=noise_schedule,\n timesteps=timesteps,\n precision=precision,\n )\n"},"all_code":{"kind":"string","value":"\n\n\n\nPROCESS_FUNC = {\n \"QM9\": ProcessedQM9,\n \"DoubleQM9\": ProcessedDoubleQM9,\n \"TripleQM9\": ProcessedTripleQM9,\n \"TS1x\": ProcessedTS1x,\n}\nFILE_TYPE = {\n \"QM9\": \".npz\",\n \"DoubleQM9\": \".npz\",\n \"TripleQM9\": \".npz\",\n \"TS1x\": \".pkl\",\n}\nLR_SCHEDULER = {\n \"cos\": CosineAnnealingWarmRestarts,\n \"step\": StepLR,\n}\n\n\nclass DDPMModule(LightningModule):\n def __init__(\n self,\n model_config: Dict,\n optimizer_config: Dict,\n training_config: Dict,\n node_nfs: List[int] = [9] * 3,\n edge_nf: int = 4,\n condition_nf: int = 3,\n fragment_names: List[str] = [\"inorg_node\", \"org_edge\", \"org_node\"],\n pos_dim: int = 3,\n update_pocket_coords: bool = True,\n condition_time: bool = True,\n edge_cutoff: Optional[float] = None,\n norm_values: Tuple = (1.0, 1.0, 1.0),\n norm_biases: Tuple = (0.0, 0.0, 0.0),\n noise_schedule: str = \"polynomial_2\",\n timesteps: int = 1000,\n precision: float = 1e-5,\n loss_type: str = \"l2\",\n pos_only: bool = False,\n process_type: Optional[str] = None,\n model: nn.Module = None,\n enforce_same_encoding: Optional[List] = None,\n scales: List[float] = [1.0, 1.0, 1.0],\n eval_epochs: int = 20,\n source: Optional[Dict] = None,\n fixed_idx: Optional[List] = None,\n ) -> None:\n super().__init__()\n egnn_dynamics = EGNNDynamics(\n model_config=model_config,\n node_nfs=node_nfs,\n edge_nf=edge_nf,\n condition_nf=condition_nf,\n fragment_names=fragment_names,\n pos_dim=pos_dim,\n update_pocket_coords=update_pocket_coords,\n condition_time=condition_time,\n edge_cutoff=edge_cutoff,\n model=model,\n enforce_same_encoding=enforce_same_encoding,\n source=source,\n )\n\n normalizer = Normalizer(\n norm_values=norm_values,\n norm_biases=norm_biases,\n pos_dim=pos_dim,\n )\n\n gamma_module = PredefinedNoiseSchedule(\n noise_schedule=noise_schedule,\n timesteps=timesteps,\n precision=precision,\n )"},"next_line":{"kind":"string","value":" schedule = DiffSchedule(gamma_module=gamma_module, norm_values=norm_values)"},"gold_snippet_index":{"kind":"number","value":6,"string":"6"},"created_at":{"kind":"string","value":"2023-10-30 02:53:38+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5686,"cells":{"repo_name":{"kind":"string","value":"nv-tlabs/pacer"},"file_path":{"kind":"string","value":"poselib/poselib/skeleton/tests/test_skeleton.py"},"context":{"kind":"list like","value":[{"identifier":"SkeletonTree","path":"poselib/poselib/skeleton/skeleton3d.py","snippet":"class SkeletonTree(Serializable):\n \"\"\"\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\n over a list of nodes with their names indicated by strings. Each edge in the tree has a local\n translation associated with it which describes the distance between the two nodes that it\n connects. \n\n Basic Usage:\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\n >>> t\n SkeletonTree(\n node_names=['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot'],\n parent_indices=tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11]),\n local_translation=tensor([[ 0.0000, 0.0000, 0.7500],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, -0.2000, 0.0000],\n [ 0.2000, -0.2000, 0.0000]])\n )\n >>> t.node_names\n ['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot']\n >>> t.parent_indices\n tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11])\n >>> t.local_translation\n tensor([[ 0.0000, 0.0000, 0.7500],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [-0.2000, 0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [-0.2000, -0.2000, 0.0000],\n [ 0.0000, 0.0000, 0.0000],\n [ 0.2000, -0.2000, 0.0000],\n [ 0.2000, -0.2000, 0.0000]])\n >>> t.parent_of('front_left_leg')\n 'torso'\n >>> t.index('front_right_foot')\n 6\n >>> t[2]\n 'aux_1'\n \"\"\"\n\n __example_mjcf_path__ = os.path.join(\n os.path.dirname(os.path.realpath(__file__)), \"tests/ant.xml\"\n )\n\n def __init__(self, node_names, parent_indices, local_translation, local_xml_rotation):\n \"\"\"\n :param node_names: a list of names for each tree node\n :type node_names: List[str]\n :param parent_indices: an int32-typed tensor that represents the edge to its parent.\\\n -1 represents the root node\n :type parent_indices: Tensor\n :param local_translation: a 3d vector that gives local translation information\n :type local_translation: Tensor\n \"\"\"\n ln, lp, ll = len(node_names), len(parent_indices), len(local_translation)\n assert len(set((ln, lp, ll))) == 1\n self._node_names = node_names\n self._parent_indices = parent_indices.long()\n self._local_translation = local_translation\n self._local_xml_rotation = local_xml_rotation\n self._node_indices = {self.node_names[i]: i for i in range(len(self))}\n\n def __len__(self):\n \"\"\" number of nodes in the skeleton tree \"\"\"\n return len(self.node_names)\n\n def __iter__(self):\n \"\"\" iterator that iterate through the name of each node \"\"\"\n yield from self.node_names\n\n def __getitem__(self, item):\n \"\"\" get the name of the node given the index \"\"\"\n return self.node_names[item]\n\n def __repr__(self):\n return (\n \"SkeletonTree(\\n node_names={},\\n parent_indices={},\"\n \"\\n local_translation={}\\n)\".format(\n self._indent(repr(self.node_names)),\n self._indent(repr(self.parent_indices)),\n self._indent(repr(self.local_translation)),\n )\n )\n\n def _indent(self, s):\n return \"\\n \".join(s.split(\"\\n\"))\n\n @property\n def node_names(self):\n return self._node_names\n\n @property\n def parent_indices(self):\n return self._parent_indices\n\n @property\n def local_translation(self):\n return self._local_translation\n\n @property\n def num_joints(self):\n \"\"\" number of nodes in the skeleton tree \"\"\"\n return len(self)\n\n @classmethod\n def from_dict(cls, dict_repr, *args, **kwargs):\n return cls(\n list(map(str, dict_repr[\"node_names\"])),\n TensorUtils.from_dict(dict_repr[\"parent_indices\"], *args,\n **kwargs),\n TensorUtils.from_dict(dict_repr[\"local_translation\"], *args,\n **kwargs),\n TensorUtils.from_dict(dict_repr[\"local_xml_rotation\"], *args,\n **kwargs),\n )\n\n def to_dict(self):\n return OrderedDict(\n [\n (\"node_names\", self.node_names),\n (\"parent_indices\", tensor_to_dict(self.parent_indices)),\n (\"local_translation\", tensor_to_dict(self.local_translation)),\n (\"local_xml_rotation\", tensor_to_dict(self._local_xml_rotation)),\n ]\n )\n\n @classmethod\n def from_mjcf(cls, path: str) -> \"SkeletonTree\":\n \"\"\"\n Parses a mujoco xml scene description file and returns a Skeleton Tree.\n We use the model attribute at the root as the name of the tree.\n \n :param path:\n :type path: string\n :return: The skeleton tree constructed from the mjcf file\n :rtype: SkeletonTree\n \"\"\"\n tree = ET.parse(path)\n xml_doc_root = tree.getroot()\n xml_world_body = xml_doc_root.find(\"worldbody\")\n if xml_world_body is None:\n raise ValueError(\"MJCF parsed incorrectly please verify it.\")\n # assume this is the root\n xml_body_root = xml_world_body.find(\"body\")\n if xml_body_root is None:\n raise ValueError(\"MJCF parsed incorrectly please verify it.\")\n\n node_names = []\n parent_indices = []\n local_translation = []\n local_xml_rotation = []\n\n # recursively adding all nodes into the skel_tree\n def _add_xml_node(xml_node, parent_index, node_index):\n node_name = xml_node.attrib.get(\"name\")\n # parse the local translation into float list\n pos = np.fromstring(xml_node.attrib.get(\"pos\"), dtype=float, sep=\" \")\n quat = np.fromstring(xml_node.attrib.get(\"quat\", \"1 0 0 0\"), dtype=float, sep=\" \")[[1, 2, 3, 0]]\n node_names.append(node_name)\n parent_indices.append(parent_index)\n local_translation.append(pos)\n local_xml_rotation.append(quat)\n curr_index = node_index\n node_index += 1\n for next_node in xml_node.findall(\"body\"):\n node_index = _add_xml_node(next_node, curr_index, node_index)\n return node_index\n\n _add_xml_node(xml_body_root, -1, 0)\n\n return cls(\n node_names,\n torch.from_numpy(np.array(parent_indices, dtype=np.int32)),\n torch.from_numpy(np.array(local_translation, dtype=np.float32)),\n torch.from_numpy(np.array(local_xml_rotation, dtype=np.float32)),\n )\n\n def parent_of(self, node_name):\n \"\"\" get the name of the parent of the given node\n\n :param node_name: the name of the node\n :type node_name: string\n :rtype: string\n \"\"\"\n return self[int(self.parent_indices[self.index(node_name)].item())]\n\n def index(self, node_name):\n \"\"\" get the index of the node\n \n :param node_name: the name of the node\n :type node_name: string\n :rtype: int\n \"\"\"\n return self._node_indices[node_name]\n\n def drop_nodes_by_names(\n self, node_names: List[str], pairwise_translation=None\n ) -> \"SkeletonTree\":\n new_length = len(self) - len(node_names)\n new_node_names = []\n new_local_translation = torch.zeros(\n new_length, 3, dtype=self.local_translation.dtype\n )\n new_parent_indices = torch.zeros(new_length, dtype=self.parent_indices.dtype)\n parent_indices = self.parent_indices.numpy()\n new_node_indices: dict = {}\n new_node_index = 0\n for node_index in range(len(self)):\n if self[node_index] in node_names:\n continue\n tb_node_index = parent_indices[node_index]\n if tb_node_index != -1:\n local_translation = self.local_translation[node_index, :]\n while tb_node_index != -1 and self[tb_node_index] in node_names:\n local_translation += self.local_translation[tb_node_index, :]\n tb_node_index = parent_indices[tb_node_index]\n assert tb_node_index != -1, \"the root node cannot be dropped\"\n\n if pairwise_translation is not None:\n local_translation = pairwise_translation[\n tb_node_index, node_index, :\n ]\n else:\n local_translation = self.local_translation[node_index, :]\n\n new_node_names.append(self[node_index])\n new_local_translation[new_node_index, :] = local_translation\n if tb_node_index == -1:\n new_parent_indices[new_node_index] = -1\n else:\n new_parent_indices[new_node_index] = new_node_indices[\n self[tb_node_index]\n ]\n new_node_indices[self[node_index]] = new_node_index\n new_node_index += 1\n\n return SkeletonTree(new_node_names, new_parent_indices, new_local_translation)\n\n def keep_nodes_by_names(\n self, node_names: List[str], pairwise_translation=None\n ) -> \"SkeletonTree\":\n nodes_to_drop = list(filter(lambda x: x not in node_names, self))\n return self.drop_nodes_by_names(nodes_to_drop, pairwise_translation)"},{"identifier":"SkeletonState","path":"poselib/poselib/skeleton/skeleton3d.py","snippet":"class SkeletonState(Serializable):\n \"\"\"\n A skeleton state contains all the information needed to describe a static state of a skeleton.\n It requires a skeleton tree, local/global rotation at each joint and the root translation.\n\n Example:\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\n >>> zero_pose = SkeletonState.zero_pose(t)\n >>> plot_skeleton_state(zero_pose) # can be imported from `.visualization.common`\n [plot of the ant at zero pose\n >>> local_rotation = zero_pose.local_rotation.clone()\n >>> local_rotation[2] = torch.tensor([0, 0, 1, 0])\n >>> new_pose = SkeletonState.from_rotation_and_root_translation(\n ... skeleton_tree=t,\n ... r=local_rotation,\n ... t=zero_pose.root_translation,\n ... is_local=True\n ... )\n >>> new_pose.local_rotation\n tensor([[0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 1., 0., 0.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.]])\n >>> plot_skeleton_state(new_pose) # you should be able to see one of ant's leg is bent\n [plot of the ant with the new pose\n >>> new_pose.global_rotation # the local rotation is propagated to the global rotation at joint #3\n tensor([[0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 1., 0., 0.],\n [0., 1., 0., 0.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.],\n [0., 0., 0., 1.]])\n\n Global/Local Representation (cont. from the previous example)\n >>> new_pose.is_local\n True\n >>> new_pose.tensor # this will return the local rotation followed by the root translation\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0.,\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\n 0.])\n >>> new_pose.tensor.shape # 4 * 13 (joint rotation) + 3 (root translatio\n torch.Size([55])\n >>> new_pose.global_repr().is_local\n False\n >>> new_pose.global_repr().tensor # this will return the global rotation followed by the root translation instead\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0.,\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\n 0.])\n >>> new_pose.global_repr().tensor.shape # 4 * 13 (joint rotation) + 3 (root translation\n torch.Size([55])\n \"\"\"\n\n def __init__(self, tensor_backend, skeleton_tree, is_local):\n self._skeleton_tree = skeleton_tree\n self._is_local = is_local\n self.tensor = tensor_backend.clone()\n\n def __len__(self):\n return self.tensor.shape[0]\n\n @property\n def rotation(self):\n if not hasattr(self, \"_rotation\"):\n self._rotation = self.tensor[..., : self.num_joints * 4].reshape(\n *(self.tensor.shape[:-1] + (self.num_joints, 4))\n )\n return self._rotation\n\n @property\n def _local_rotation(self):\n if self._is_local:\n return self.rotation\n else:\n return None\n\n @property\n def _global_rotation(self):\n if not self._is_local:\n return self.rotation\n else:\n return None\n\n @property\n def is_local(self):\n \"\"\" is the rotation represented in local frame? \n \n :rtype: bool\n \"\"\"\n return self._is_local\n\n @property\n def invariant_property(self):\n return {\"skeleton_tree\": self.skeleton_tree, \"is_local\": self.is_local}\n\n @property\n def num_joints(self):\n \"\"\" number of joints in the skeleton tree \n \n :rtype: int\n \"\"\"\n return self.skeleton_tree.num_joints\n\n @property\n def skeleton_tree(self):\n \"\"\" skeleton tree \n \n :rtype: SkeletonTree\n \"\"\"\n return self._skeleton_tree\n\n @property\n def root_translation(self):\n \"\"\" root translation \n \n :rtype: Tensor\n \"\"\"\n if not hasattr(self, \"_root_translation\"):\n self._root_translation = self.tensor[\n ..., self.num_joints * 4 : self.num_joints * 4 + 3\n ]\n return self._root_translation\n\n @property\n def global_transformation(self):\n \"\"\" global transformation of each joint (transform from joint frame to global frame) \"\"\"\n # Forward kinemaitcs.\n \n if not hasattr(self, \"_global_transformation\"):\n local_transformation = self.local_transformation.clone()\n global_transformation = []\n parent_indices = self.skeleton_tree.parent_indices.numpy()\n # global_transformation = local_transformation.identity_like()\n \n local_transformation[..., :4] = quat_mul(\n self.skeleton_tree._local_xml_rotation,\n local_transformation[..., :4])\n\n for node_index in range(len(self.skeleton_tree)):\n parent_index = parent_indices[node_index]\n if parent_index == -1:\n global_transformation.append(\n local_transformation[..., node_index, :]\n )\n else:\n # Here to factor in the local xml rotation\n\n global_transformation.append(\n transform_mul(\n global_transformation[parent_index],\n local_transformation[..., node_index, :],\n )\n )\n self._global_transformation = torch.stack(global_transformation, axis=-2)\n return self._global_transformation\n\n @property\n def global_rotation(self):\n \"\"\" global rotation of each joint (rotation matrix to rotate from joint's F.O.R to global\n F.O.R) \"\"\"\n if self._global_rotation is None:\n if not hasattr(self, \"_comp_global_rotation\"):\n self._comp_global_rotation = transform_rotation(\n self.global_transformation\n )\n return self._comp_global_rotation\n else:\n return self._global_rotation\n\n @property\n def global_translation(self):\n \"\"\" global translation of each joint \"\"\"\n if not hasattr(self, \"_global_translation\"):\n self._global_translation = transform_translation(self.global_transformation)\n return self._global_translation\n\n @property\n def global_translation_xy(self):\n \"\"\" global translation in xy \"\"\"\n trans_xy_data = self.global_translation.zeros_like()\n trans_xy_data[..., 0:2] = self.global_translation[..., 0:2]\n return trans_xy_data\n\n @property\n def global_translation_xz(self):\n \"\"\" global translation in xz \"\"\"\n trans_xz_data = self.global_translation.zeros_like()\n trans_xz_data[..., 0:1] = self.global_translation[..., 0:1]\n trans_xz_data[..., 2:3] = self.global_translation[..., 2:3]\n return trans_xz_data\n\n @property\n def local_rotation(self):\n \"\"\" the rotation from child frame to parent frame given in the order of child nodes appeared\n in `.skeleton_tree.node_names` \"\"\"\n if self._local_rotation is None:\n if not hasattr(self, \"_comp_local_rotation\"):\n local_rotation = quat_identity_like(self.global_rotation)\n for node_index in range(len(self.skeleton_tree)):\n parent_index = self.skeleton_tree.parent_indices[node_index]\n if parent_index == -1:\n local_rotation[..., node_index, :] = self.global_rotation[\n ..., node_index, :\n ]\n else:\n local_rotation[..., node_index, :] = quat_mul_norm(\n quat_inverse(self.global_rotation[..., parent_index, :]),\n self.global_rotation[..., node_index, :],\n )\n self._comp_local_rotation = local_rotation\n return self._comp_local_rotation\n else:\n return self._local_rotation\n\n @property\n def local_transformation(self):\n \"\"\" local translation + local rotation. It describes the transformation from child frame to \n parent frame given in the order of child nodes appeared in `.skeleton_tree.node_names` \"\"\"\n if not hasattr(self, \"_local_transformation\"):\n self._local_transformation = transform_from_rotation_translation(\n r=self.local_rotation, t=self.local_translation\n )\n return self._local_transformation\n\n @property\n def local_translation(self):\n \"\"\" local translation of the skeleton state. It is identical to the local translation in\n `.skeleton_tree.local_translation` except the root translation. The root translation is\n identical to `.root_translation` \"\"\"\n if not hasattr(self, \"_local_translation\"):\n broadcast_shape = (\n tuple(self.tensor.shape[:-1])\n + (len(self.skeleton_tree),)\n + tuple(self.skeleton_tree.local_translation.shape[-1:])\n )\n local_translation = self.skeleton_tree.local_translation.broadcast_to(\n *broadcast_shape\n ).clone()\n local_translation[..., 0, :] = self.root_translation\n self._local_translation = local_translation\n return self._local_translation\n\n # Root Properties\n @property\n def root_translation_xy(self):\n \"\"\" root translation on xy \"\"\"\n if not hasattr(self, \"_root_translation_xy\"):\n self._root_translation_xy = self.global_translation_xy[..., 0, :]\n return self._root_translation_xy\n\n @property\n def global_root_rotation(self):\n \"\"\" root rotation \"\"\"\n if not hasattr(self, \"_global_root_rotation\"):\n self._global_root_rotation = self.global_rotation[..., 0, :]\n return self._global_root_rotation\n\n @property\n def global_root_yaw_rotation(self):\n \"\"\" root yaw rotation \"\"\"\n if not hasattr(self, \"_global_root_yaw_rotation\"):\n self._global_root_yaw_rotation = self.global_root_rotation.yaw_rotation()\n return self._global_root_yaw_rotation\n\n # Properties relative to root\n @property\n def local_translation_to_root(self):\n \"\"\" The 3D translation from joint frame to the root frame. \"\"\"\n if not hasattr(self, \"_local_translation_to_root\"):\n self._local_translation_to_root = (\n self.global_translation - self.root_translation.unsqueeze(-1)\n )\n return self._local_translation_to_root\n\n @property\n def local_rotation_to_root(self):\n \"\"\" The 3D rotation from joint frame to the root frame. It is equivalent to \n The root_R_world * world_R_node \"\"\"\n return (\n quat_inverse(self.global_root_rotation).unsqueeze(-1) * self.global_rotation\n )\n\n def compute_forward_vector(\n self,\n left_shoulder_index,\n right_shoulder_index,\n left_hip_index,\n right_hip_index,\n gaussian_filter_width=20,\n ):\n \"\"\" Computes forward vector based on cross product of the up vector with \n average of the right->left shoulder and hip vectors \"\"\"\n global_positions = self.global_translation\n # Perpendicular to the forward direction.\n # Uses the shoulders and hips to find this.\n side_direction = (\n global_positions[:, left_shoulder_index].numpy()\n - global_positions[:, right_shoulder_index].numpy()\n + global_positions[:, left_hip_index].numpy()\n - global_positions[:, right_hip_index].numpy()\n )\n side_direction = (\n side_direction\n / np.sqrt((side_direction ** 2).sum(axis=-1))[..., np.newaxis]\n )\n\n # Forward direction obtained by crossing with the up direction.\n forward_direction = np.cross(side_direction, np.array([[0, 1, 0]]))\n\n # Smooth the forward direction with a Gaussian.\n # Axis 0 is the time/frame axis.\n forward_direction = filters.gaussian_filter1d(\n forward_direction, gaussian_filter_width, axis=0, mode=\"nearest\"\n )\n forward_direction = (\n forward_direction\n / np.sqrt((forward_direction ** 2).sum(axis=-1))[..., np.newaxis]\n )\n\n return torch.from_numpy(forward_direction)\n\n @staticmethod\n def _to_state_vector(rot, rt):\n # Tensorbackend: local rotation and translation, rotation is is in quat 33 * 4 + 3\n state_shape = rot.shape[:-2]\n vr = rot.reshape(*(state_shape + (-1,)))\n vt = rt.broadcast_to(*state_shape + rt.shape[-1:]).reshape(\n *(state_shape + (-1,))\n )\n v = torch.cat([vr, vt], axis=-1)\n return v\n\n @classmethod\n def from_dict(\n cls: Type[\"SkeletonState\"], dict_repr: OrderedDict, *args, **kwargs\n ) -> \"SkeletonState\":\n rot = TensorUtils.from_dict(dict_repr[\"rotation\"], *args, **kwargs)\n rt = TensorUtils.from_dict(dict_repr[\"root_translation\"], *args, **kwargs)\n return cls(\n SkeletonState._to_state_vector(rot, rt),\n SkeletonTree.from_dict(dict_repr[\"skeleton_tree\"], *args, **kwargs),\n dict_repr[\"is_local\"],\n )\n\n def to_dict(self) -> OrderedDict:\n return OrderedDict(\n [\n (\"rotation\", tensor_to_dict(self.rotation)),\n (\"root_translation\", tensor_to_dict(self.root_translation)),\n (\"skeleton_tree\", self.skeleton_tree.to_dict()),\n (\"is_local\", self.is_local),\n ]\n )\n\n @classmethod\n def from_rotation_and_root_translation(cls, skeleton_tree, r, t, is_local=True):\n \"\"\"\n Construct a skeleton state from rotation and root translation\n\n :param skeleton_tree: the skeleton tree\n :type skeleton_tree: SkeletonTree\n :param r: rotation (either global or local)\n :type r: Tensor\n :param t: root translation\n :type t: Tensor\n :param is_local: to indicate that whether the rotation is local or global\n :type is_local: bool, optional, default=True\n \"\"\"\n assert (\n r.dim() > 0\n ), \"the rotation needs to have at least 1 dimension (dim = {})\".format(r.dim)\n return cls(\n SkeletonState._to_state_vector(r, t),\n skeleton_tree=skeleton_tree,\n is_local=is_local,\n )\n\n @classmethod\n def zero_pose(cls, skeleton_tree):\n \"\"\"\n Construct a zero-pose skeleton state from the skeleton tree by assuming that all the local\n rotation is 0 and root translation is also 0.\n\n :param skeleton_tree: the skeleton tree as the rigid body\n :type skeleton_tree: SkeletonTree\n \"\"\"\n return cls.from_rotation_and_root_translation(\n skeleton_tree=skeleton_tree,\n r=quat_identity([skeleton_tree.num_joints]),\n t=torch.zeros(3, dtype=skeleton_tree.local_translation.dtype),\n is_local=True,\n )\n\n def local_repr(self):\n \"\"\" \n Convert the skeleton state into local representation. This will only affects the values of\n .tensor. If the skeleton state already has `is_local=True`. This method will do nothing. \n\n :rtype: SkeletonState\n \"\"\"\n if self.is_local:\n return self\n return SkeletonState.from_rotation_and_root_translation(\n self.skeleton_tree,\n r=self.local_rotation,\n t=self.root_translation,\n is_local=True,\n )\n\n def global_repr(self):\n \"\"\" \n Convert the skeleton state into global representation. This will only affects the values of\n .tensor. If the skeleton state already has `is_local=False`. This method will do nothing. \n\n :rtype: SkeletonState\n \"\"\"\n if not self.is_local:\n return self\n return SkeletonState.from_rotation_and_root_translation(\n self.skeleton_tree,\n r=self.global_rotation,\n t=self.root_translation,\n is_local=False,\n )\n\n def _get_pairwise_average_translation(self):\n global_transform_inv = transform_inverse(self.global_transformation)\n p1 = global_transform_inv.unsqueeze(-2)\n p2 = self.global_transformation.unsqueeze(-3)\n\n pairwise_translation = (\n transform_translation(transform_mul(p1, p2))\n .reshape(-1, len(self.skeleton_tree), len(self.skeleton_tree), 3)\n .mean(axis=0)\n )\n return pairwise_translation\n\n def _transfer_to(self, new_skeleton_tree: SkeletonTree):\n old_indices = list(map(self.skeleton_tree.index, new_skeleton_tree))\n return SkeletonState.from_rotation_and_root_translation(\n new_skeleton_tree,\n r=self.global_rotation[..., old_indices, :],\n t=self.root_translation,\n is_local=False,\n )\n\n def drop_nodes_by_names(\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\n ) -> \"SkeletonState\":\n \"\"\" \n Drop a list of nodes from the skeleton and re-compute the local rotation to match the \n original joint position as much as possible. \n\n :param node_names: a list node names that specifies the nodes need to be dropped\n :type node_names: List of strings\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\n or not to re-estimate the local translation from the states (avg.)\n :type estimate_local_translation_from_states: boolean\n :rtype: SkeletonState\n \"\"\"\n if estimate_local_translation_from_states:\n pairwise_translation = self._get_pairwise_average_translation()\n else:\n pairwise_translation = None\n new_skeleton_tree = self.skeleton_tree.drop_nodes_by_names(\n node_names, pairwise_translation\n )\n return self._transfer_to(new_skeleton_tree)\n\n def keep_nodes_by_names(\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\n ) -> \"SkeletonState\":\n \"\"\" \n Keep a list of nodes and drop all other nodes from the skeleton and re-compute the local \n rotation to match the original joint position as much as possible. \n\n :param node_names: a list node names that specifies the nodes need to be dropped\n :type node_names: List of strings\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\n or not to re-estimate the local translation from the states (avg.)\n :type estimate_local_translation_from_states: boolean\n :rtype: SkeletonState\n \"\"\"\n return self.drop_nodes_by_names(\n list(filter(lambda x: (x not in node_names), self)),\n estimate_local_translation_from_states,\n )\n\n def _remapped_to(\n self, joint_mapping: Dict[str, str], target_skeleton_tree: SkeletonTree\n ):\n joint_mapping_inv = {target: source for source, target in joint_mapping.items()}\n reduced_target_skeleton_tree = target_skeleton_tree.keep_nodes_by_names(\n list(joint_mapping_inv)\n )\n n_joints = (\n len(joint_mapping),\n len(self.skeleton_tree),\n len(reduced_target_skeleton_tree),\n )\n assert (\n len(set(n_joints)) == 1\n ), \"the joint mapping is not consistent with the skeleton trees\"\n source_indices = list(\n map(\n lambda x: self.skeleton_tree.index(joint_mapping_inv[x]),\n reduced_target_skeleton_tree,\n )\n )\n target_local_rotation = self.local_rotation[..., source_indices, :]\n return SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=reduced_target_skeleton_tree,\n r=target_local_rotation,\n t=self.root_translation,\n is_local=True,\n )\n\n def retarget_to(\n self,\n joint_mapping: Dict[str, str],\n source_tpose_local_rotation,\n source_tpose_root_translation: np.ndarray,\n target_skeleton_tree: SkeletonTree,\n target_tpose_local_rotation,\n target_tpose_root_translation: np.ndarray,\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n z_up: bool = True,\n ) -> \"SkeletonState\":\n \"\"\" \n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\n implementation with rough approximations. The function follows the procedures below.\n\n Steps:\n 1. Drop the joints from the source (self) that do not belong to the joint mapping\\\n with an implementation that is similar to \"keep_nodes_by_names()\" - take a\\\n look at the function doc for more details (same for source_tpose)\n \n 2. Rotate the source state and the source tpose by \"rotation_to_target_skeleton\"\\\n to align the source with the target orientation\n \n 3. Extract the root translation and normalize it to match the scale of the target\\\n skeleton\n \n 4. Extract the global rotation from source state relative to source tpose and\\\n re-apply the relative rotation to the target tpose to construct the global\\\n rotation after retargetting\n \n 5. Combine the computed global rotation and the root translation from 3 and 4 to\\\n complete the retargeting.\n \n 6. Make feet on the ground (global translation z)\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose_local_rotation: the local rotation of the source skeleton\n :type source_tpose_local_rotation: Tensor\n \n :param source_tpose_root_translation: the root translation of the source tpose\n :type source_tpose_root_translation: np.ndarray\n \n :param target_skeleton_tree: the target skeleton tree\n :type target_skeleton_tree: SkeletonTree\n \n :param target_tpose_local_rotation: the local rotation of the target skeleton\n :type target_tpose_local_rotation: Tensor\n \n :param target_tpose_root_translation: the root translation of the target tpose\n :type target_tpose_root_translation: Tensor\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonState\n \"\"\"\n\n # STEP 0: Preprocess\n source_tpose = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=self.skeleton_tree,\n r=source_tpose_local_rotation,\n t=source_tpose_root_translation,\n is_local=True,\n )\n target_tpose = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=target_skeleton_tree,\n r=target_tpose_local_rotation,\n t=target_tpose_root_translation,\n is_local=True,\n )\n\n # STEP 1: Drop the irrelevant joints\n pairwise_translation = self._get_pairwise_average_translation()\n node_names = list(joint_mapping)\n new_skeleton_tree = self.skeleton_tree.keep_nodes_by_names(\n node_names, pairwise_translation\n )\n\n # TODO: combine the following steps before STEP 3\n source_tpose = source_tpose._transfer_to(new_skeleton_tree)\n source_state = self._transfer_to(new_skeleton_tree)\n\n source_tpose = source_tpose._remapped_to(joint_mapping, target_skeleton_tree)\n source_state = source_state._remapped_to(joint_mapping, target_skeleton_tree)\n\n # STEP 2: Rotate the source to align with the target\n new_local_rotation = source_tpose.local_rotation.clone()\n new_local_rotation[..., 0, :] = quat_mul_norm(\n rotation_to_target_skeleton, source_tpose.local_rotation[..., 0, :]\n )\n\n source_tpose = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=source_tpose.skeleton_tree,\n r=new_local_rotation,\n t=quat_rotate(rotation_to_target_skeleton, source_tpose.root_translation),\n is_local=True,\n )\n\n new_local_rotation = source_state.local_rotation.clone()\n new_local_rotation[..., 0, :] = quat_mul_norm(\n rotation_to_target_skeleton, source_state.local_rotation[..., 0, :]\n )\n source_state = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=source_state.skeleton_tree,\n r=new_local_rotation,\n t=quat_rotate(rotation_to_target_skeleton, source_state.root_translation),\n is_local=True,\n )\n\n # STEP 3: Normalize to match the target scale\n root_translation_diff = (\n source_state.root_translation - source_tpose.root_translation\n ) * scale_to_target_skeleton\n\n # STEP 4: the global rotation from source state relative to source tpose and\n # re-apply to the target\n current_skeleton_tree = source_state.skeleton_tree\n target_tpose_global_rotation = source_state.global_rotation[0, :].clone()\n for current_index, name in enumerate(current_skeleton_tree):\n if name in target_tpose.skeleton_tree:\n target_tpose_global_rotation[\n current_index, :\n ] = target_tpose.global_rotation[\n target_tpose.skeleton_tree.index(name), :\n ]\n\n global_rotation_diff = quat_mul_norm(\n source_state.global_rotation, quat_inverse(source_tpose.global_rotation)\n )\n new_global_rotation = quat_mul_norm(\n global_rotation_diff, target_tpose_global_rotation\n )\n\n # STEP 5: Putting 3 and 4 together\n current_skeleton_tree = source_state.skeleton_tree\n shape = source_state.global_rotation.shape[:-1]\n shape = shape[:-1] + target_tpose.global_rotation.shape[-2:-1]\n new_global_rotation_output = quat_identity(shape)\n for current_index, name in enumerate(target_skeleton_tree):\n while name not in current_skeleton_tree:\n name = target_skeleton_tree.parent_of(name)\n parent_index = current_skeleton_tree.index(name)\n new_global_rotation_output[:, current_index, :] = new_global_rotation[\n :, parent_index, :\n ]\n\n source_state = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree=target_skeleton_tree,\n r=new_global_rotation_output,\n t=target_tpose.root_translation + root_translation_diff,\n is_local=False,\n ).local_repr()\n\n return source_state\n\n def retarget_to_by_tpose(\n self,\n joint_mapping: Dict[str, str],\n source_tpose: \"SkeletonState\",\n target_tpose: \"SkeletonState\",\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n ) -> \"SkeletonState\":\n \"\"\" \n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\n implementation with rough approximations. See the method `retarget_to()` for more information\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose: t-pose of the source skeleton\n :type source_tpose: SkeletonState\n \n :param target_tpose: t-pose of the target skeleton\n :type target_tpose: SkeletonState\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonState\n \"\"\"\n assert (\n len(source_tpose.shape) == 0 and len(target_tpose.shape) == 0\n ), \"the retargeting script currently doesn't support vectorized operations\"\n return self.retarget_to(\n joint_mapping,\n source_tpose.local_rotation,\n source_tpose.root_translation,\n target_tpose.skeleton_tree,\n target_tpose.local_rotation,\n target_tpose.root_translation,\n rotation_to_target_skeleton,\n scale_to_target_skeleton,\n )"},{"identifier":"SkeletonMotion","path":"poselib/poselib/skeleton/skeleton3d.py","snippet":"class SkeletonMotion(SkeletonState):\n def __init__(self, tensor_backend, skeleton_tree, is_local, fps, *args, **kwargs):\n self._fps = fps\n super().__init__(tensor_backend, skeleton_tree, is_local, *args, **kwargs)\n\n def clone(self):\n return SkeletonMotion(\n self.tensor.clone(), self.skeleton_tree, self._is_local, self._fps\n )\n\n @property\n def invariant_property(self):\n return {\n \"skeleton_tree\": self.skeleton_tree,\n \"is_local\": self.is_local,\n \"fps\": self.fps,\n }\n\n @property\n def global_velocity(self):\n \"\"\" global velocity \"\"\"\n curr_index = self.num_joints * 4 + 3\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\n )\n\n @property\n def global_angular_velocity(self):\n \"\"\" global angular velocity \"\"\"\n curr_index = self.num_joints * 7 + 3\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\n )\n\n @property\n def fps(self):\n \"\"\" number of frames per second \"\"\"\n return self._fps\n\n @property\n def time_delta(self):\n \"\"\" time between two adjacent frames \"\"\"\n return 1.0 / self.fps\n\n @property\n def global_root_velocity(self):\n \"\"\" global root velocity \"\"\"\n return self.global_velocity[..., 0, :]\n\n @property\n def global_root_angular_velocity(self):\n \"\"\" global root angular velocity \"\"\"\n return self.global_angular_velocity[..., 0, :]\n\n @classmethod\n def from_state_vector_and_velocity(\n cls,\n skeleton_tree,\n state_vector,\n global_velocity,\n global_angular_velocity,\n is_local,\n fps,\n ):\n \"\"\"\n Construct a skeleton motion from a skeleton state vector, global velocity and angular\n velocity at each joint.\n\n :param skeleton_tree: the skeleton tree that the motion is based on \n :type skeleton_tree: SkeletonTree\n :param state_vector: the state vector from the skeleton state by `.tensor`\n :type state_vector: Tensor\n :param global_velocity: the global velocity at each joint\n :type global_velocity: Tensor\n :param global_angular_velocity: the global angular velocity at each joint\n :type global_angular_velocity: Tensor\n :param is_local: if the rotation ins the state vector is given in local frame\n :type is_local: boolean\n :param fps: number of frames per second\n :type fps: int\n\n :rtype: SkeletonMotion\n \"\"\"\n state_shape = state_vector.shape[:-1]\n v = global_velocity.reshape(*(state_shape + (-1,)))\n av = global_angular_velocity.reshape(*(state_shape + (-1,)))\n new_state_vector = torch.cat([state_vector, v, av], axis=-1)\n return cls(\n new_state_vector, skeleton_tree=skeleton_tree, is_local=is_local, fps=fps,\n )\n\n @classmethod\n def from_skeleton_state(\n cls: Type[\"SkeletonMotion\"], skeleton_state: SkeletonState, fps: int\n ):\n \"\"\"\n Construct a skeleton motion from a skeleton state. The velocities are estimated using second\n order guassian filter along the last axis. The skeleton state must have at least .dim >= 1\n\n :param skeleton_state: the skeleton state that the motion is based on \n :type skeleton_state: SkeletonState\n :param fps: number of frames per second\n :type fps: int\n\n :rtype: SkeletonMotion\n \"\"\"\n\n assert (\n type(skeleton_state) == SkeletonState\n ), \"expected type of {}, got {}\".format(SkeletonState, type(skeleton_state))\n\n global_velocity = SkeletonMotion._compute_velocity(\n p=skeleton_state.global_translation, time_delta=1 / fps\n )\n global_angular_velocity = SkeletonMotion._compute_angular_velocity(\n r=skeleton_state.global_rotation, time_delta=1 / fps\n )\n\n return cls.from_state_vector_and_velocity(\n skeleton_tree=skeleton_state.skeleton_tree,\n state_vector=skeleton_state.tensor,\n global_velocity=global_velocity,\n global_angular_velocity=global_angular_velocity,\n is_local=skeleton_state.is_local,\n fps=fps,\n )\n\n @staticmethod\n def _to_state_vector(rot, rt, vel, avel):\n state_shape = rot.shape[:-2]\n skeleton_state_v = SkeletonState._to_state_vector(rot, rt)\n v = vel.reshape(*(state_shape + (-1,)))\n av = avel.reshape(*(state_shape + (-1,)))\n skeleton_motion_v = torch.cat([skeleton_state_v, v, av], axis=-1)\n return skeleton_motion_v\n\n @classmethod\n def from_dict(\n cls: Type[\"SkeletonMotion\"], dict_repr: OrderedDict, *args, **kwargs\n ) -> \"SkeletonMotion\":\n rot = TensorUtils.from_dict(dict_repr[\"rotation\"], *args, **kwargs)\n rt = TensorUtils.from_dict(dict_repr[\"root_translation\"], *args, **kwargs)\n vel = TensorUtils.from_dict(dict_repr[\"global_velocity\"], *args, **kwargs)\n avel = TensorUtils.from_dict(\n dict_repr[\"global_angular_velocity\"], *args, **kwargs\n )\n return cls(\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\n skeleton_tree=SkeletonTree.from_dict(\n dict_repr[\"skeleton_tree\"], *args, **kwargs\n ),\n is_local=dict_repr[\"is_local\"],\n fps=dict_repr[\"fps\"],\n )\n\n def to_dict(self) -> OrderedDict:\n return OrderedDict(\n [\n (\"rotation\", tensor_to_dict(self.rotation)),\n (\"root_translation\", tensor_to_dict(self.root_translation)),\n (\"global_velocity\", tensor_to_dict(self.global_velocity)),\n (\"global_angular_velocity\", tensor_to_dict(self.global_angular_velocity)),\n (\"skeleton_tree\", self.skeleton_tree.to_dict()),\n (\"is_local\", self.is_local),\n (\"fps\", self.fps),\n ]\n )\n\n @classmethod\n def from_fbx(\n cls: Type[\"SkeletonMotion\"],\n fbx_file_path,\n fbx_configs,\n skeleton_tree=None,\n is_local=True,\n fps=120,\n root_joint=\"\",\n root_trans_index=0,\n *args,\n **kwargs,\n ) -> \"SkeletonMotion\":\n \"\"\"\n Construct a skeleton motion from a fbx file (TODO - generalize this). If the skeleton tree\n is not given, it will use the first frame of the mocap to construct the skeleton tree.\n\n :param fbx_file_path: the path of the fbx file\n :type fbx_file_path: string\n :param fbx_configs: the configuration in terms of {\"tmp_path\": ..., \"fbx_py27_path\": ...}\n :type fbx_configs: dict\n :param skeleton_tree: the optional skeleton tree that the rotation will be applied to\n :type skeleton_tree: SkeletonTree, optional\n :param is_local: the state vector uses local or global rotation as the representation\n :type is_local: bool, optional, default=True\n :rtype: SkeletonMotion\n \"\"\"\n joint_names, joint_parents, transforms, fps = fbx_to_array(\n fbx_file_path, fbx_configs, root_joint, fps\n )\n # swap the last two axis to match the convention\n local_transform = euclidean_to_transform(\n transformation_matrix=torch.from_numpy(\n np.swapaxes(np.array(transforms), -1, -2),\n ).float()\n )\n local_rotation = transform_rotation(local_transform)\n root_translation = transform_translation(local_transform)[..., root_trans_index, :]\n joint_parents = torch.from_numpy(np.array(joint_parents)).int()\n\n if skeleton_tree is None:\n local_translation = transform_translation(local_transform).reshape(\n -1, len(joint_parents), 3\n )[0]\n skeleton_tree = SkeletonTree(joint_names, joint_parents, local_translation)\n skeleton_state = SkeletonState.from_rotation_and_root_translation(\n skeleton_tree, r=local_rotation, t=root_translation, is_local=True\n )\n if not is_local:\n skeleton_state = skeleton_state.global_repr()\n return cls.from_skeleton_state(\n skeleton_state=skeleton_state, fps=fps\n )\n\n @staticmethod\n def _compute_velocity(p, time_delta, guassian_filter=True):\n velocity = torch.from_numpy(\n filters.gaussian_filter1d(\n np.gradient(p.numpy(), axis=-3), 2, axis=-3, mode=\"nearest\"\n )\n / time_delta,\n )\n return velocity\n\n @staticmethod\n def _compute_angular_velocity(r, time_delta: float, guassian_filter=True):\n # assume the second last dimension is the time axis\n diff_quat_data = quat_identity_like(r)\n diff_quat_data[..., :-1, :, :] = quat_mul_norm(\n r[..., 1:, :, :], quat_inverse(r[..., :-1, :, :])\n )\n diff_angle, diff_axis = quat_angle_axis(diff_quat_data)\n angular_velocity = diff_axis * diff_angle.unsqueeze(-1) / time_delta\n angular_velocity = torch.from_numpy(\n filters.gaussian_filter1d(\n angular_velocity.numpy(), 2, axis=-3, mode=\"nearest\"\n ),\n )\n return angular_velocity\n\n def crop(self, start: int, end: int, fps: Optional[int] = None):\n \"\"\"\n Crop the motion along its last axis. This is equivalent to performing a slicing on the\n object with [..., start: end: skip_every] where skip_every = old_fps / fps. Note that the\n new fps provided must be a factor of the original fps. \n\n :param start: the beginning frame index\n :type start: int\n :param end: the ending frame index\n :type end: int\n :param fps: number of frames per second in the output (if not given the original fps will be used)\n :type fps: int, optional\n :rtype: SkeletonMotion\n \"\"\"\n if fps is None:\n new_fps = int(self.fps)\n old_fps = int(self.fps)\n else:\n new_fps = int(fps)\n old_fps = int(self.fps)\n assert old_fps % fps == 0, (\n \"the resampling doesn't support fps with non-integer division \"\n \"from the original fps: {} => {}\".format(old_fps, fps)\n )\n skip_every = old_fps // new_fps\n s = slice(start, end, skip_every)\n z = self[..., s]\n\n rot = z.local_rotation if z.is_local else z.global_rotation\n rt = z.root_translation\n vel = z.global_velocity\n avel = z.global_angular_velocity\n return SkeletonMotion(\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\n skeleton_tree=z.skeleton_tree,\n is_local=z.is_local,\n fps=new_fps,\n )\n\n def retarget_to(\n self,\n joint_mapping: Dict[str, str],\n source_tpose_local_rotation,\n source_tpose_root_translation: np.ndarray,\n target_skeleton_tree: \"SkeletonTree\",\n target_tpose_local_rotation,\n target_tpose_root_translation: np.ndarray,\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n z_up: bool = True,\n ) -> \"SkeletonMotion\":\n \"\"\" \n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\n new retargetted motion.\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose_local_rotation: the local rotation of the source skeleton\n :type source_tpose_local_rotation: Tensor\n \n :param source_tpose_root_translation: the root translation of the source tpose\n :type source_tpose_root_translation: np.ndarray\n \n :param target_skeleton_tree: the target skeleton tree\n :type target_skeleton_tree: SkeletonTree\n \n :param target_tpose_local_rotation: the local rotation of the target skeleton\n :type target_tpose_local_rotation: Tensor\n \n :param target_tpose_root_translation: the root translation of the target tpose\n :type target_tpose_root_translation: Tensor\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonMotion\n \"\"\"\n return SkeletonMotion.from_skeleton_state(\n super().retarget_to(\n joint_mapping,\n source_tpose_local_rotation,\n source_tpose_root_translation,\n target_skeleton_tree,\n target_tpose_local_rotation,\n target_tpose_root_translation,\n rotation_to_target_skeleton,\n scale_to_target_skeleton,\n z_up,\n ),\n self.fps,\n )\n\n def retarget_to_by_tpose(\n self,\n joint_mapping: Dict[str, str],\n source_tpose: \"SkeletonState\",\n target_tpose: \"SkeletonState\",\n rotation_to_target_skeleton,\n scale_to_target_skeleton: float,\n z_up: bool = True,\n ) -> \"SkeletonMotion\":\n \"\"\" \n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\n new retargetted motion.\n\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\n the target skeleton\n :type joint_mapping: Dict[str, str]\n \n :param source_tpose: t-pose of the source skeleton\n :type source_tpose: SkeletonState\n \n :param target_tpose: t-pose of the target skeleton\n :type target_tpose: SkeletonState\n \n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\n skeleton\n :type rotation_to_target_skeleton: Tensor\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\n factor needs to be 0.01.\n :type scale_to_target_skeleton: float\n :rtype: SkeletonMotion\n \"\"\"\n return self.retarget_to(\n joint_mapping,\n source_tpose.local_rotation,\n source_tpose.root_translation,\n target_tpose.skeleton_tree,\n target_tpose.local_rotation,\n target_tpose.root_translation,\n rotation_to_target_skeleton,\n scale_to_target_skeleton,\n z_up,\n )"},{"identifier":"plot_skeleton_state","path":"poselib/poselib/visualization/common.py","snippet":"def plot_skeleton_state(skeleton_state, task_name=\"\"):\n \"\"\"\n Visualize a skeleton state\n\n :param skeleton_state:\n :param task_name:\n :type skeleton_state: SkeletonState\n :type task_name: string, optional\n \"\"\"\n logger.info(\"plotting {}\".format(task_name))\n task = Draw3DSkeletonState(task_name=task_name, skeleton_state=skeleton_state)\n plotter = Matplotlib3DPlotter(task)\n plotter.show()"},{"identifier":"plot_skeleton_motion_interactive","path":"poselib/poselib/visualization/common.py","snippet":"def plot_skeleton_motion_interactive(skeleton_motion, task_name=\"\"):\n \"\"\"\n Visualize a skeleton motion along its first dimension interactively.\n\n :param skeleton_motion:\n :param task_name:\n :type skeleton_motion: SkeletonMotion\n :type task_name: string, optional\n \"\"\"\n for _ in plot_skeleton_motion_interactive_base(skeleton_motion, task_name):\n pass"},{"identifier":"Matplotlib3DPlotter","path":"poselib/poselib/visualization/plt_plotter.py","snippet":"class Matplotlib3DPlotter(BasePlotter):\n _fig: plt.figure # plt figure\n _ax: p3.Axes3D # plt 3d axis\n # stores artist objects for each task (task name as the key)\n _artist_cache: Dict[str, Any]\n # callables for each task primitives\n _create_impl_callables: Dict[str, Callable]\n _update_impl_callables: Dict[str, Callable]\n\n def __init__(self, task: \"BasePlotterTask\") -> None:\n self._fig = plt.figure()\n self._ax = p3.Axes3D(self._fig)\n self._artist_cache = {}\n\n self._create_impl_callables = {\n \"Draw3DLines\": self._lines_create_impl,\n \"Draw3DDots\": self._dots_create_impl,\n \"Draw3DTrail\": self._trail_create_impl,\n }\n self._update_impl_callables = {\n \"Draw3DLines\": self._lines_update_impl,\n \"Draw3DDots\": self._dots_update_impl,\n \"Draw3DTrail\": self._trail_update_impl,\n }\n self._init_lim()\n super().__init__(task)\n\n @property\n def ax(self):\n return self._ax\n\n @property\n def fig(self):\n return self._fig\n\n def show(self):\n plt.show()\n\n def _min(self, x, y):\n if x is None:\n return y\n if y is None:\n return x\n return min(x, y)\n\n def _max(self, x, y):\n if x is None:\n return y\n if y is None:\n return x\n return max(x, y)\n\n def _init_lim(self):\n self._curr_x_min = None\n self._curr_y_min = None\n self._curr_z_min = None\n self._curr_x_max = None\n self._curr_y_max = None\n self._curr_z_max = None\n\n def _update_lim(self, xs, ys, zs):\n self._curr_x_min = self._min(np.min(xs), self._curr_x_min)\n self._curr_y_min = self._min(np.min(ys), self._curr_y_min)\n self._curr_z_min = self._min(np.min(zs), self._curr_z_min)\n self._curr_x_max = self._max(np.max(xs), self._curr_x_max)\n self._curr_y_max = self._max(np.max(ys), self._curr_y_max)\n self._curr_z_max = self._max(np.max(zs), self._curr_z_max)\n\n def _set_lim(self):\n if not (\n self._curr_x_min is None\n or self._curr_x_max is None\n or self._curr_y_min is None\n or self._curr_y_max is None\n or self._curr_z_min is None\n or self._curr_z_max is None\n ):\n self._ax.set_xlim3d(self._curr_x_min, self._curr_x_max)\n self._ax.set_ylim3d(self._curr_y_min, self._curr_y_max)\n self._ax.set_zlim3d(self._curr_z_min, self._curr_z_max)\n self._init_lim()\n\n @staticmethod\n def _lines_extract_xyz_impl(index, lines_task):\n return lines_task[index, :, 0], lines_task[index, :, 1], lines_task[index, :, 2]\n\n @staticmethod\n def _trail_extract_xyz_impl(index, trail_task):\n return (\n trail_task[index : index + 2, 0],\n trail_task[index : index + 2, 1],\n trail_task[index : index + 2, 2],\n )\n\n def _lines_create_impl(self, lines_task):\n color = lines_task.color\n self._artist_cache[lines_task.task_name] = [\n self._ax.plot(\n *Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task),\n color=color,\n linewidth=lines_task.line_width,\n alpha=lines_task.alpha\n )[0]\n for i in range(len(lines_task))\n ]\n\n def _lines_update_impl(self, lines_task):\n lines_artists = self._artist_cache[lines_task.task_name]\n for i in range(len(lines_task)):\n artist = lines_artists[i]\n xs, ys, zs = Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task)\n artist.set_data(xs, ys)\n artist.set_3d_properties(zs)\n if lines_task.influence_lim:\n self._update_lim(xs, ys, zs)\n\n def _dots_create_impl(self, dots_task):\n color = dots_task.color\n self._artist_cache[dots_task.task_name] = self._ax.plot(\n dots_task[:, 0],\n dots_task[:, 1],\n dots_task[:, 2],\n c=color,\n linestyle=\"\",\n marker=\".\",\n markersize=dots_task.marker_size,\n alpha=dots_task.alpha,\n )[0]\n\n def _dots_update_impl(self, dots_task):\n dots_artist = self._artist_cache[dots_task.task_name]\n dots_artist.set_data(dots_task[:, 0], dots_task[:, 1])\n dots_artist.set_3d_properties(dots_task[:, 2])\n if dots_task.influence_lim:\n self._update_lim(dots_task[:, 0], dots_task[:, 1], dots_task[:, 2])\n\n def _trail_create_impl(self, trail_task):\n color = trail_task.color\n trail_length = len(trail_task) - 1\n self._artist_cache[trail_task.task_name] = [\n self._ax.plot(\n *Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task),\n color=trail_task.color,\n linewidth=trail_task.line_width,\n alpha=trail_task.alpha * (1.0 - i / (trail_length - 1))\n )[0]\n for i in range(trail_length)\n ]\n\n def _trail_update_impl(self, trail_task):\n trails_artists = self._artist_cache[trail_task.task_name]\n for i in range(len(trail_task) - 1):\n artist = trails_artists[i]\n xs, ys, zs = Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task)\n artist.set_data(xs, ys)\n artist.set_3d_properties(zs)\n if trail_task.influence_lim:\n self._update_lim(xs, ys, zs)\n\n def _create_impl(self, task_list):\n for task in task_list:\n self._create_impl_callables[task.task_type](task)\n self._draw()\n\n def _update_impl(self, task_list):\n for task in task_list:\n self._update_impl_callables[task.task_type](task)\n self._draw()\n\n def _set_aspect_equal_3d(self):\n xlim = self._ax.get_xlim3d()\n ylim = self._ax.get_ylim3d()\n zlim = self._ax.get_zlim3d()\n\n xmean = np.mean(xlim)\n ymean = np.mean(ylim)\n zmean = np.mean(zlim)\n\n plot_radius = max(\n [\n abs(lim - mean_)\n for lims, mean_ in ((xlim, xmean), (ylim, ymean), (zlim, zmean))\n for lim in lims\n ]\n )\n\n self._ax.set_xlim3d([xmean - plot_radius, xmean + plot_radius])\n self._ax.set_ylim3d([ymean - plot_radius, ymean + plot_radius])\n self._ax.set_zlim3d([zmean - plot_radius, zmean + plot_radius])\n\n def _draw(self):\n self._set_lim()\n self._set_aspect_equal_3d()\n self._fig.canvas.draw()\n self._fig.canvas.flush_events()\n plt.pause(0.00001)"},{"identifier":"Draw3DSkeletonMotion","path":"poselib/poselib/visualization/skeleton_plotter_tasks.py","snippet":"class Draw3DSkeletonMotion(BasePlotterTask):\n def __init__(\n self,\n task_name: str,\n skeleton_motion,\n frame_index=None,\n joints_color=\"red\",\n lines_color=\"blue\",\n velocity_color=\"green\",\n angular_velocity_color=\"purple\",\n trail_color=\"black\",\n trail_length=10,\n alpha=1.0,\n ) -> None:\n super().__init__(task_name=task_name, task_type=\"3DSkeletonMotion\")\n self._trail_length = trail_length\n self._skeleton_motion = skeleton_motion\n # if frame_index is None:\n curr_skeleton_motion = self._skeleton_motion.clone()\n if frame_index is not None:\n curr_skeleton_motion.tensor = self._skeleton_motion.tensor[frame_index, :]\n # else:\n # curr_skeleton_motion = self._skeleton_motion[frame_index, :]\n self._skeleton_state_task = Draw3DSkeletonState(\n self.get_scoped_name(\"skeleton_state\"),\n curr_skeleton_motion,\n joints_color=joints_color,\n lines_color=lines_color,\n alpha=alpha,\n )\n vel_lines, avel_lines = Draw3DSkeletonMotion._get_vel_and_avel(\n curr_skeleton_motion\n )\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\n np.newaxis, ...\n ].repeat(trail_length, axis=0)\n self._vel_task = Draw3DLines(\n self.get_scoped_name(\"velocity\"),\n vel_lines,\n velocity_color,\n influence_lim=False,\n alpha=alpha,\n )\n self._avel_task = Draw3DLines(\n self.get_scoped_name(\"angular_velocity\"),\n avel_lines,\n angular_velocity_color,\n influence_lim=False,\n alpha=alpha,\n )\n self._com_trail_task = Draw3DTrail(\n self.get_scoped_name(\"com_trail\"),\n self._com_pos,\n trail_color,\n marker_size=2,\n influence_lim=True,\n alpha=alpha,\n )\n\n @property\n def name(self):\n return \"3DSkeletonMotion\"\n\n def update(self, frame_index=None, reset_trail=False, skeleton_motion=None) -> None:\n if skeleton_motion is not None:\n self._skeleton_motion = skeleton_motion\n\n curr_skeleton_motion = self._skeleton_motion.clone()\n if frame_index is not None:\n curr_skeleton_motion.tensor = curr_skeleton_motion.tensor[frame_index, :]\n if reset_trail:\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\n np.newaxis, ...\n ].repeat(self._trail_length, axis=0)\n else:\n self._com_pos = np.concatenate(\n (\n curr_skeleton_motion.root_translation.numpy()[np.newaxis, ...],\n self._com_pos[:-1],\n ),\n axis=0,\n )\n self._skeleton_state_task.update(curr_skeleton_motion)\n self._com_trail_task.update(self._com_pos)\n self._update(*Draw3DSkeletonMotion._get_vel_and_avel(curr_skeleton_motion))\n\n @staticmethod\n def _get_vel_and_avel(skeleton_motion):\n \"\"\"Get all the velocity and angular velocity lines\n \"\"\"\n pos = skeleton_motion.global_translation.numpy()\n vel = skeleton_motion.global_velocity.numpy()\n avel = skeleton_motion.global_angular_velocity.numpy()\n\n vel_lines = np.stack((pos, pos + vel * 0.02), axis=1)\n avel_lines = np.stack((pos, pos + avel * 0.01), axis=1)\n return vel_lines, avel_lines\n\n def _update(self, vel_lines, avel_lines) -> None:\n self._vel_task.update(vel_lines)\n self._avel_task.update(avel_lines)\n\n def __iter__(self):\n yield from self._skeleton_state_task\n yield from self._vel_task\n yield from self._avel_task\n yield from self._com_trail_task"},{"identifier":"Draw3DSkeletonState","path":"poselib/poselib/visualization/skeleton_plotter_tasks.py","snippet":"class Draw3DSkeletonState(BasePlotterTask):\n _lines_task: Draw3DLines # sub-task for drawing lines\n _dots_task: Draw3DDots # sub-task for drawing dots\n\n def __init__(\n self,\n task_name: str,\n skeleton_state,\n joints_color: str = \"red\",\n lines_color: str = \"blue\",\n alpha=1.0,\n ) -> None:\n super().__init__(task_name=task_name, task_type=\"3DSkeletonState\")\n lines, dots = Draw3DSkeletonState._get_lines_and_dots(skeleton_state)\n self._lines_task = Draw3DLines(\n self.get_scoped_name(\"bodies\"), lines, joints_color, alpha=alpha\n )\n self._dots_task = Draw3DDots(\n self.get_scoped_name(\"joints\"), dots, lines_color, alpha=alpha\n )\n\n @property\n def name(self):\n return \"3DSkeleton\"\n\n def update(self, skeleton_state) -> None:\n self._update(*Draw3DSkeletonState._get_lines_and_dots(skeleton_state))\n\n @staticmethod\n def _get_lines_and_dots(skeleton_state):\n \"\"\"Get all the lines and dots needed to draw the skeleton state\n \"\"\"\n assert (\n len(skeleton_state.tensor.shape) == 1\n ), \"the state has to be zero dimensional\"\n dots = skeleton_state.global_translation.numpy()\n skeleton_tree = skeleton_state.skeleton_tree\n parent_indices = skeleton_tree.parent_indices.numpy()\n lines = []\n for node_index in range(len(skeleton_tree)):\n parent_index = parent_indices[node_index]\n if parent_index != -1:\n lines.append([dots[node_index], dots[parent_index]])\n lines = np.array(lines)\n return lines, dots\n\n def _update(self, lines, dots) -> None:\n self._lines_task.update(lines)\n self._dots_task.update(dots)\n\n def __iter__(self):\n yield from self._lines_task\n yield from self._dots_task"}],"string":"[\n {\n \"identifier\": \"SkeletonTree\",\n \"path\": \"poselib/poselib/skeleton/skeleton3d.py\",\n \"snippet\": \"class SkeletonTree(Serializable):\\n \\\"\\\"\\\"\\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\\n over a list of nodes with their names indicated by strings. Each edge in the tree has a local\\n translation associated with it which describes the distance between the two nodes that it\\n connects. \\n\\n Basic Usage:\\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\\n >>> t\\n SkeletonTree(\\n node_names=['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot'],\\n parent_indices=tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11]),\\n local_translation=tensor([[ 0.0000, 0.0000, 0.7500],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000]])\\n )\\n >>> t.node_names\\n ['torso', 'front_left_leg', 'aux_1', 'front_left_foot', 'front_right_leg', 'aux_2', 'front_right_foot', 'left_back_leg', 'aux_3', 'left_back_foot', 'right_back_leg', 'aux_4', 'right_back_foot']\\n >>> t.parent_indices\\n tensor([-1, 0, 1, 2, 0, 4, 5, 0, 7, 8, 0, 10, 11])\\n >>> t.local_translation\\n tensor([[ 0.0000, 0.0000, 0.7500],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [-0.2000, 0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [-0.2000, -0.2000, 0.0000],\\n [ 0.0000, 0.0000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000],\\n [ 0.2000, -0.2000, 0.0000]])\\n >>> t.parent_of('front_left_leg')\\n 'torso'\\n >>> t.index('front_right_foot')\\n 6\\n >>> t[2]\\n 'aux_1'\\n \\\"\\\"\\\"\\n\\n __example_mjcf_path__ = os.path.join(\\n os.path.dirname(os.path.realpath(__file__)), \\\"tests/ant.xml\\\"\\n )\\n\\n def __init__(self, node_names, parent_indices, local_translation, local_xml_rotation):\\n \\\"\\\"\\\"\\n :param node_names: a list of names for each tree node\\n :type node_names: List[str]\\n :param parent_indices: an int32-typed tensor that represents the edge to its parent.\\\\\\n -1 represents the root node\\n :type parent_indices: Tensor\\n :param local_translation: a 3d vector that gives local translation information\\n :type local_translation: Tensor\\n \\\"\\\"\\\"\\n ln, lp, ll = len(node_names), len(parent_indices), len(local_translation)\\n assert len(set((ln, lp, ll))) == 1\\n self._node_names = node_names\\n self._parent_indices = parent_indices.long()\\n self._local_translation = local_translation\\n self._local_xml_rotation = local_xml_rotation\\n self._node_indices = {self.node_names[i]: i for i in range(len(self))}\\n\\n def __len__(self):\\n \\\"\\\"\\\" number of nodes in the skeleton tree \\\"\\\"\\\"\\n return len(self.node_names)\\n\\n def __iter__(self):\\n \\\"\\\"\\\" iterator that iterate through the name of each node \\\"\\\"\\\"\\n yield from self.node_names\\n\\n def __getitem__(self, item):\\n \\\"\\\"\\\" get the name of the node given the index \\\"\\\"\\\"\\n return self.node_names[item]\\n\\n def __repr__(self):\\n return (\\n \\\"SkeletonTree(\\\\n node_names={},\\\\n parent_indices={},\\\"\\n \\\"\\\\n local_translation={}\\\\n)\\\".format(\\n self._indent(repr(self.node_names)),\\n self._indent(repr(self.parent_indices)),\\n self._indent(repr(self.local_translation)),\\n )\\n )\\n\\n def _indent(self, s):\\n return \\\"\\\\n \\\".join(s.split(\\\"\\\\n\\\"))\\n\\n @property\\n def node_names(self):\\n return self._node_names\\n\\n @property\\n def parent_indices(self):\\n return self._parent_indices\\n\\n @property\\n def local_translation(self):\\n return self._local_translation\\n\\n @property\\n def num_joints(self):\\n \\\"\\\"\\\" number of nodes in the skeleton tree \\\"\\\"\\\"\\n return len(self)\\n\\n @classmethod\\n def from_dict(cls, dict_repr, *args, **kwargs):\\n return cls(\\n list(map(str, dict_repr[\\\"node_names\\\"])),\\n TensorUtils.from_dict(dict_repr[\\\"parent_indices\\\"], *args,\\n **kwargs),\\n TensorUtils.from_dict(dict_repr[\\\"local_translation\\\"], *args,\\n **kwargs),\\n TensorUtils.from_dict(dict_repr[\\\"local_xml_rotation\\\"], *args,\\n **kwargs),\\n )\\n\\n def to_dict(self):\\n return OrderedDict(\\n [\\n (\\\"node_names\\\", self.node_names),\\n (\\\"parent_indices\\\", tensor_to_dict(self.parent_indices)),\\n (\\\"local_translation\\\", tensor_to_dict(self.local_translation)),\\n (\\\"local_xml_rotation\\\", tensor_to_dict(self._local_xml_rotation)),\\n ]\\n )\\n\\n @classmethod\\n def from_mjcf(cls, path: str) -> \\\"SkeletonTree\\\":\\n \\\"\\\"\\\"\\n Parses a mujoco xml scene description file and returns a Skeleton Tree.\\n We use the model attribute at the root as the name of the tree.\\n \\n :param path:\\n :type path: string\\n :return: The skeleton tree constructed from the mjcf file\\n :rtype: SkeletonTree\\n \\\"\\\"\\\"\\n tree = ET.parse(path)\\n xml_doc_root = tree.getroot()\\n xml_world_body = xml_doc_root.find(\\\"worldbody\\\")\\n if xml_world_body is None:\\n raise ValueError(\\\"MJCF parsed incorrectly please verify it.\\\")\\n # assume this is the root\\n xml_body_root = xml_world_body.find(\\\"body\\\")\\n if xml_body_root is None:\\n raise ValueError(\\\"MJCF parsed incorrectly please verify it.\\\")\\n\\n node_names = []\\n parent_indices = []\\n local_translation = []\\n local_xml_rotation = []\\n\\n # recursively adding all nodes into the skel_tree\\n def _add_xml_node(xml_node, parent_index, node_index):\\n node_name = xml_node.attrib.get(\\\"name\\\")\\n # parse the local translation into float list\\n pos = np.fromstring(xml_node.attrib.get(\\\"pos\\\"), dtype=float, sep=\\\" \\\")\\n quat = np.fromstring(xml_node.attrib.get(\\\"quat\\\", \\\"1 0 0 0\\\"), dtype=float, sep=\\\" \\\")[[1, 2, 3, 0]]\\n node_names.append(node_name)\\n parent_indices.append(parent_index)\\n local_translation.append(pos)\\n local_xml_rotation.append(quat)\\n curr_index = node_index\\n node_index += 1\\n for next_node in xml_node.findall(\\\"body\\\"):\\n node_index = _add_xml_node(next_node, curr_index, node_index)\\n return node_index\\n\\n _add_xml_node(xml_body_root, -1, 0)\\n\\n return cls(\\n node_names,\\n torch.from_numpy(np.array(parent_indices, dtype=np.int32)),\\n torch.from_numpy(np.array(local_translation, dtype=np.float32)),\\n torch.from_numpy(np.array(local_xml_rotation, dtype=np.float32)),\\n )\\n\\n def parent_of(self, node_name):\\n \\\"\\\"\\\" get the name of the parent of the given node\\n\\n :param node_name: the name of the node\\n :type node_name: string\\n :rtype: string\\n \\\"\\\"\\\"\\n return self[int(self.parent_indices[self.index(node_name)].item())]\\n\\n def index(self, node_name):\\n \\\"\\\"\\\" get the index of the node\\n \\n :param node_name: the name of the node\\n :type node_name: string\\n :rtype: int\\n \\\"\\\"\\\"\\n return self._node_indices[node_name]\\n\\n def drop_nodes_by_names(\\n self, node_names: List[str], pairwise_translation=None\\n ) -> \\\"SkeletonTree\\\":\\n new_length = len(self) - len(node_names)\\n new_node_names = []\\n new_local_translation = torch.zeros(\\n new_length, 3, dtype=self.local_translation.dtype\\n )\\n new_parent_indices = torch.zeros(new_length, dtype=self.parent_indices.dtype)\\n parent_indices = self.parent_indices.numpy()\\n new_node_indices: dict = {}\\n new_node_index = 0\\n for node_index in range(len(self)):\\n if self[node_index] in node_names:\\n continue\\n tb_node_index = parent_indices[node_index]\\n if tb_node_index != -1:\\n local_translation = self.local_translation[node_index, :]\\n while tb_node_index != -1 and self[tb_node_index] in node_names:\\n local_translation += self.local_translation[tb_node_index, :]\\n tb_node_index = parent_indices[tb_node_index]\\n assert tb_node_index != -1, \\\"the root node cannot be dropped\\\"\\n\\n if pairwise_translation is not None:\\n local_translation = pairwise_translation[\\n tb_node_index, node_index, :\\n ]\\n else:\\n local_translation = self.local_translation[node_index, :]\\n\\n new_node_names.append(self[node_index])\\n new_local_translation[new_node_index, :] = local_translation\\n if tb_node_index == -1:\\n new_parent_indices[new_node_index] = -1\\n else:\\n new_parent_indices[new_node_index] = new_node_indices[\\n self[tb_node_index]\\n ]\\n new_node_indices[self[node_index]] = new_node_index\\n new_node_index += 1\\n\\n return SkeletonTree(new_node_names, new_parent_indices, new_local_translation)\\n\\n def keep_nodes_by_names(\\n self, node_names: List[str], pairwise_translation=None\\n ) -> \\\"SkeletonTree\\\":\\n nodes_to_drop = list(filter(lambda x: x not in node_names, self))\\n return self.drop_nodes_by_names(nodes_to_drop, pairwise_translation)\"\n },\n {\n \"identifier\": \"SkeletonState\",\n \"path\": \"poselib/poselib/skeleton/skeleton3d.py\",\n \"snippet\": \"class SkeletonState(Serializable):\\n \\\"\\\"\\\"\\n A skeleton state contains all the information needed to describe a static state of a skeleton.\\n It requires a skeleton tree, local/global rotation at each joint and the root translation.\\n\\n Example:\\n >>> t = SkeletonTree.from_mjcf(SkeletonTree.__example_mjcf_path__)\\n >>> zero_pose = SkeletonState.zero_pose(t)\\n >>> plot_skeleton_state(zero_pose) # can be imported from `.visualization.common`\\n [plot of the ant at zero pose\\n >>> local_rotation = zero_pose.local_rotation.clone()\\n >>> local_rotation[2] = torch.tensor([0, 0, 1, 0])\\n >>> new_pose = SkeletonState.from_rotation_and_root_translation(\\n ... skeleton_tree=t,\\n ... r=local_rotation,\\n ... t=zero_pose.root_translation,\\n ... is_local=True\\n ... )\\n >>> new_pose.local_rotation\\n tensor([[0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 1., 0., 0.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.]])\\n >>> plot_skeleton_state(new_pose) # you should be able to see one of ant's leg is bent\\n [plot of the ant with the new pose\\n >>> new_pose.global_rotation # the local rotation is propagated to the global rotation at joint #3\\n tensor([[0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 1., 0., 0.],\\n [0., 1., 0., 0.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.],\\n [0., 0., 0., 1.]])\\n\\n Global/Local Representation (cont. from the previous example)\\n >>> new_pose.is_local\\n True\\n >>> new_pose.tensor # this will return the local rotation followed by the root translation\\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 0., 0., 1., 0., 0.,\\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\\n 0.])\\n >>> new_pose.tensor.shape # 4 * 13 (joint rotation) + 3 (root translatio\\n torch.Size([55])\\n >>> new_pose.global_repr().is_local\\n False\\n >>> new_pose.global_repr().tensor # this will return the global rotation followed by the root translation instead\\n tensor([0., 0., 0., 1., 0., 0., 0., 1., 0., 1., 0., 0., 0., 1., 0., 0., 0., 0.,\\n 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1.,\\n 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0., 0., 1., 0., 0.,\\n 0.])\\n >>> new_pose.global_repr().tensor.shape # 4 * 13 (joint rotation) + 3 (root translation\\n torch.Size([55])\\n \\\"\\\"\\\"\\n\\n def __init__(self, tensor_backend, skeleton_tree, is_local):\\n self._skeleton_tree = skeleton_tree\\n self._is_local = is_local\\n self.tensor = tensor_backend.clone()\\n\\n def __len__(self):\\n return self.tensor.shape[0]\\n\\n @property\\n def rotation(self):\\n if not hasattr(self, \\\"_rotation\\\"):\\n self._rotation = self.tensor[..., : self.num_joints * 4].reshape(\\n *(self.tensor.shape[:-1] + (self.num_joints, 4))\\n )\\n return self._rotation\\n\\n @property\\n def _local_rotation(self):\\n if self._is_local:\\n return self.rotation\\n else:\\n return None\\n\\n @property\\n def _global_rotation(self):\\n if not self._is_local:\\n return self.rotation\\n else:\\n return None\\n\\n @property\\n def is_local(self):\\n \\\"\\\"\\\" is the rotation represented in local frame? \\n \\n :rtype: bool\\n \\\"\\\"\\\"\\n return self._is_local\\n\\n @property\\n def invariant_property(self):\\n return {\\\"skeleton_tree\\\": self.skeleton_tree, \\\"is_local\\\": self.is_local}\\n\\n @property\\n def num_joints(self):\\n \\\"\\\"\\\" number of joints in the skeleton tree \\n \\n :rtype: int\\n \\\"\\\"\\\"\\n return self.skeleton_tree.num_joints\\n\\n @property\\n def skeleton_tree(self):\\n \\\"\\\"\\\" skeleton tree \\n \\n :rtype: SkeletonTree\\n \\\"\\\"\\\"\\n return self._skeleton_tree\\n\\n @property\\n def root_translation(self):\\n \\\"\\\"\\\" root translation \\n \\n :rtype: Tensor\\n \\\"\\\"\\\"\\n if not hasattr(self, \\\"_root_translation\\\"):\\n self._root_translation = self.tensor[\\n ..., self.num_joints * 4 : self.num_joints * 4 + 3\\n ]\\n return self._root_translation\\n\\n @property\\n def global_transformation(self):\\n \\\"\\\"\\\" global transformation of each joint (transform from joint frame to global frame) \\\"\\\"\\\"\\n # Forward kinemaitcs.\\n \\n if not hasattr(self, \\\"_global_transformation\\\"):\\n local_transformation = self.local_transformation.clone()\\n global_transformation = []\\n parent_indices = self.skeleton_tree.parent_indices.numpy()\\n # global_transformation = local_transformation.identity_like()\\n \\n local_transformation[..., :4] = quat_mul(\\n self.skeleton_tree._local_xml_rotation,\\n local_transformation[..., :4])\\n\\n for node_index in range(len(self.skeleton_tree)):\\n parent_index = parent_indices[node_index]\\n if parent_index == -1:\\n global_transformation.append(\\n local_transformation[..., node_index, :]\\n )\\n else:\\n # Here to factor in the local xml rotation\\n\\n global_transformation.append(\\n transform_mul(\\n global_transformation[parent_index],\\n local_transformation[..., node_index, :],\\n )\\n )\\n self._global_transformation = torch.stack(global_transformation, axis=-2)\\n return self._global_transformation\\n\\n @property\\n def global_rotation(self):\\n \\\"\\\"\\\" global rotation of each joint (rotation matrix to rotate from joint's F.O.R to global\\n F.O.R) \\\"\\\"\\\"\\n if self._global_rotation is None:\\n if not hasattr(self, \\\"_comp_global_rotation\\\"):\\n self._comp_global_rotation = transform_rotation(\\n self.global_transformation\\n )\\n return self._comp_global_rotation\\n else:\\n return self._global_rotation\\n\\n @property\\n def global_translation(self):\\n \\\"\\\"\\\" global translation of each joint \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_translation\\\"):\\n self._global_translation = transform_translation(self.global_transformation)\\n return self._global_translation\\n\\n @property\\n def global_translation_xy(self):\\n \\\"\\\"\\\" global translation in xy \\\"\\\"\\\"\\n trans_xy_data = self.global_translation.zeros_like()\\n trans_xy_data[..., 0:2] = self.global_translation[..., 0:2]\\n return trans_xy_data\\n\\n @property\\n def global_translation_xz(self):\\n \\\"\\\"\\\" global translation in xz \\\"\\\"\\\"\\n trans_xz_data = self.global_translation.zeros_like()\\n trans_xz_data[..., 0:1] = self.global_translation[..., 0:1]\\n trans_xz_data[..., 2:3] = self.global_translation[..., 2:3]\\n return trans_xz_data\\n\\n @property\\n def local_rotation(self):\\n \\\"\\\"\\\" the rotation from child frame to parent frame given in the order of child nodes appeared\\n in `.skeleton_tree.node_names` \\\"\\\"\\\"\\n if self._local_rotation is None:\\n if not hasattr(self, \\\"_comp_local_rotation\\\"):\\n local_rotation = quat_identity_like(self.global_rotation)\\n for node_index in range(len(self.skeleton_tree)):\\n parent_index = self.skeleton_tree.parent_indices[node_index]\\n if parent_index == -1:\\n local_rotation[..., node_index, :] = self.global_rotation[\\n ..., node_index, :\\n ]\\n else:\\n local_rotation[..., node_index, :] = quat_mul_norm(\\n quat_inverse(self.global_rotation[..., parent_index, :]),\\n self.global_rotation[..., node_index, :],\\n )\\n self._comp_local_rotation = local_rotation\\n return self._comp_local_rotation\\n else:\\n return self._local_rotation\\n\\n @property\\n def local_transformation(self):\\n \\\"\\\"\\\" local translation + local rotation. It describes the transformation from child frame to \\n parent frame given in the order of child nodes appeared in `.skeleton_tree.node_names` \\\"\\\"\\\"\\n if not hasattr(self, \\\"_local_transformation\\\"):\\n self._local_transformation = transform_from_rotation_translation(\\n r=self.local_rotation, t=self.local_translation\\n )\\n return self._local_transformation\\n\\n @property\\n def local_translation(self):\\n \\\"\\\"\\\" local translation of the skeleton state. It is identical to the local translation in\\n `.skeleton_tree.local_translation` except the root translation. The root translation is\\n identical to `.root_translation` \\\"\\\"\\\"\\n if not hasattr(self, \\\"_local_translation\\\"):\\n broadcast_shape = (\\n tuple(self.tensor.shape[:-1])\\n + (len(self.skeleton_tree),)\\n + tuple(self.skeleton_tree.local_translation.shape[-1:])\\n )\\n local_translation = self.skeleton_tree.local_translation.broadcast_to(\\n *broadcast_shape\\n ).clone()\\n local_translation[..., 0, :] = self.root_translation\\n self._local_translation = local_translation\\n return self._local_translation\\n\\n # Root Properties\\n @property\\n def root_translation_xy(self):\\n \\\"\\\"\\\" root translation on xy \\\"\\\"\\\"\\n if not hasattr(self, \\\"_root_translation_xy\\\"):\\n self._root_translation_xy = self.global_translation_xy[..., 0, :]\\n return self._root_translation_xy\\n\\n @property\\n def global_root_rotation(self):\\n \\\"\\\"\\\" root rotation \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_root_rotation\\\"):\\n self._global_root_rotation = self.global_rotation[..., 0, :]\\n return self._global_root_rotation\\n\\n @property\\n def global_root_yaw_rotation(self):\\n \\\"\\\"\\\" root yaw rotation \\\"\\\"\\\"\\n if not hasattr(self, \\\"_global_root_yaw_rotation\\\"):\\n self._global_root_yaw_rotation = self.global_root_rotation.yaw_rotation()\\n return self._global_root_yaw_rotation\\n\\n # Properties relative to root\\n @property\\n def local_translation_to_root(self):\\n \\\"\\\"\\\" The 3D translation from joint frame to the root frame. \\\"\\\"\\\"\\n if not hasattr(self, \\\"_local_translation_to_root\\\"):\\n self._local_translation_to_root = (\\n self.global_translation - self.root_translation.unsqueeze(-1)\\n )\\n return self._local_translation_to_root\\n\\n @property\\n def local_rotation_to_root(self):\\n \\\"\\\"\\\" The 3D rotation from joint frame to the root frame. It is equivalent to \\n The root_R_world * world_R_node \\\"\\\"\\\"\\n return (\\n quat_inverse(self.global_root_rotation).unsqueeze(-1) * self.global_rotation\\n )\\n\\n def compute_forward_vector(\\n self,\\n left_shoulder_index,\\n right_shoulder_index,\\n left_hip_index,\\n right_hip_index,\\n gaussian_filter_width=20,\\n ):\\n \\\"\\\"\\\" Computes forward vector based on cross product of the up vector with \\n average of the right->left shoulder and hip vectors \\\"\\\"\\\"\\n global_positions = self.global_translation\\n # Perpendicular to the forward direction.\\n # Uses the shoulders and hips to find this.\\n side_direction = (\\n global_positions[:, left_shoulder_index].numpy()\\n - global_positions[:, right_shoulder_index].numpy()\\n + global_positions[:, left_hip_index].numpy()\\n - global_positions[:, right_hip_index].numpy()\\n )\\n side_direction = (\\n side_direction\\n / np.sqrt((side_direction ** 2).sum(axis=-1))[..., np.newaxis]\\n )\\n\\n # Forward direction obtained by crossing with the up direction.\\n forward_direction = np.cross(side_direction, np.array([[0, 1, 0]]))\\n\\n # Smooth the forward direction with a Gaussian.\\n # Axis 0 is the time/frame axis.\\n forward_direction = filters.gaussian_filter1d(\\n forward_direction, gaussian_filter_width, axis=0, mode=\\\"nearest\\\"\\n )\\n forward_direction = (\\n forward_direction\\n / np.sqrt((forward_direction ** 2).sum(axis=-1))[..., np.newaxis]\\n )\\n\\n return torch.from_numpy(forward_direction)\\n\\n @staticmethod\\n def _to_state_vector(rot, rt):\\n # Tensorbackend: local rotation and translation, rotation is is in quat 33 * 4 + 3\\n state_shape = rot.shape[:-2]\\n vr = rot.reshape(*(state_shape + (-1,)))\\n vt = rt.broadcast_to(*state_shape + rt.shape[-1:]).reshape(\\n *(state_shape + (-1,))\\n )\\n v = torch.cat([vr, vt], axis=-1)\\n return v\\n\\n @classmethod\\n def from_dict(\\n cls: Type[\\\"SkeletonState\\\"], dict_repr: OrderedDict, *args, **kwargs\\n ) -> \\\"SkeletonState\\\":\\n rot = TensorUtils.from_dict(dict_repr[\\\"rotation\\\"], *args, **kwargs)\\n rt = TensorUtils.from_dict(dict_repr[\\\"root_translation\\\"], *args, **kwargs)\\n return cls(\\n SkeletonState._to_state_vector(rot, rt),\\n SkeletonTree.from_dict(dict_repr[\\\"skeleton_tree\\\"], *args, **kwargs),\\n dict_repr[\\\"is_local\\\"],\\n )\\n\\n def to_dict(self) -> OrderedDict:\\n return OrderedDict(\\n [\\n (\\\"rotation\\\", tensor_to_dict(self.rotation)),\\n (\\\"root_translation\\\", tensor_to_dict(self.root_translation)),\\n (\\\"skeleton_tree\\\", self.skeleton_tree.to_dict()),\\n (\\\"is_local\\\", self.is_local),\\n ]\\n )\\n\\n @classmethod\\n def from_rotation_and_root_translation(cls, skeleton_tree, r, t, is_local=True):\\n \\\"\\\"\\\"\\n Construct a skeleton state from rotation and root translation\\n\\n :param skeleton_tree: the skeleton tree\\n :type skeleton_tree: SkeletonTree\\n :param r: rotation (either global or local)\\n :type r: Tensor\\n :param t: root translation\\n :type t: Tensor\\n :param is_local: to indicate that whether the rotation is local or global\\n :type is_local: bool, optional, default=True\\n \\\"\\\"\\\"\\n assert (\\n r.dim() > 0\\n ), \\\"the rotation needs to have at least 1 dimension (dim = {})\\\".format(r.dim)\\n return cls(\\n SkeletonState._to_state_vector(r, t),\\n skeleton_tree=skeleton_tree,\\n is_local=is_local,\\n )\\n\\n @classmethod\\n def zero_pose(cls, skeleton_tree):\\n \\\"\\\"\\\"\\n Construct a zero-pose skeleton state from the skeleton tree by assuming that all the local\\n rotation is 0 and root translation is also 0.\\n\\n :param skeleton_tree: the skeleton tree as the rigid body\\n :type skeleton_tree: SkeletonTree\\n \\\"\\\"\\\"\\n return cls.from_rotation_and_root_translation(\\n skeleton_tree=skeleton_tree,\\n r=quat_identity([skeleton_tree.num_joints]),\\n t=torch.zeros(3, dtype=skeleton_tree.local_translation.dtype),\\n is_local=True,\\n )\\n\\n def local_repr(self):\\n \\\"\\\"\\\" \\n Convert the skeleton state into local representation. This will only affects the values of\\n .tensor. If the skeleton state already has `is_local=True`. This method will do nothing. \\n\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n if self.is_local:\\n return self\\n return SkeletonState.from_rotation_and_root_translation(\\n self.skeleton_tree,\\n r=self.local_rotation,\\n t=self.root_translation,\\n is_local=True,\\n )\\n\\n def global_repr(self):\\n \\\"\\\"\\\" \\n Convert the skeleton state into global representation. This will only affects the values of\\n .tensor. If the skeleton state already has `is_local=False`. This method will do nothing. \\n\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n if not self.is_local:\\n return self\\n return SkeletonState.from_rotation_and_root_translation(\\n self.skeleton_tree,\\n r=self.global_rotation,\\n t=self.root_translation,\\n is_local=False,\\n )\\n\\n def _get_pairwise_average_translation(self):\\n global_transform_inv = transform_inverse(self.global_transformation)\\n p1 = global_transform_inv.unsqueeze(-2)\\n p2 = self.global_transformation.unsqueeze(-3)\\n\\n pairwise_translation = (\\n transform_translation(transform_mul(p1, p2))\\n .reshape(-1, len(self.skeleton_tree), len(self.skeleton_tree), 3)\\n .mean(axis=0)\\n )\\n return pairwise_translation\\n\\n def _transfer_to(self, new_skeleton_tree: SkeletonTree):\\n old_indices = list(map(self.skeleton_tree.index, new_skeleton_tree))\\n return SkeletonState.from_rotation_and_root_translation(\\n new_skeleton_tree,\\n r=self.global_rotation[..., old_indices, :],\\n t=self.root_translation,\\n is_local=False,\\n )\\n\\n def drop_nodes_by_names(\\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Drop a list of nodes from the skeleton and re-compute the local rotation to match the \\n original joint position as much as possible. \\n\\n :param node_names: a list node names that specifies the nodes need to be dropped\\n :type node_names: List of strings\\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\\\\n or not to re-estimate the local translation from the states (avg.)\\n :type estimate_local_translation_from_states: boolean\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n if estimate_local_translation_from_states:\\n pairwise_translation = self._get_pairwise_average_translation()\\n else:\\n pairwise_translation = None\\n new_skeleton_tree = self.skeleton_tree.drop_nodes_by_names(\\n node_names, pairwise_translation\\n )\\n return self._transfer_to(new_skeleton_tree)\\n\\n def keep_nodes_by_names(\\n self, node_names: List[str], estimate_local_translation_from_states: bool = True\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Keep a list of nodes and drop all other nodes from the skeleton and re-compute the local \\n rotation to match the original joint position as much as possible. \\n\\n :param node_names: a list node names that specifies the nodes need to be dropped\\n :type node_names: List of strings\\n :param estimate_local_translation_from_states: the boolean indicator that specifies whether\\\\\\n or not to re-estimate the local translation from the states (avg.)\\n :type estimate_local_translation_from_states: boolean\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n return self.drop_nodes_by_names(\\n list(filter(lambda x: (x not in node_names), self)),\\n estimate_local_translation_from_states,\\n )\\n\\n def _remapped_to(\\n self, joint_mapping: Dict[str, str], target_skeleton_tree: SkeletonTree\\n ):\\n joint_mapping_inv = {target: source for source, target in joint_mapping.items()}\\n reduced_target_skeleton_tree = target_skeleton_tree.keep_nodes_by_names(\\n list(joint_mapping_inv)\\n )\\n n_joints = (\\n len(joint_mapping),\\n len(self.skeleton_tree),\\n len(reduced_target_skeleton_tree),\\n )\\n assert (\\n len(set(n_joints)) == 1\\n ), \\\"the joint mapping is not consistent with the skeleton trees\\\"\\n source_indices = list(\\n map(\\n lambda x: self.skeleton_tree.index(joint_mapping_inv[x]),\\n reduced_target_skeleton_tree,\\n )\\n )\\n target_local_rotation = self.local_rotation[..., source_indices, :]\\n return SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=reduced_target_skeleton_tree,\\n r=target_local_rotation,\\n t=self.root_translation,\\n is_local=True,\\n )\\n\\n def retarget_to(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose_local_rotation,\\n source_tpose_root_translation: np.ndarray,\\n target_skeleton_tree: SkeletonTree,\\n target_tpose_local_rotation,\\n target_tpose_root_translation: np.ndarray,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n z_up: bool = True,\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\\n implementation with rough approximations. The function follows the procedures below.\\n\\n Steps:\\n 1. Drop the joints from the source (self) that do not belong to the joint mapping\\\\\\n with an implementation that is similar to \\\"keep_nodes_by_names()\\\" - take a\\\\\\n look at the function doc for more details (same for source_tpose)\\n \\n 2. Rotate the source state and the source tpose by \\\"rotation_to_target_skeleton\\\"\\\\\\n to align the source with the target orientation\\n \\n 3. Extract the root translation and normalize it to match the scale of the target\\\\\\n skeleton\\n \\n 4. Extract the global rotation from source state relative to source tpose and\\\\\\n re-apply the relative rotation to the target tpose to construct the global\\\\\\n rotation after retargetting\\n \\n 5. Combine the computed global rotation and the root translation from 3 and 4 to\\\\\\n complete the retargeting.\\n \\n 6. Make feet on the ground (global translation z)\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose_local_rotation: the local rotation of the source skeleton\\n :type source_tpose_local_rotation: Tensor\\n \\n :param source_tpose_root_translation: the root translation of the source tpose\\n :type source_tpose_root_translation: np.ndarray\\n \\n :param target_skeleton_tree: the target skeleton tree\\n :type target_skeleton_tree: SkeletonTree\\n \\n :param target_tpose_local_rotation: the local rotation of the target skeleton\\n :type target_tpose_local_rotation: Tensor\\n \\n :param target_tpose_root_translation: the root translation of the target tpose\\n :type target_tpose_root_translation: Tensor\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n\\n # STEP 0: Preprocess\\n source_tpose = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=self.skeleton_tree,\\n r=source_tpose_local_rotation,\\n t=source_tpose_root_translation,\\n is_local=True,\\n )\\n target_tpose = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=target_skeleton_tree,\\n r=target_tpose_local_rotation,\\n t=target_tpose_root_translation,\\n is_local=True,\\n )\\n\\n # STEP 1: Drop the irrelevant joints\\n pairwise_translation = self._get_pairwise_average_translation()\\n node_names = list(joint_mapping)\\n new_skeleton_tree = self.skeleton_tree.keep_nodes_by_names(\\n node_names, pairwise_translation\\n )\\n\\n # TODO: combine the following steps before STEP 3\\n source_tpose = source_tpose._transfer_to(new_skeleton_tree)\\n source_state = self._transfer_to(new_skeleton_tree)\\n\\n source_tpose = source_tpose._remapped_to(joint_mapping, target_skeleton_tree)\\n source_state = source_state._remapped_to(joint_mapping, target_skeleton_tree)\\n\\n # STEP 2: Rotate the source to align with the target\\n new_local_rotation = source_tpose.local_rotation.clone()\\n new_local_rotation[..., 0, :] = quat_mul_norm(\\n rotation_to_target_skeleton, source_tpose.local_rotation[..., 0, :]\\n )\\n\\n source_tpose = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=source_tpose.skeleton_tree,\\n r=new_local_rotation,\\n t=quat_rotate(rotation_to_target_skeleton, source_tpose.root_translation),\\n is_local=True,\\n )\\n\\n new_local_rotation = source_state.local_rotation.clone()\\n new_local_rotation[..., 0, :] = quat_mul_norm(\\n rotation_to_target_skeleton, source_state.local_rotation[..., 0, :]\\n )\\n source_state = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=source_state.skeleton_tree,\\n r=new_local_rotation,\\n t=quat_rotate(rotation_to_target_skeleton, source_state.root_translation),\\n is_local=True,\\n )\\n\\n # STEP 3: Normalize to match the target scale\\n root_translation_diff = (\\n source_state.root_translation - source_tpose.root_translation\\n ) * scale_to_target_skeleton\\n\\n # STEP 4: the global rotation from source state relative to source tpose and\\n # re-apply to the target\\n current_skeleton_tree = source_state.skeleton_tree\\n target_tpose_global_rotation = source_state.global_rotation[0, :].clone()\\n for current_index, name in enumerate(current_skeleton_tree):\\n if name in target_tpose.skeleton_tree:\\n target_tpose_global_rotation[\\n current_index, :\\n ] = target_tpose.global_rotation[\\n target_tpose.skeleton_tree.index(name), :\\n ]\\n\\n global_rotation_diff = quat_mul_norm(\\n source_state.global_rotation, quat_inverse(source_tpose.global_rotation)\\n )\\n new_global_rotation = quat_mul_norm(\\n global_rotation_diff, target_tpose_global_rotation\\n )\\n\\n # STEP 5: Putting 3 and 4 together\\n current_skeleton_tree = source_state.skeleton_tree\\n shape = source_state.global_rotation.shape[:-1]\\n shape = shape[:-1] + target_tpose.global_rotation.shape[-2:-1]\\n new_global_rotation_output = quat_identity(shape)\\n for current_index, name in enumerate(target_skeleton_tree):\\n while name not in current_skeleton_tree:\\n name = target_skeleton_tree.parent_of(name)\\n parent_index = current_skeleton_tree.index(name)\\n new_global_rotation_output[:, current_index, :] = new_global_rotation[\\n :, parent_index, :\\n ]\\n\\n source_state = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree=target_skeleton_tree,\\n r=new_global_rotation_output,\\n t=target_tpose.root_translation + root_translation_diff,\\n is_local=False,\\n ).local_repr()\\n\\n return source_state\\n\\n def retarget_to_by_tpose(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose: \\\"SkeletonState\\\",\\n target_tpose: \\\"SkeletonState\\\",\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n ) -> \\\"SkeletonState\\\":\\n \\\"\\\"\\\" \\n Retarget the skeleton state to a target skeleton tree. This is a naive retarget\\n implementation with rough approximations. See the method `retarget_to()` for more information\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose: t-pose of the source skeleton\\n :type source_tpose: SkeletonState\\n \\n :param target_tpose: t-pose of the target skeleton\\n :type target_tpose: SkeletonState\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonState\\n \\\"\\\"\\\"\\n assert (\\n len(source_tpose.shape) == 0 and len(target_tpose.shape) == 0\\n ), \\\"the retargeting script currently doesn't support vectorized operations\\\"\\n return self.retarget_to(\\n joint_mapping,\\n source_tpose.local_rotation,\\n source_tpose.root_translation,\\n target_tpose.skeleton_tree,\\n target_tpose.local_rotation,\\n target_tpose.root_translation,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton,\\n )\"\n },\n {\n \"identifier\": \"SkeletonMotion\",\n \"path\": \"poselib/poselib/skeleton/skeleton3d.py\",\n \"snippet\": \"class SkeletonMotion(SkeletonState):\\n def __init__(self, tensor_backend, skeleton_tree, is_local, fps, *args, **kwargs):\\n self._fps = fps\\n super().__init__(tensor_backend, skeleton_tree, is_local, *args, **kwargs)\\n\\n def clone(self):\\n return SkeletonMotion(\\n self.tensor.clone(), self.skeleton_tree, self._is_local, self._fps\\n )\\n\\n @property\\n def invariant_property(self):\\n return {\\n \\\"skeleton_tree\\\": self.skeleton_tree,\\n \\\"is_local\\\": self.is_local,\\n \\\"fps\\\": self.fps,\\n }\\n\\n @property\\n def global_velocity(self):\\n \\\"\\\"\\\" global velocity \\\"\\\"\\\"\\n curr_index = self.num_joints * 4 + 3\\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\\n )\\n\\n @property\\n def global_angular_velocity(self):\\n \\\"\\\"\\\" global angular velocity \\\"\\\"\\\"\\n curr_index = self.num_joints * 7 + 3\\n return self.tensor[..., curr_index : curr_index + self.num_joints * 3].reshape(\\n *(self.tensor.shape[:-1] + (self.num_joints, 3))\\n )\\n\\n @property\\n def fps(self):\\n \\\"\\\"\\\" number of frames per second \\\"\\\"\\\"\\n return self._fps\\n\\n @property\\n def time_delta(self):\\n \\\"\\\"\\\" time between two adjacent frames \\\"\\\"\\\"\\n return 1.0 / self.fps\\n\\n @property\\n def global_root_velocity(self):\\n \\\"\\\"\\\" global root velocity \\\"\\\"\\\"\\n return self.global_velocity[..., 0, :]\\n\\n @property\\n def global_root_angular_velocity(self):\\n \\\"\\\"\\\" global root angular velocity \\\"\\\"\\\"\\n return self.global_angular_velocity[..., 0, :]\\n\\n @classmethod\\n def from_state_vector_and_velocity(\\n cls,\\n skeleton_tree,\\n state_vector,\\n global_velocity,\\n global_angular_velocity,\\n is_local,\\n fps,\\n ):\\n \\\"\\\"\\\"\\n Construct a skeleton motion from a skeleton state vector, global velocity and angular\\n velocity at each joint.\\n\\n :param skeleton_tree: the skeleton tree that the motion is based on \\n :type skeleton_tree: SkeletonTree\\n :param state_vector: the state vector from the skeleton state by `.tensor`\\n :type state_vector: Tensor\\n :param global_velocity: the global velocity at each joint\\n :type global_velocity: Tensor\\n :param global_angular_velocity: the global angular velocity at each joint\\n :type global_angular_velocity: Tensor\\n :param is_local: if the rotation ins the state vector is given in local frame\\n :type is_local: boolean\\n :param fps: number of frames per second\\n :type fps: int\\n\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n state_shape = state_vector.shape[:-1]\\n v = global_velocity.reshape(*(state_shape + (-1,)))\\n av = global_angular_velocity.reshape(*(state_shape + (-1,)))\\n new_state_vector = torch.cat([state_vector, v, av], axis=-1)\\n return cls(\\n new_state_vector, skeleton_tree=skeleton_tree, is_local=is_local, fps=fps,\\n )\\n\\n @classmethod\\n def from_skeleton_state(\\n cls: Type[\\\"SkeletonMotion\\\"], skeleton_state: SkeletonState, fps: int\\n ):\\n \\\"\\\"\\\"\\n Construct a skeleton motion from a skeleton state. The velocities are estimated using second\\n order guassian filter along the last axis. The skeleton state must have at least .dim >= 1\\n\\n :param skeleton_state: the skeleton state that the motion is based on \\n :type skeleton_state: SkeletonState\\n :param fps: number of frames per second\\n :type fps: int\\n\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n\\n assert (\\n type(skeleton_state) == SkeletonState\\n ), \\\"expected type of {}, got {}\\\".format(SkeletonState, type(skeleton_state))\\n\\n global_velocity = SkeletonMotion._compute_velocity(\\n p=skeleton_state.global_translation, time_delta=1 / fps\\n )\\n global_angular_velocity = SkeletonMotion._compute_angular_velocity(\\n r=skeleton_state.global_rotation, time_delta=1 / fps\\n )\\n\\n return cls.from_state_vector_and_velocity(\\n skeleton_tree=skeleton_state.skeleton_tree,\\n state_vector=skeleton_state.tensor,\\n global_velocity=global_velocity,\\n global_angular_velocity=global_angular_velocity,\\n is_local=skeleton_state.is_local,\\n fps=fps,\\n )\\n\\n @staticmethod\\n def _to_state_vector(rot, rt, vel, avel):\\n state_shape = rot.shape[:-2]\\n skeleton_state_v = SkeletonState._to_state_vector(rot, rt)\\n v = vel.reshape(*(state_shape + (-1,)))\\n av = avel.reshape(*(state_shape + (-1,)))\\n skeleton_motion_v = torch.cat([skeleton_state_v, v, av], axis=-1)\\n return skeleton_motion_v\\n\\n @classmethod\\n def from_dict(\\n cls: Type[\\\"SkeletonMotion\\\"], dict_repr: OrderedDict, *args, **kwargs\\n ) -> \\\"SkeletonMotion\\\":\\n rot = TensorUtils.from_dict(dict_repr[\\\"rotation\\\"], *args, **kwargs)\\n rt = TensorUtils.from_dict(dict_repr[\\\"root_translation\\\"], *args, **kwargs)\\n vel = TensorUtils.from_dict(dict_repr[\\\"global_velocity\\\"], *args, **kwargs)\\n avel = TensorUtils.from_dict(\\n dict_repr[\\\"global_angular_velocity\\\"], *args, **kwargs\\n )\\n return cls(\\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\\n skeleton_tree=SkeletonTree.from_dict(\\n dict_repr[\\\"skeleton_tree\\\"], *args, **kwargs\\n ),\\n is_local=dict_repr[\\\"is_local\\\"],\\n fps=dict_repr[\\\"fps\\\"],\\n )\\n\\n def to_dict(self) -> OrderedDict:\\n return OrderedDict(\\n [\\n (\\\"rotation\\\", tensor_to_dict(self.rotation)),\\n (\\\"root_translation\\\", tensor_to_dict(self.root_translation)),\\n (\\\"global_velocity\\\", tensor_to_dict(self.global_velocity)),\\n (\\\"global_angular_velocity\\\", tensor_to_dict(self.global_angular_velocity)),\\n (\\\"skeleton_tree\\\", self.skeleton_tree.to_dict()),\\n (\\\"is_local\\\", self.is_local),\\n (\\\"fps\\\", self.fps),\\n ]\\n )\\n\\n @classmethod\\n def from_fbx(\\n cls: Type[\\\"SkeletonMotion\\\"],\\n fbx_file_path,\\n fbx_configs,\\n skeleton_tree=None,\\n is_local=True,\\n fps=120,\\n root_joint=\\\"\\\",\\n root_trans_index=0,\\n *args,\\n **kwargs,\\n ) -> \\\"SkeletonMotion\\\":\\n \\\"\\\"\\\"\\n Construct a skeleton motion from a fbx file (TODO - generalize this). If the skeleton tree\\n is not given, it will use the first frame of the mocap to construct the skeleton tree.\\n\\n :param fbx_file_path: the path of the fbx file\\n :type fbx_file_path: string\\n :param fbx_configs: the configuration in terms of {\\\"tmp_path\\\": ..., \\\"fbx_py27_path\\\": ...}\\n :type fbx_configs: dict\\n :param skeleton_tree: the optional skeleton tree that the rotation will be applied to\\n :type skeleton_tree: SkeletonTree, optional\\n :param is_local: the state vector uses local or global rotation as the representation\\n :type is_local: bool, optional, default=True\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n joint_names, joint_parents, transforms, fps = fbx_to_array(\\n fbx_file_path, fbx_configs, root_joint, fps\\n )\\n # swap the last two axis to match the convention\\n local_transform = euclidean_to_transform(\\n transformation_matrix=torch.from_numpy(\\n np.swapaxes(np.array(transforms), -1, -2),\\n ).float()\\n )\\n local_rotation = transform_rotation(local_transform)\\n root_translation = transform_translation(local_transform)[..., root_trans_index, :]\\n joint_parents = torch.from_numpy(np.array(joint_parents)).int()\\n\\n if skeleton_tree is None:\\n local_translation = transform_translation(local_transform).reshape(\\n -1, len(joint_parents), 3\\n )[0]\\n skeleton_tree = SkeletonTree(joint_names, joint_parents, local_translation)\\n skeleton_state = SkeletonState.from_rotation_and_root_translation(\\n skeleton_tree, r=local_rotation, t=root_translation, is_local=True\\n )\\n if not is_local:\\n skeleton_state = skeleton_state.global_repr()\\n return cls.from_skeleton_state(\\n skeleton_state=skeleton_state, fps=fps\\n )\\n\\n @staticmethod\\n def _compute_velocity(p, time_delta, guassian_filter=True):\\n velocity = torch.from_numpy(\\n filters.gaussian_filter1d(\\n np.gradient(p.numpy(), axis=-3), 2, axis=-3, mode=\\\"nearest\\\"\\n )\\n / time_delta,\\n )\\n return velocity\\n\\n @staticmethod\\n def _compute_angular_velocity(r, time_delta: float, guassian_filter=True):\\n # assume the second last dimension is the time axis\\n diff_quat_data = quat_identity_like(r)\\n diff_quat_data[..., :-1, :, :] = quat_mul_norm(\\n r[..., 1:, :, :], quat_inverse(r[..., :-1, :, :])\\n )\\n diff_angle, diff_axis = quat_angle_axis(diff_quat_data)\\n angular_velocity = diff_axis * diff_angle.unsqueeze(-1) / time_delta\\n angular_velocity = torch.from_numpy(\\n filters.gaussian_filter1d(\\n angular_velocity.numpy(), 2, axis=-3, mode=\\\"nearest\\\"\\n ),\\n )\\n return angular_velocity\\n\\n def crop(self, start: int, end: int, fps: Optional[int] = None):\\n \\\"\\\"\\\"\\n Crop the motion along its last axis. This is equivalent to performing a slicing on the\\n object with [..., start: end: skip_every] where skip_every = old_fps / fps. Note that the\\n new fps provided must be a factor of the original fps. \\n\\n :param start: the beginning frame index\\n :type start: int\\n :param end: the ending frame index\\n :type end: int\\n :param fps: number of frames per second in the output (if not given the original fps will be used)\\n :type fps: int, optional\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n if fps is None:\\n new_fps = int(self.fps)\\n old_fps = int(self.fps)\\n else:\\n new_fps = int(fps)\\n old_fps = int(self.fps)\\n assert old_fps % fps == 0, (\\n \\\"the resampling doesn't support fps with non-integer division \\\"\\n \\\"from the original fps: {} => {}\\\".format(old_fps, fps)\\n )\\n skip_every = old_fps // new_fps\\n s = slice(start, end, skip_every)\\n z = self[..., s]\\n\\n rot = z.local_rotation if z.is_local else z.global_rotation\\n rt = z.root_translation\\n vel = z.global_velocity\\n avel = z.global_angular_velocity\\n return SkeletonMotion(\\n SkeletonMotion._to_state_vector(rot, rt, vel, avel),\\n skeleton_tree=z.skeleton_tree,\\n is_local=z.is_local,\\n fps=new_fps,\\n )\\n\\n def retarget_to(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose_local_rotation,\\n source_tpose_root_translation: np.ndarray,\\n target_skeleton_tree: \\\"SkeletonTree\\\",\\n target_tpose_local_rotation,\\n target_tpose_root_translation: np.ndarray,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n z_up: bool = True,\\n ) -> \\\"SkeletonMotion\\\":\\n \\\"\\\"\\\" \\n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\\n new retargetted motion.\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose_local_rotation: the local rotation of the source skeleton\\n :type source_tpose_local_rotation: Tensor\\n \\n :param source_tpose_root_translation: the root translation of the source tpose\\n :type source_tpose_root_translation: np.ndarray\\n \\n :param target_skeleton_tree: the target skeleton tree\\n :type target_skeleton_tree: SkeletonTree\\n \\n :param target_tpose_local_rotation: the local rotation of the target skeleton\\n :type target_tpose_local_rotation: Tensor\\n \\n :param target_tpose_root_translation: the root translation of the target tpose\\n :type target_tpose_root_translation: Tensor\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n return SkeletonMotion.from_skeleton_state(\\n super().retarget_to(\\n joint_mapping,\\n source_tpose_local_rotation,\\n source_tpose_root_translation,\\n target_skeleton_tree,\\n target_tpose_local_rotation,\\n target_tpose_root_translation,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton,\\n z_up,\\n ),\\n self.fps,\\n )\\n\\n def retarget_to_by_tpose(\\n self,\\n joint_mapping: Dict[str, str],\\n source_tpose: \\\"SkeletonState\\\",\\n target_tpose: \\\"SkeletonState\\\",\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton: float,\\n z_up: bool = True,\\n ) -> \\\"SkeletonMotion\\\":\\n \\\"\\\"\\\" \\n Same as the one in :class:`SkeletonState`. This method discards all velocity information before\\n retargeting and re-estimate the velocity after the retargeting. The same fps is used in the\\n new retargetted motion.\\n\\n :param joint_mapping: a dictionary of that maps the joint node from the source skeleton to \\\\\\n the target skeleton\\n :type joint_mapping: Dict[str, str]\\n \\n :param source_tpose: t-pose of the source skeleton\\n :type source_tpose: SkeletonState\\n \\n :param target_tpose: t-pose of the target skeleton\\n :type target_tpose: SkeletonState\\n \\n :param rotation_to_target_skeleton: the rotation that needs to be applied to the source\\\\\\n skeleton to align with the target skeleton. Essentially the rotation is t_R_s, where t is\\\\\\n the frame of reference of the target skeleton and s is the frame of reference of the source\\\\\\n skeleton\\n :type rotation_to_target_skeleton: Tensor\\n :param scale_to_target_skeleton: the factor that needs to be multiplied from source\\\\\\n skeleton to target skeleton (unit in distance). For example, to go from `cm` to `m`, the \\\\\\n factor needs to be 0.01.\\n :type scale_to_target_skeleton: float\\n :rtype: SkeletonMotion\\n \\\"\\\"\\\"\\n return self.retarget_to(\\n joint_mapping,\\n source_tpose.local_rotation,\\n source_tpose.root_translation,\\n target_tpose.skeleton_tree,\\n target_tpose.local_rotation,\\n target_tpose.root_translation,\\n rotation_to_target_skeleton,\\n scale_to_target_skeleton,\\n z_up,\\n )\"\n },\n {\n \"identifier\": \"plot_skeleton_state\",\n \"path\": \"poselib/poselib/visualization/common.py\",\n \"snippet\": \"def plot_skeleton_state(skeleton_state, task_name=\\\"\\\"):\\n \\\"\\\"\\\"\\n Visualize a skeleton state\\n\\n :param skeleton_state:\\n :param task_name:\\n :type skeleton_state: SkeletonState\\n :type task_name: string, optional\\n \\\"\\\"\\\"\\n logger.info(\\\"plotting {}\\\".format(task_name))\\n task = Draw3DSkeletonState(task_name=task_name, skeleton_state=skeleton_state)\\n plotter = Matplotlib3DPlotter(task)\\n plotter.show()\"\n },\n {\n \"identifier\": \"plot_skeleton_motion_interactive\",\n \"path\": \"poselib/poselib/visualization/common.py\",\n \"snippet\": \"def plot_skeleton_motion_interactive(skeleton_motion, task_name=\\\"\\\"):\\n \\\"\\\"\\\"\\n Visualize a skeleton motion along its first dimension interactively.\\n\\n :param skeleton_motion:\\n :param task_name:\\n :type skeleton_motion: SkeletonMotion\\n :type task_name: string, optional\\n \\\"\\\"\\\"\\n for _ in plot_skeleton_motion_interactive_base(skeleton_motion, task_name):\\n pass\"\n },\n {\n \"identifier\": \"Matplotlib3DPlotter\",\n \"path\": \"poselib/poselib/visualization/plt_plotter.py\",\n \"snippet\": \"class Matplotlib3DPlotter(BasePlotter):\\n _fig: plt.figure # plt figure\\n _ax: p3.Axes3D # plt 3d axis\\n # stores artist objects for each task (task name as the key)\\n _artist_cache: Dict[str, Any]\\n # callables for each task primitives\\n _create_impl_callables: Dict[str, Callable]\\n _update_impl_callables: Dict[str, Callable]\\n\\n def __init__(self, task: \\\"BasePlotterTask\\\") -> None:\\n self._fig = plt.figure()\\n self._ax = p3.Axes3D(self._fig)\\n self._artist_cache = {}\\n\\n self._create_impl_callables = {\\n \\\"Draw3DLines\\\": self._lines_create_impl,\\n \\\"Draw3DDots\\\": self._dots_create_impl,\\n \\\"Draw3DTrail\\\": self._trail_create_impl,\\n }\\n self._update_impl_callables = {\\n \\\"Draw3DLines\\\": self._lines_update_impl,\\n \\\"Draw3DDots\\\": self._dots_update_impl,\\n \\\"Draw3DTrail\\\": self._trail_update_impl,\\n }\\n self._init_lim()\\n super().__init__(task)\\n\\n @property\\n def ax(self):\\n return self._ax\\n\\n @property\\n def fig(self):\\n return self._fig\\n\\n def show(self):\\n plt.show()\\n\\n def _min(self, x, y):\\n if x is None:\\n return y\\n if y is None:\\n return x\\n return min(x, y)\\n\\n def _max(self, x, y):\\n if x is None:\\n return y\\n if y is None:\\n return x\\n return max(x, y)\\n\\n def _init_lim(self):\\n self._curr_x_min = None\\n self._curr_y_min = None\\n self._curr_z_min = None\\n self._curr_x_max = None\\n self._curr_y_max = None\\n self._curr_z_max = None\\n\\n def _update_lim(self, xs, ys, zs):\\n self._curr_x_min = self._min(np.min(xs), self._curr_x_min)\\n self._curr_y_min = self._min(np.min(ys), self._curr_y_min)\\n self._curr_z_min = self._min(np.min(zs), self._curr_z_min)\\n self._curr_x_max = self._max(np.max(xs), self._curr_x_max)\\n self._curr_y_max = self._max(np.max(ys), self._curr_y_max)\\n self._curr_z_max = self._max(np.max(zs), self._curr_z_max)\\n\\n def _set_lim(self):\\n if not (\\n self._curr_x_min is None\\n or self._curr_x_max is None\\n or self._curr_y_min is None\\n or self._curr_y_max is None\\n or self._curr_z_min is None\\n or self._curr_z_max is None\\n ):\\n self._ax.set_xlim3d(self._curr_x_min, self._curr_x_max)\\n self._ax.set_ylim3d(self._curr_y_min, self._curr_y_max)\\n self._ax.set_zlim3d(self._curr_z_min, self._curr_z_max)\\n self._init_lim()\\n\\n @staticmethod\\n def _lines_extract_xyz_impl(index, lines_task):\\n return lines_task[index, :, 0], lines_task[index, :, 1], lines_task[index, :, 2]\\n\\n @staticmethod\\n def _trail_extract_xyz_impl(index, trail_task):\\n return (\\n trail_task[index : index + 2, 0],\\n trail_task[index : index + 2, 1],\\n trail_task[index : index + 2, 2],\\n )\\n\\n def _lines_create_impl(self, lines_task):\\n color = lines_task.color\\n self._artist_cache[lines_task.task_name] = [\\n self._ax.plot(\\n *Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task),\\n color=color,\\n linewidth=lines_task.line_width,\\n alpha=lines_task.alpha\\n )[0]\\n for i in range(len(lines_task))\\n ]\\n\\n def _lines_update_impl(self, lines_task):\\n lines_artists = self._artist_cache[lines_task.task_name]\\n for i in range(len(lines_task)):\\n artist = lines_artists[i]\\n xs, ys, zs = Matplotlib3DPlotter._lines_extract_xyz_impl(i, lines_task)\\n artist.set_data(xs, ys)\\n artist.set_3d_properties(zs)\\n if lines_task.influence_lim:\\n self._update_lim(xs, ys, zs)\\n\\n def _dots_create_impl(self, dots_task):\\n color = dots_task.color\\n self._artist_cache[dots_task.task_name] = self._ax.plot(\\n dots_task[:, 0],\\n dots_task[:, 1],\\n dots_task[:, 2],\\n c=color,\\n linestyle=\\\"\\\",\\n marker=\\\".\\\",\\n markersize=dots_task.marker_size,\\n alpha=dots_task.alpha,\\n )[0]\\n\\n def _dots_update_impl(self, dots_task):\\n dots_artist = self._artist_cache[dots_task.task_name]\\n dots_artist.set_data(dots_task[:, 0], dots_task[:, 1])\\n dots_artist.set_3d_properties(dots_task[:, 2])\\n if dots_task.influence_lim:\\n self._update_lim(dots_task[:, 0], dots_task[:, 1], dots_task[:, 2])\\n\\n def _trail_create_impl(self, trail_task):\\n color = trail_task.color\\n trail_length = len(trail_task) - 1\\n self._artist_cache[trail_task.task_name] = [\\n self._ax.plot(\\n *Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task),\\n color=trail_task.color,\\n linewidth=trail_task.line_width,\\n alpha=trail_task.alpha * (1.0 - i / (trail_length - 1))\\n )[0]\\n for i in range(trail_length)\\n ]\\n\\n def _trail_update_impl(self, trail_task):\\n trails_artists = self._artist_cache[trail_task.task_name]\\n for i in range(len(trail_task) - 1):\\n artist = trails_artists[i]\\n xs, ys, zs = Matplotlib3DPlotter._trail_extract_xyz_impl(i, trail_task)\\n artist.set_data(xs, ys)\\n artist.set_3d_properties(zs)\\n if trail_task.influence_lim:\\n self._update_lim(xs, ys, zs)\\n\\n def _create_impl(self, task_list):\\n for task in task_list:\\n self._create_impl_callables[task.task_type](task)\\n self._draw()\\n\\n def _update_impl(self, task_list):\\n for task in task_list:\\n self._update_impl_callables[task.task_type](task)\\n self._draw()\\n\\n def _set_aspect_equal_3d(self):\\n xlim = self._ax.get_xlim3d()\\n ylim = self._ax.get_ylim3d()\\n zlim = self._ax.get_zlim3d()\\n\\n xmean = np.mean(xlim)\\n ymean = np.mean(ylim)\\n zmean = np.mean(zlim)\\n\\n plot_radius = max(\\n [\\n abs(lim - mean_)\\n for lims, mean_ in ((xlim, xmean), (ylim, ymean), (zlim, zmean))\\n for lim in lims\\n ]\\n )\\n\\n self._ax.set_xlim3d([xmean - plot_radius, xmean + plot_radius])\\n self._ax.set_ylim3d([ymean - plot_radius, ymean + plot_radius])\\n self._ax.set_zlim3d([zmean - plot_radius, zmean + plot_radius])\\n\\n def _draw(self):\\n self._set_lim()\\n self._set_aspect_equal_3d()\\n self._fig.canvas.draw()\\n self._fig.canvas.flush_events()\\n plt.pause(0.00001)\"\n },\n {\n \"identifier\": \"Draw3DSkeletonMotion\",\n \"path\": \"poselib/poselib/visualization/skeleton_plotter_tasks.py\",\n \"snippet\": \"class Draw3DSkeletonMotion(BasePlotterTask):\\n def __init__(\\n self,\\n task_name: str,\\n skeleton_motion,\\n frame_index=None,\\n joints_color=\\\"red\\\",\\n lines_color=\\\"blue\\\",\\n velocity_color=\\\"green\\\",\\n angular_velocity_color=\\\"purple\\\",\\n trail_color=\\\"black\\\",\\n trail_length=10,\\n alpha=1.0,\\n ) -> None:\\n super().__init__(task_name=task_name, task_type=\\\"3DSkeletonMotion\\\")\\n self._trail_length = trail_length\\n self._skeleton_motion = skeleton_motion\\n # if frame_index is None:\\n curr_skeleton_motion = self._skeleton_motion.clone()\\n if frame_index is not None:\\n curr_skeleton_motion.tensor = self._skeleton_motion.tensor[frame_index, :]\\n # else:\\n # curr_skeleton_motion = self._skeleton_motion[frame_index, :]\\n self._skeleton_state_task = Draw3DSkeletonState(\\n self.get_scoped_name(\\\"skeleton_state\\\"),\\n curr_skeleton_motion,\\n joints_color=joints_color,\\n lines_color=lines_color,\\n alpha=alpha,\\n )\\n vel_lines, avel_lines = Draw3DSkeletonMotion._get_vel_and_avel(\\n curr_skeleton_motion\\n )\\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\\n np.newaxis, ...\\n ].repeat(trail_length, axis=0)\\n self._vel_task = Draw3DLines(\\n self.get_scoped_name(\\\"velocity\\\"),\\n vel_lines,\\n velocity_color,\\n influence_lim=False,\\n alpha=alpha,\\n )\\n self._avel_task = Draw3DLines(\\n self.get_scoped_name(\\\"angular_velocity\\\"),\\n avel_lines,\\n angular_velocity_color,\\n influence_lim=False,\\n alpha=alpha,\\n )\\n self._com_trail_task = Draw3DTrail(\\n self.get_scoped_name(\\\"com_trail\\\"),\\n self._com_pos,\\n trail_color,\\n marker_size=2,\\n influence_lim=True,\\n alpha=alpha,\\n )\\n\\n @property\\n def name(self):\\n return \\\"3DSkeletonMotion\\\"\\n\\n def update(self, frame_index=None, reset_trail=False, skeleton_motion=None) -> None:\\n if skeleton_motion is not None:\\n self._skeleton_motion = skeleton_motion\\n\\n curr_skeleton_motion = self._skeleton_motion.clone()\\n if frame_index is not None:\\n curr_skeleton_motion.tensor = curr_skeleton_motion.tensor[frame_index, :]\\n if reset_trail:\\n self._com_pos = curr_skeleton_motion.root_translation.numpy()[\\n np.newaxis, ...\\n ].repeat(self._trail_length, axis=0)\\n else:\\n self._com_pos = np.concatenate(\\n (\\n curr_skeleton_motion.root_translation.numpy()[np.newaxis, ...],\\n self._com_pos[:-1],\\n ),\\n axis=0,\\n )\\n self._skeleton_state_task.update(curr_skeleton_motion)\\n self._com_trail_task.update(self._com_pos)\\n self._update(*Draw3DSkeletonMotion._get_vel_and_avel(curr_skeleton_motion))\\n\\n @staticmethod\\n def _get_vel_and_avel(skeleton_motion):\\n \\\"\\\"\\\"Get all the velocity and angular velocity lines\\n \\\"\\\"\\\"\\n pos = skeleton_motion.global_translation.numpy()\\n vel = skeleton_motion.global_velocity.numpy()\\n avel = skeleton_motion.global_angular_velocity.numpy()\\n\\n vel_lines = np.stack((pos, pos + vel * 0.02), axis=1)\\n avel_lines = np.stack((pos, pos + avel * 0.01), axis=1)\\n return vel_lines, avel_lines\\n\\n def _update(self, vel_lines, avel_lines) -> None:\\n self._vel_task.update(vel_lines)\\n self._avel_task.update(avel_lines)\\n\\n def __iter__(self):\\n yield from self._skeleton_state_task\\n yield from self._vel_task\\n yield from self._avel_task\\n yield from self._com_trail_task\"\n },\n {\n \"identifier\": \"Draw3DSkeletonState\",\n \"path\": \"poselib/poselib/visualization/skeleton_plotter_tasks.py\",\n \"snippet\": \"class Draw3DSkeletonState(BasePlotterTask):\\n _lines_task: Draw3DLines # sub-task for drawing lines\\n _dots_task: Draw3DDots # sub-task for drawing dots\\n\\n def __init__(\\n self,\\n task_name: str,\\n skeleton_state,\\n joints_color: str = \\\"red\\\",\\n lines_color: str = \\\"blue\\\",\\n alpha=1.0,\\n ) -> None:\\n super().__init__(task_name=task_name, task_type=\\\"3DSkeletonState\\\")\\n lines, dots = Draw3DSkeletonState._get_lines_and_dots(skeleton_state)\\n self._lines_task = Draw3DLines(\\n self.get_scoped_name(\\\"bodies\\\"), lines, joints_color, alpha=alpha\\n )\\n self._dots_task = Draw3DDots(\\n self.get_scoped_name(\\\"joints\\\"), dots, lines_color, alpha=alpha\\n )\\n\\n @property\\n def name(self):\\n return \\\"3DSkeleton\\\"\\n\\n def update(self, skeleton_state) -> None:\\n self._update(*Draw3DSkeletonState._get_lines_and_dots(skeleton_state))\\n\\n @staticmethod\\n def _get_lines_and_dots(skeleton_state):\\n \\\"\\\"\\\"Get all the lines and dots needed to draw the skeleton state\\n \\\"\\\"\\\"\\n assert (\\n len(skeleton_state.tensor.shape) == 1\\n ), \\\"the state has to be zero dimensional\\\"\\n dots = skeleton_state.global_translation.numpy()\\n skeleton_tree = skeleton_state.skeleton_tree\\n parent_indices = skeleton_tree.parent_indices.numpy()\\n lines = []\\n for node_index in range(len(skeleton_tree)):\\n parent_index = parent_indices[node_index]\\n if parent_index != -1:\\n lines.append([dots[node_index], dots[parent_index]])\\n lines = np.array(lines)\\n return lines, dots\\n\\n def _update(self, lines, dots) -> None:\\n self._lines_task.update(lines)\\n self._dots_task.update(dots)\\n\\n def __iter__(self):\\n yield from self._lines_task\\n yield from self._dots_task\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from ...core import *\nfrom ..skeleton3d import SkeletonTree, SkeletonState, SkeletonMotion\nfrom ...visualization.common import (\n plot_skeleton_state,\n plot_skeleton_motion_interactive,\n)\nfrom ...visualization.plt_plotter import Matplotlib3DPlotter\nfrom ...visualization.skeleton_plotter_tasks import (\n Draw3DSkeletonMotion,\n Draw3DSkeletonState,\n)\nimport numpy as np\nimport torch"},"token_num":{"kind":"number","value":18248,"string":"18,248"},"cropped_code":{"kind":"string","value":"# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.\n# NVIDIA CORPORATION and its licensors retain all intellectual property\n# and proprietary rights in and to this software, related documentation\n# and any modifications thereto. Any use, reproduction, disclosure or\n# distribution of this software and related documentation without an express\n# license agreement from NVIDIA CORPORATION is strictly prohibited.\n\n\n\n\n\n\ndef test_skel_tree():\n skel_tree = SkeletonTree.from_mjcf(\n \"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml\",\n backend=\"pytorch\",\n )\n skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend=\"pytorch\")\n # assert skel_tree.to_str() == skel_tree_rec.to_str()\n print(skel_tree.node_names)\n print(skel_tree.local_translation)\n print(skel_tree.parent_indices)\n skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n skel_state = skel_state.drop_nodes_by_names([\"right_hip\", \"left_hip\"])\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n\n\ndef test_skel_motion():\n skel_motion = SkeletonMotion.from_file(\n \"/tmp/tmp.npy\", backend=\"pytorch\", load_context=True\n )\n\n"},"all_code":{"kind":"string","value":"# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.\n# NVIDIA CORPORATION and its licensors retain all intellectual property\n# and proprietary rights in and to this software, related documentation\n# and any modifications thereto. Any use, reproduction, disclosure or\n# distribution of this software and related documentation without an express\n# license agreement from NVIDIA CORPORATION is strictly prohibited.\n\n\n\n\n\n\ndef test_skel_tree():\n skel_tree = SkeletonTree.from_mjcf(\n \"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml\",\n backend=\"pytorch\",\n )\n skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend=\"pytorch\")\n # assert skel_tree.to_str() == skel_tree_rec.to_str()\n print(skel_tree.node_names)\n print(skel_tree.local_translation)\n print(skel_tree.parent_indices)\n skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n skel_state = skel_state.drop_nodes_by_names([\"right_hip\", \"left_hip\"])\n plot_skeleton_state(task_name=\"draw_skeleton\", skeleton_state=skel_state)\n\n\ndef test_skel_motion():\n skel_motion = SkeletonMotion.from_file(\n \"/tmp/tmp.npy\", backend=\"pytorch\", load_context=True\n )\n"},"next_line":{"kind":"string","value":" plot_skeleton_motion_interactive(skel_motion)"},"gold_snippet_index":{"kind":"number","value":4,"string":"4"},"created_at":{"kind":"string","value":"2023-10-31 20:47:12+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5687,"cells":{"repo_name":{"kind":"string","value":"Improbable-AI/dexenv"},"file_path":{"kind":"string","value":"dexenv/envs/dclaw_multiobjs.py"},"context":{"kind":"list like","value":[{"identifier":"DClawBase","path":"dexenv/envs/dclaw_base.py","snippet":"class DClawBase(VecTask):\n\n def __init__(self, cfg, sim_device, rl_device, graphics_device_id):\n\n self.cfg = cfg\n headless = self.cfg.headless\n self.randomize = self.cfg[\"task\"][\"randomize\"]\n if self.randomize:\n logger.warning(f'Domain randomization is enabled!')\n self.randomization_params = self.cfg[\"task\"][\"randomization_params\"]\n self.aggregate_mode = self.cfg[\"env\"][\"aggregateMode\"]\n\n self.dist_reward_scale = self.cfg[\"env\"][\"rew\"][\"distRewardScale\"]\n self.rot_reward_scale = self.cfg[\"env\"][\"rew\"][\"rotRewardScale\"]\n self.success_tolerance = self.cfg[\"env\"][\"rew\"][\"successTolerance\"]\n self.reach_goal_bonus = self.cfg[\"env\"][\"rew\"][\"reachGoalBonus\"]\n self.fall_dist = self.cfg[\"env\"][\"rew\"][\"fallDistance\"]\n self.fall_penalty = self.cfg[\"env\"][\"rew\"][\"fallPenalty\"]\n self.rot_eps = self.cfg[\"env\"][\"rew\"][\"rotEps\"]\n\n self.vel_obs_scale = 0.2 # scale factor of velocity based observations\n self.force_torque_obs_scale = 10.0 # scale factor of velocity based observations\n\n self.reset_position_noise = self.cfg[\"env\"][\"resetPositionNoise\"]\n self.reset_rotation_noise = self.cfg[\"env\"][\"resetRotationNoise\"]\n self.reset_dof_pos_noise = self.cfg[\"env\"][\"resetDofPosRandomInterval\"]\n self.reset_dof_vel_noise = self.cfg[\"env\"][\"resetDofVelRandomInterval\"]\n\n self.force_scale = self.cfg[\"env\"].get(\"forceScale\", 0.0)\n self.force_prob_range = self.cfg[\"env\"].get(\"forceProbRange\", [0.001, 0.1])\n self.force_decay = self.cfg[\"env\"].get(\"forceDecay\", 0.99)\n self.force_decay_interval = self.cfg[\"env\"].get(\"forceDecayInterval\", 0.08)\n\n self.dclaw_dof_speed_scale = self.cfg[\"env\"][\"dofSpeedScale\"]\n # self.act_moving_average = self.cfg[\"env\"][\"actionsMovingAverage\"]\n\n self.debug_viz = self.cfg[\"env\"][\"enableDebugVis\"]\n\n self.max_episode_length = self.cfg[\"env\"][\"episodeLength\"]\n self.reset_time = self.cfg[\"env\"].get(\"resetTime\", -1.0)\n self.print_success_stat = self.cfg[\"env\"][\"printNumSuccesses\"]\n self.max_consecutive_successes = self.cfg[\"env\"][\"maxConsecutiveSuccesses\"]\n self.av_factor = self.cfg[\"env\"].get(\"averFactor\", 0.1)\n\n self.object_type = self.cfg[\"env\"][\"objectType\"]\n\n self.asset_files_dict = {\n \"block\": \"urdf/objects/cube_multicolor.urdf\",\n \"egg\": \"mjcf/open_ai_assets/hand/egg.xml\",\n \"airplane\": \"single_objects/airplane/model.urdf\",\n 'power_drill': 'single_objects/power_drill/model.urdf',\n 'mug': 'single_objects/mug/model.urdf',\n 'elephant': 'asymm/train/elephant/var_000/model.urdf',\n 'train': 'asymm/train/train/var_000/model.urdf',\n 'stanford_bunny': 'asymm/train/stanford_bunny/var_004/model.urdf'\n\n }\n self.objs_in_isaacgym = ['block', 'egg']\n\n if \"asset\" in self.cfg[\"env\"]:\n self.asset_files_dict[\"block\"] = self.cfg[\"env\"][\"asset\"].get(\"assetFileNameBlock\",\n self.asset_files_dict[\"block\"])\n self.asset_files_dict[\"egg\"] = self.cfg[\"env\"][\"asset\"].get(\"assetFileNameEgg\",\n self.asset_files_dict[\"egg\"])\n\n self.obs_type = self.cfg[\"env\"][\"observationType\"]\n\n if not (self.obs_type in [\"full_no_vel\", \"full\", \"full_state\"]):\n raise Exception(\n \"Unknown type of observations!\\nobservationType should be one of: [openai, full_no_vel, full, full_state]\")\n\n print(\"Obs type:\", self.obs_type)\n\n ## TODO: change value here\n self.num_obs_dict = {\n \"full_no_vel\": 42,\n \"full\": 87,\n \"full_state\": 114\n }\n\n self.up_axis = 'z'\n\n num_states = 0\n\n self.cfg[\"env\"][\"numObservations\"] = self.num_obs_dict[self.obs_type]\n self.cfg[\"env\"][\"numStates\"] = num_states\n self.cfg[\"env\"][\"numActions\"] = 12\n self.hist_buf_reset_env_ids = None\n\n super().__init__(config=self.cfg,\n sim_device=sim_device,\n rl_device=rl_device,\n graphics_device_id=graphics_device_id,\n headless=headless)\n\n self.dt = self.sim_params.dt\n control_freq_inv = self.cfg[\"env\"].get(\"controlFrequencyInv\", 1)\n if self.reset_time > 0.0:\n self.max_episode_length = int(round(self.reset_time / (control_freq_inv * self.dt)))\n print(\"Reset time: \", self.reset_time)\n print(\"New episode length: \", self.max_episode_length)\n\n if self.viewer != None:\n cam_pos = gymapi.Vec3(0.16, -0.5, 0.5)\n cam_target = gymapi.Vec3(0.0, 0.0, 0.15)\n self.gym.viewer_camera_look_at(self.viewer, None, cam_pos, cam_target)\n\n actor_root_state_tensor = self.gym.acquire_actor_root_state_tensor(self.sim)\n dof_state_tensor = self.gym.acquire_dof_state_tensor(self.sim)\n rigid_body_tensor = self.gym.acquire_rigid_body_state_tensor(self.sim)\n dof_force_tensor = self.gym.acquire_dof_force_tensor(self.sim)\n\n if self.obs_type == \"full_state\":\n sensor_tensor = self.gym.acquire_force_sensor_tensor(self.sim)\n self.vec_sensor_tensor = gymtorch.wrap_tensor(sensor_tensor).view(self.num_envs, self.num_fingertips * 6)\n\n dof_force_tensor = self.gym.acquire_dof_force_tensor(self.sim)\n self.dof_force_tensor = gymtorch.wrap_tensor(dof_force_tensor).view(self.num_envs,\n self.num_dclaw_dofs)\n\n self.gym.refresh_actor_root_state_tensor(self.sim)\n self.gym.refresh_dof_state_tensor(self.sim)\n if self.cfg.env.dof_torque_on:\n self.gym.refresh_dof_force_tensor(self.sim)\n self.gym.refresh_rigid_body_state_tensor(self.sim)\n\n self.dof_state = gymtorch.wrap_tensor(dof_state_tensor)\n self.dclaw_dof_state = self.dof_state.view(self.num_envs, -1, 2)[:, :self.num_dclaw_dofs]\n self.dclaw_dof_pos = self.dclaw_dof_state[..., 0]\n self.dclaw_dof_vel = self.dclaw_dof_state[..., 1]\n if self.cfg.env.dof_torque_on:\n self.dclaw_dof_torque = gymtorch.wrap_tensor(dof_force_tensor).view(self.num_envs, -1)\n else:\n self.dclaw_dof_torque = None\n\n self.rigid_body_states = gymtorch.wrap_tensor(rigid_body_tensor).view(self.num_envs, -1, 13)\n self.num_bodies = self.rigid_body_states.shape[1]\n\n self.root_state_tensor = gymtorch.wrap_tensor(actor_root_state_tensor).view(-1, 13)\n\n if self.cfg.env.rew.pen_tb_contact:\n _net_cf = self.gym.acquire_net_contact_force_tensor(self.sim)\n self.net_contact_force = gymtorch.wrap_tensor(_net_cf).view(self.num_envs, -1, 3)\n table_handle = self.gym.find_actor_handle(self.envs[0], 'table')\n self.table_body_index = self.gym.find_actor_rigid_body_index(self.envs[0],\n table_handle,\n 'table',\n gymapi.DOMAIN_ENV)\n logger.warning(f'Table body index:{self.table_body_index}')\n self.table_contact_force = self.net_contact_force[:, self.table_body_index]\n\n self.num_dofs = self.gym.get_sim_dof_count(self.sim) // self.num_envs\n self.prev_targets = torch.zeros((self.num_envs, self.num_dofs), dtype=torch.float, device=self.device)\n self.cur_targets = torch.zeros((self.num_envs, self.num_dofs), dtype=torch.float, device=self.device)\n\n self.global_indices = torch.arange(self.num_envs * 3, dtype=torch.int32, device=self.device).view(self.num_envs, -1)\n\n self.reset_goal_buf = self.reset_buf.clone()\n self.successes = torch.zeros(self.num_envs, dtype=torch.float, device=self.device)\n self.consecutive_successes = torch.zeros(1, dtype=torch.float, device=self.device)\n\n self.av_factor = to_torch(self.av_factor, dtype=torch.float, device=self.device)\n\n self.total_successes = 0\n self.total_resets = 0\n\n self.force_decay = to_torch(self.force_decay, dtype=torch.float, device=self.device)\n self.force_prob_range = to_torch(self.force_prob_range, dtype=torch.float, device=self.device)\n self.random_force_prob = torch.exp((torch.log(self.force_prob_range[0]) - torch.log(self.force_prob_range[1]))\n * torch.rand(self.num_envs, device=self.device) + torch.log(\n self.force_prob_range[1]))\n\n self.rb_forces = torch.zeros((self.num_envs, self.num_bodies, 3), dtype=torch.float, device=self.device)\n\n self.num_actions = self.num_dclaw_dofs\n self.actions = self.zero_actions()\n DClawBase.compute_observations(self)\n self.num_observations = self.obs_buf.shape[-1]\n self.cfg.env.numObservations = self.num_observations\n self.create_ob_act_space()\n\n def create_sim(self):\n self.dt = self.cfg[\"sim\"][\"dt\"]\n self.up_axis_idx = self.set_sim_params_up_axis(self.sim_params, self.up_axis)\n\n self.sim = super().create_sim(self.device_id, self.graphics_device_id, self.physics_engine, self.sim_params)\n self._create_ground_plane()\n self._create_envs(self.num_envs, self.cfg[\"env\"]['envSpacing'], int(np.sqrt(self.num_envs)))\n\n if self.randomize:\n self.apply_randomizations(self.randomization_params)\n\n def _create_ground_plane(self):\n plane_params = gymapi.PlaneParams()\n plane_params.normal = gymapi.Vec3(0.0, 0.0, 1.0)\n plane_params.distance = 0.1\n self.gym.add_ground(self.sim, plane_params)\n\n def _create_envs(self, num_envs, spacing, num_per_row):\n lower = gymapi.Vec3(-spacing, -spacing, 0.0)\n upper = gymapi.Vec3(spacing, spacing, spacing)\n\n asset_root = dexenv.LIB_PATH.joinpath('assets', 'dclaw').as_posix()\n object_asset_file = self.asset_files_dict[self.object_type]\n\n dclaw_asset, dclaw_dof_props = self.get_dclaw_asset(asset_root=asset_root)\n table_asset = self.get_table_asset()\n table_pose = self.get_table_pose()\n\n if self.obs_type == \"full_state\":\n sensor_pose = gymapi.Transform()\n for ft_handle in self.fingertip_handles:\n self.gym.create_asset_force_sensor(dclaw_asset, ft_handle, sensor_pose)\n\n if self.object_type in self.objs_in_isaacgym:\n asset_root = get_module_path('isaacgymenvs').parent.joinpath('assets').as_posix()\n else:\n asset_root = dexenv.LIB_PATH.joinpath('assets').as_posix()\n\n object_asset_options = gymapi.AssetOptions()\n if self.cfg.env.vhacd:\n object_asset_options.convex_decomposition_from_submeshes = True\n\n object_asset = self.gym.load_asset(self.sim, asset_root, object_asset_file, object_asset_options)\n\n object_asset_options.disable_gravity = True\n goal_asset = self.gym.load_asset(self.sim, asset_root, object_asset_file, object_asset_options)\n\n dclaw_start_pose = self.get_dclaw_start_pose()\n object_start_pose = self.get_object_start_pose(dclaw_start_pose)\n\n goal_start_pose = self.get_goal_object_start_pose(object_start_pose=object_start_pose)\n\n self.dclaws = []\n self.envs = []\n\n self.object_init_state = []\n self.hand_start_states = []\n\n self.hand_indices = []\n self.fingertip_indices = []\n self.object_indices = []\n self.goal_object_indices = []\n\n self.render_camera_handles = []\n if self.cfg.rgb_render:\n render_cam_pose, render_cam_params = self.get_visual_render_camera_setup()\n\n self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in\n self.fingertips]\n print(f'Fingertip handles:{self.fingertip_handles}')\n\n dclaw_rb_count = self.gym.get_asset_rigid_body_count(dclaw_asset)\n object_rb_count = self.gym.get_asset_rigid_body_count(object_asset)\n object_rs_count = self.gym.get_asset_rigid_shape_count(object_asset)\n self.object_rb_handles = list(range(dclaw_rb_count, dclaw_rb_count + object_rb_count))\n self.object_handles = []\n\n max_agg_bodies = self.num_dclaw_bodies + 2 * object_rb_count + 1\n max_agg_shapes = self.num_dclaw_shapes + 2 * object_rs_count + 1\n\n for i in range(self.num_envs):\n env_ptr = self.gym.create_env(\n self.sim, lower, upper, num_per_row\n )\n\n if self.aggregate_mode >= 1:\n self.gym.begin_aggregate(env_ptr, max_agg_bodies, max_agg_shapes, True)\n\n self.create_hand_actor(env_ptr=env_ptr,\n dclaw_asset=dclaw_asset,\n dclaw_start_pose=dclaw_start_pose,\n dclaw_dof_props=dclaw_dof_props,\n env_id=i)\n\n object_handle = self.gym.create_actor(env_ptr, object_asset, object_start_pose, \"object\", i, 0, 1)\n self.object_handles.append(object_handle)\n self.object_init_state.append([object_start_pose.p.x, object_start_pose.p.y, object_start_pose.p.z,\n object_start_pose.r.x, object_start_pose.r.y, object_start_pose.r.z,\n object_start_pose.r.w,\n 0, 0, 0, 0, 0, 0])\n object_idx = self.gym.get_actor_index(env_ptr, object_handle, gymapi.DOMAIN_SIM)\n self.object_indices.append(object_idx)\n\n goal_handle = self.gym.create_actor(env_ptr, goal_asset, goal_start_pose, \"goal_object\", i + self.num_envs,\n 0, 2)\n goal_object_idx = self.gym.get_actor_index(env_ptr, goal_handle, gymapi.DOMAIN_SIM)\n self.goal_object_indices.append(goal_object_idx)\n\n if self.cfg.env.blockscale is not None and self.cfg.env.objectType == 'block':\n blockscale = float(self.cfg.env.blockscale)\n self.gym.set_actor_scale(env_ptr, object_handle, blockscale)\n self.gym.set_actor_scale(env_ptr, goal_handle, blockscale)\n\n if self.object_type != \"block\":\n self.gym.set_rigid_body_color(\n env_ptr, object_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(0.6, 0.72, 0.98))\n self.gym.set_rigid_body_color(\n env_ptr, goal_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(0.6, 0.72, 0.98))\n table_handle = self.gym.create_actor(env_ptr, table_asset, table_pose, \"table\", i, 0)\n\n if self.cfg.rgb_render:\n render_camera_handle = self.create_camera(render_cam_pose, env_ptr, render_cam_params)\n self.render_camera_handles.append(render_camera_handle[0])\n\n if self.aggregate_mode > 0:\n self.gym.end_aggregate(env_ptr)\n\n self.envs.append(env_ptr)\n\n self.setup_torch_states()\n\n def create_camera(self, camera_poses, env_ptr, camera_params):\n cam_handles = []\n for ic in range(min(len(camera_poses), self.cfg.cam.cam_num)):\n camera_handle = self.gym.create_camera_sensor(env_ptr, camera_params)\n if isinstance(camera_poses[ic], tuple):\n self.gym.set_camera_location(camera_handle, env_ptr, camera_poses[ic][0], camera_poses[ic][1])\n else:\n self.gym.set_camera_transform(camera_handle, env_ptr, camera_poses[ic])\n cam_handles.append(camera_handle)\n return cam_handles\n\n def get_visual_render_camera_setup(self):\n cam_pos = np.array([-0.7, 0, 0.5])\n cam_focus_pt = np.array([0.08, 0, 0.15])\n cam_focus_pt = gymapi.Vec3(*cam_focus_pt)\n cam_pos = gymapi.Vec3(*cam_pos)\n camera_poses = [(cam_pos, cam_focus_pt)]\n camera_params = get_camera_params(width=self.cfg.cam.visual_render_width,\n height=self.cfg.cam.visual_render_height,\n hov=45,\n cuda=False)\n return camera_poses, camera_params\n\n def create_hand_actor(self, env_ptr, dclaw_asset, dclaw_start_pose, dclaw_dof_props, env_id):\n dclaw_actor = self.gym.create_actor(env_ptr, dclaw_asset, dclaw_start_pose, \"hand\", env_id, 0, 0)\n if self.cfg.env.dof_torque_on:\n self.gym.enable_actor_dof_force_sensors(env_ptr, dclaw_actor)\n self.hand_start_states.append(\n [dclaw_start_pose.p.x, dclaw_start_pose.p.y, dclaw_start_pose.p.z,\n dclaw_start_pose.r.x, dclaw_start_pose.r.y, dclaw_start_pose.r.z,\n dclaw_start_pose.r.w,\n 0, 0, 0, 0, 0, 0])\n self.gym.set_actor_dof_properties(env_ptr, dclaw_actor, dclaw_dof_props)\n hand_idx = self.gym.get_actor_index(env_ptr, dclaw_actor, gymapi.DOMAIN_SIM)\n self.hand_indices.append(hand_idx)\n\n self.gym.set_actor_dof_states(env_ptr, dclaw_actor, self.dclaw_default_dof_states, gymapi.STATE_ALL)\n if self.obs_type == \"full_state\":\n self.gym.enable_actor_dof_force_sensors(env_ptr, dclaw_actor)\n self.dclaws.append(dclaw_actor)\n self.set_hand_color(env_ptr, dclaw_actor)\n\n def set_hand_color(self, env_ptr, dclaw_actor):\n rgd_dict = self.gym.get_actor_rigid_body_dict(env_ptr, dclaw_actor)\n for bd, bd_id in rgd_dict.items():\n if bd not in dclaw_body_color_mapping:\n continue\n color = gymapi.Vec3(*dclaw_body_color_mapping[bd])\n self.gym.set_rigid_body_color(env_ptr, dclaw_actor,\n bd_id, gymapi.MESH_VISUAL,\n color)\n\n def get_table_asset(self):\n asset_options = gymapi.AssetOptions()\n asset_options.armature = 0.001\n asset_options.fix_base_link = True\n asset_options.thickness = 0.001\n asset_options.disable_gravity = True\n table_dims = gymapi.Vec3(0.6, 0.6, 0.1)\n table_asset = self.gym.create_box(self.sim,\n table_dims.x,\n table_dims.y,\n table_dims.z,\n asset_options)\n table_props = self.gym.get_asset_rigid_shape_properties(table_asset)\n for p in table_props:\n p.friction = self.cfg.env.table.friction\n p.torsion_friction = self.cfg.env.table.torsion_friction\n p.restitution = self.cfg.env.table.restitution\n p.rolling_friction = self.cfg.env.table.rolling_friction\n self.gym.set_asset_rigid_shape_properties(table_asset, table_props)\n return table_asset\n\n def get_table_pose(self):\n object_start_pose = gymapi.Transform()\n object_start_pose.p = gymapi.Vec3()\n object_start_pose.p.x = 0\n object_start_pose.p.y = 0\n object_start_pose.p.z = -0.05\n return object_start_pose\n\n def get_dclaw_start_pose(self):\n dclaw_start_pose = gymapi.Transform()\n dclaw_start_pose.p = gymapi.Vec3(*get_axis_params(0.25, self.up_axis_idx))\n dclaw_start_pose.r = gymapi.Quat.from_axis_angle(gymapi.Vec3(0, 1, 0), np.pi)\n return dclaw_start_pose\n\n def setup_torch_states(self):\n self.render_rgb_obs_buf = None\n if self.cfg.rgb_render:\n self.gym.set_light_parameters(self.sim, 0, gymapi.Vec3(0.9, 0.9, 0.9),\n gymapi.Vec3(0.9, 0.9, 0.9), gymapi.Vec3(0, 0, 0))\n else:\n self.gym.set_light_parameters(self.sim, 0, gymapi.Vec3(0.9, 0.9, 0.9),\n gymapi.Vec3(0.7, 0.7, 0.7), gymapi.Vec3(0, 0, 0))\n self.object_init_state = to_torch(self.object_init_state, device=self.device, dtype=torch.float).view(\n self.num_envs, 13)\n self.goal_states = self.object_init_state.clone()\n self.goal_states[:, self.up_axis_idx] -= 0.04\n self.goal_init_state = self.goal_states.clone()\n self.hand_start_states = to_torch(self.hand_start_states, device=self.device).view(self.num_envs, 13)\n\n self.fingertip_handles = to_torch(self.fingertip_handles, dtype=torch.long, device=self.device)\n self.object_rb_handles = to_torch(self.object_rb_handles, dtype=torch.long, device=self.device)\n self.object_rb_masses = None\n self.update_obj_mass()\n self.hand_indices = to_torch(self.hand_indices, dtype=torch.long, device=self.device)\n self.object_indices = to_torch(self.object_indices, dtype=torch.long, device=self.device)\n self.goal_object_indices = to_torch(self.goal_object_indices, dtype=torch.long, device=self.device)\n\n def get_dclaw_asset(self, asset_root=None, asset_options=None):\n # load dclaw asset\n if asset_options is None:\n asset_options = gymapi.AssetOptions()\n asset_options.flip_visual_attachments = False\n asset_options.fix_base_link = True\n asset_options.collapse_fixed_joints = False\n asset_options.disable_gravity = False\n asset_options.thickness = 0.001\n asset_options.angular_damping = 0.01\n asset_options.override_inertia = True\n asset_options.override_com = True\n logger.info(f'VHACD:{self.cfg.env.vhacd}')\n if self.cfg.env.vhacd:\n asset_options.convex_decomposition_from_submeshes = True\n if self.cfg.physics_engine == \"physx\":\n # if self.physics_engine == gymapi.SIM_PHYSX:\n asset_options.use_physx_armature = True\n asset_options.default_dof_drive_mode = gymapi.DOF_MODE_POS\n\n if asset_root is None:\n asset_root = dexenv.LIB_PATH.joinpath('assets', 'dclaw_4f').as_posix()\n robot_name = self.cfg.env.robot\n asset_root = pathlib_file(asset_root).parent.joinpath(f'{robot_name}').as_posix()\n dclaw_asset = self.gym.load_asset(self.sim, asset_root, f\"{robot_name}.urdf\", asset_options)\n print(f'Dclaw asset root:{asset_root} robot name:{robot_name}')\n\n self.num_dclaw_bodies = self.gym.get_asset_rigid_body_count(dclaw_asset)\n self.num_dclaw_shapes = self.gym.get_asset_rigid_shape_count(dclaw_asset)\n self.num_dclaw_dofs = self.gym.get_asset_dof_count(dclaw_asset)\n\n print(f'D-Claw:')\n print(f'\\t Number of bodies: {self.num_dclaw_bodies}')\n print(f'\\t Number of shapes: {self.num_dclaw_shapes}')\n print(f'\\t Number of dofs: {self.num_dclaw_dofs}')\n\n self.dclaw_asset_dof_dict = self.gym.get_asset_dof_dict(dclaw_asset)\n joint_names = self.dclaw_asset_dof_dict.keys()\n logger.info(f'Joint names:{joint_names}')\n\n self.dof_joint_indices = list(self.dclaw_asset_dof_dict.values())\n dinds = np.array(self.dof_joint_indices)\n assert np.all(np.diff(dinds) > 0) # check if it's in a sorted order (ascending)\n\n rb_links = self.gym.get_asset_rigid_body_names(dclaw_asset)\n self.fingertips = [x for x in rb_links if 'tip_link' in x] # [\"one_tip_link\", \"two_tip_link\", \"three_tip_link\"]\n self.num_fingertips = len(self.fingertips)\n\n print(f'Number of fingertips:{self.num_fingertips} Fingertips:{self.fingertips}')\n\n print(f'Actuator --- DoF Index')\n for act_name, act_index in zip(joint_names, self.dof_joint_indices):\n print(f'\\t {act_name} {act_index}')\n\n dclaw_dof_props = self.gym.get_asset_dof_properties(dclaw_asset)\n\n def set_dof_prop(props, prop_name, val):\n if np.isscalar(val):\n props[prop_name].fill(val)\n elif len(val) == 3:\n props[prop_name] = np.array(list(val) * int(len(props[prop_name]) / 3))\n else:\n props[prop_name] = np.array(val)\n\n if self.cfg[\"env\"][\"dof_vel_hard_limit\"] is not None:\n vel_hard_limit = self.cfg[\"env\"][\"dof_vel_hard_limit\"] if not self.cfg.env.soft_control else self.cfg[\"env\"][\"soft_dof_vel_hard_limit\"]\n print(f'Setting DOF velocity limit to:{vel_hard_limit}')\n set_dof_prop(dclaw_dof_props, 'velocity', vel_hard_limit)\n if self.cfg[\"env\"][\"effort_limit\"] is not None:\n effort_limit = self.cfg[\"env\"][\"effort_limit\"] if not self.cfg.env.soft_control else self.cfg[\"env\"][\"soft_effort_limit\"]\n print(f'Setting DOF effort limit to:{effort_limit}')\n set_dof_prop(dclaw_dof_props, 'effort', effort_limit)\n if self.cfg[\"env\"][\"stiffness\"] is not None:\n stiffness = self.cfg[\"env\"][\"stiffness\"] if not self.cfg.env.soft_control else self.cfg[\"env\"][\"soft_stiffness\"]\n print(f'Setting stiffness to:{stiffness}')\n set_dof_prop(dclaw_dof_props, 'stiffness', stiffness)\n if self.cfg[\"env\"][\"damping\"] is not None:\n damping = self.cfg[\"env\"][\"damping\"] if not self.cfg.env.soft_control else self.cfg[\"env\"][\"soft_damping\"]\n print(f'Setting damping to:{damping}')\n set_dof_prop(dclaw_dof_props, 'damping', damping)\n\n self.dclaw_dof_lower_limits = []\n self.dclaw_dof_upper_limits = []\n\n self.dclaw_default_dof_states = np.zeros(self.num_dclaw_dofs, dtype=gymapi.DofState.dtype)\n self.dclaw_default_dof_pos = self.dclaw_default_dof_states['pos']\n self.dclaw_default_dof_vel = self.dclaw_default_dof_states['vel']\n for i in range(self.num_dclaw_dofs):\n self.dclaw_dof_lower_limits.append(dclaw_dof_props['lower'][i])\n self.dclaw_dof_upper_limits.append(dclaw_dof_props['upper'][i])\n if i % 3 == 1:\n self.dclaw_default_dof_pos[i] = 0.8\n elif i % 3 == 2:\n self.dclaw_default_dof_pos[i] = -1.1\n else:\n self.dclaw_default_dof_pos[i] = 0.\n self.dclaw_default_dof_vel[i] = 0.0\n\n self.dof_joint_indices = to_torch(self.dof_joint_indices, dtype=torch.long, device=self.device)\n self.dclaw_dof_lower_limits = to_torch(self.dclaw_dof_lower_limits, device=self.device)\n self.dclaw_dof_upper_limits = to_torch(self.dclaw_dof_upper_limits, device=self.device)\n self.dclaw_default_dof_pos = to_torch(self.dclaw_default_dof_pos, device=self.device)\n self.dclaw_default_dof_vel = to_torch(self.dclaw_default_dof_vel, device=self.device)\n\n self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in\n self.fingertips]\n\n dclaw_asset_props = self.gym.get_asset_rigid_shape_properties(dclaw_asset)\n for p in dclaw_asset_props:\n p.friction = self.cfg.env.hand.friction\n p.torsion_friction = self.cfg.env.hand.torsion_friction\n p.rolling_friction = self.cfg.env.hand.rolling_friction\n p.restitution = self.cfg.env.hand.restitution\n self.gym.set_asset_rigid_shape_properties(dclaw_asset, dclaw_asset_props)\n return dclaw_asset, dclaw_dof_props\n\n def get_object_start_pose(self, dclaw_start_pose):\n object_start_pose = gymapi.Transform()\n object_start_pose.p = gymapi.Vec3()\n if self.cfg.env.obj_init_delta_pos is not None:\n delta_pos = self.cfg.env.obj_init_delta_pos\n object_start_pose.p.x = dclaw_start_pose.p.x + delta_pos[0]\n object_start_pose.p.y = dclaw_start_pose.p.y + delta_pos[1]\n object_start_pose.p.z = dclaw_start_pose.p.z + delta_pos[2]\n else:\n object_start_pose.p.x = dclaw_start_pose.p.x\n pose_dy, pose_dz = 0., -0.13\n object_start_pose.p.y = dclaw_start_pose.p.y + pose_dy\n object_start_pose.p.z = dclaw_start_pose.p.z + pose_dz\n return object_start_pose\n\n def get_goal_object_start_pose(self, object_start_pose):\n self.goal_displacement = gymapi.Vec3(0., 0, 0.25)\n self.goal_displacement_tensor = to_torch(\n [self.goal_displacement.x, self.goal_displacement.y, self.goal_displacement.z], device=self.device)\n goal_start_pose = gymapi.Transform()\n goal_start_pose.p = object_start_pose.p + self.goal_displacement\n return goal_start_pose\n\n def set_dof_props(self, props_dict):\n param_setters_map = get_property_setter_map(self.gym)\n param_getters_map = get_property_getter_map(self.gym)\n prop_name = 'dof_properties'\n setter = param_setters_map[prop_name]\n for env_id in range(len(self.envs)):\n env = self.envs[env_id]\n handle = self.gym.find_actor_handle(env, 'hand')\n prop = param_getters_map[prop_name](env, handle)\n for dof_prop_name, dof_prop_values in props_dict.items():\n if env_id == 0:\n assert len(dof_prop_values) == len(self.envs)\n prop_val = dof_prop_values[env_id]\n prop[dof_prop_name].fill(prop_val)\n success = setter(env, handle, prop)\n if not success:\n logger.warning(f'Setting dof properties is not successful!')\n\n def update_obj_mass(self, env_ids=None):\n object_rb_masses = []\n env_pool = env_ids if env_ids is not None else list(range(self.num_envs))\n if len(env_pool) < 1:\n return\n for env_id, object_handle in zip(env_pool, self.object_handles):\n env_ptr = self.envs[env_id]\n object_rb_props = self.gym.get_actor_rigid_body_properties(env_ptr, object_handle)\n object_rb_masses.append([prop.mass for prop in object_rb_props])\n if self.object_rb_masses is None:\n self.object_rb_masses = to_torch(object_rb_masses, dtype=torch.float, device=self.device)\n else:\n self.object_rb_masses[env_pool] = to_torch(object_rb_masses, dtype=torch.float, device=self.device)\n\n def reset(self) -> torch.Tensor:\n \"\"\"Reset the environment.\n Returns:\n Observation dictionary\n \"\"\"\n zero_actions = self.zero_actions()\n self.reset_buf.fill_(1)\n self.reset_goal_buf.fill_(1)\n if self.cfg.env.action_ema is not None:\n self.action_ema_val = zero_actions.clone()\n # step the simulator\n\n self.step(zero_actions)\n\n return self.update_obs()\n\n def compute_reward(self, actions):\n res = compute_dclaw_reward(\n self.reset_buf, self.reset_goal_buf, self.progress_buf,\n self.successes, self.max_episode_length,\n self.object_pos, self.object_rot, self.goal_pos, self.goal_rot,\n self.cfg['env']['rew'], self.actions,\n self.fingertip_pos, self.fingertip_vel, self.object_linvel, self.object_angvel,\n self.dclaw_dof_vel, self.dclaw_dof_torque,\n table_cf=self.table_contact_force if self.cfg.env.rew.pen_tb_contact else None\n )\n self.rew_buf[:] = res[0] * self.cfg.env.rew.rew_scale\n self.done_buf[:] = res[1]\n self.reset_buf[:] = res[2]\n self.reset_goal_buf[:] = res[3]\n self.progress_buf[:] = res[4]\n self.successes[:] = res[5]\n abs_rot_dist = res[6]\n reward_terms = res[7]\n timeout_envs = res[8]\n\n self.extras['success'] = self.reset_goal_buf.detach().to(self.rl_device).flatten()\n self.extras['abs_dist'] = abs_rot_dist.detach().to(self.rl_device)\n self.extras['TimeLimit.truncated'] = timeout_envs.detach().to(self.rl_device)\n for reward_key, reward_val in reward_terms.items():\n self.extras[reward_key] = reward_val.detach()\n\n def get_images(self):\n rgb = self.render_rgb_obs_buf\n return rgb\n\n def compute_observations(self):\n self.gym.refresh_dof_state_tensor(self.sim)\n if self.cfg.env.dof_torque_on:\n self.gym.refresh_dof_force_tensor(self.sim)\n self.gym.refresh_actor_root_state_tensor(self.sim)\n self.gym.refresh_rigid_body_state_tensor(self.sim)\n\n if self.obs_type == \"full_state\":\n self.gym.refresh_force_sensor_tensor(self.sim)\n self.gym.refresh_dof_force_tensor(self.sim)\n\n if self.cfg.env.rew.pen_tb_contact:\n self.gym.refresh_net_contact_force_tensor(self.sim)\n\n self.object_pose = self.root_state_tensor[self.object_indices, 0:7]\n self.object_pos = self.root_state_tensor[self.object_indices, 0:3]\n self.object_rot = self.root_state_tensor[self.object_indices, 3:7]\n self.object_linvel = self.root_state_tensor[self.object_indices, 7:10]\n self.object_angvel = self.root_state_tensor[self.object_indices, 10:13]\n\n self.goal_pose = self.goal_states[:, 0:7]\n self.goal_pos = self.goal_states[:, 0:3]\n self.goal_rot = self.goal_states[:, 3:7]\n\n self.fingertip_state = self.rigid_body_states[:, self.fingertip_handles][:, :, 0:13]\n self.fingertip_pos = self.rigid_body_states[:, self.fingertip_handles][:, :, 0:3]\n self.fingertip_vel = self.rigid_body_states[:, self.fingertip_handles][:, :, 7:13]\n\n if self.obs_type == \"full_no_vel\":\n obs_buf = self.compute_full_observations(no_vel=True)\n elif self.obs_type == \"full\":\n obs_buf = self.compute_full_observations()\n elif self.obs_type == \"full_state\":\n obs_buf = self.compute_full_state()\n else:\n print(\"Unkown observations type!\")\n self.obs_buf = obs_buf\n\n if self.cfg.rgb_render:\n self.gym.fetch_results(self.sim, True)\n self.gym.step_graphics(self.sim)\n self.gym.render_all_camera_sensors(self.sim)\n self.gym.start_access_image_tensors(self.sim)\n self.render_rgb_obs_buf = self.get_numpy_rgb_images(self.render_camera_handles)\n self.gym.end_access_image_tensors(self.sim)\n\n def allocate_ob_buffers(self):\n self.obs_buf = torch.zeros(\n (self.num_envs, self.num_obs), device=self.device, dtype=torch.float)\n\n def compute_full_observations(self, no_vel=False):\n scaled_dof_pos = unscale(\n self.dclaw_dof_pos,\n self.dclaw_dof_lower_limits,\n self.dclaw_dof_upper_limits\n )\n quat_dist = quat_mul(self.object_rot, quat_conjugate(self.goal_rot))\n\n if no_vel:\n out = torch.cat(\n [\n scaled_dof_pos,\n self.object_pose,\n self.goal_rot,\n quat_dist,\n self.fingertip_pos.reshape(self.num_envs, 3 * self.num_fingertips),\n self.actions\n ],\n dim=-1\n )\n else:\n out = torch.cat(\n [\n scaled_dof_pos,\n self.vel_obs_scale * self.dclaw_dof_vel,\n self.object_pose,\n self.object_linvel,\n self.vel_obs_scale * self.object_angvel,\n self.goal_rot,\n quat_dist,\n self.fingertip_state.reshape(self.num_envs, 13 * self.num_fingertips),\n self.actions\n ],\n dim=-1\n )\n return out\n\n def compute_full_state(self):\n obs_buf = self.compute_full_observations()\n obs_no_actions = obs_buf[:, :-9]\n actions = obs_buf[:, -9:]\n out = torch.cat(\n [\n obs_no_actions,\n self.force_torque_obs_scale * self.dof_force_tensor,\n self.force_torque_obs_scale * self.vec_sensor_tensor,\n actions\n ],\n dim=-1\n )\n\n return out\n\n def update_obs(self):\n if self.randomize:\n self.obs_buf = self.dr_randomizations['observations']['noise_lambda'](self.obs_buf)\n\n self.obs_dict[\"ob\"] = torch.clamp(self.obs_buf, -self.clip_obs, self.clip_obs).to(self.rl_device)\n if self.num_states > 0:\n self.obs_dict[\"state\"] = self.get_state()\n return self.obs_dict\n\n def reset_target_pose(self, env_ids, apply_reset=False):\n new_rot = random_quaternions(num=len(env_ids), device=self.device, order='xyzw')\n\n self.goal_states[env_ids, 0:3] = self.goal_init_state[env_ids, 0:3]\n self.goal_states[env_ids, 3:7] = new_rot\n self.root_state_tensor[self.goal_object_indices[env_ids], 0:3] = self.goal_states[env_ids, 0:3] + self.goal_displacement_tensor\n self.root_state_tensor[self.goal_object_indices[env_ids], 3:7] = self.goal_states[env_ids, 3:7]\n self.root_state_tensor[self.goal_object_indices[env_ids], 7:13] = torch.zeros_like(\n self.root_state_tensor[self.goal_object_indices[env_ids], 7:13])\n\n if apply_reset:\n goal_object_indices = self.goal_object_indices[env_ids].to(torch.int32)\n self.gym.set_actor_root_state_tensor_indexed(self.sim,\n gymtorch.unwrap_tensor(self.root_state_tensor),\n gymtorch.unwrap_tensor(goal_object_indices), len(env_ids))\n self.reset_goal_buf[env_ids] = 0\n\n def reset_idx(self, env_ids, goal_env_ids):\n if self.randomize and not self.cfg.env.rand_once:\n self.apply_randomizations(self.randomization_params)\n\n rand_floats = torch_rand_float(-1.0, 1.0, (len(env_ids), self.num_dclaw_dofs * 2 + 3), device=self.device)\n\n self.reset_target_pose(env_ids)\n self.rb_forces[env_ids, :, :] = 0.0\n\n self.root_state_tensor[self.object_indices[env_ids]] = self.object_init_state[env_ids].clone()\n self.root_state_tensor[self.object_indices[env_ids], 0:3] = self.object_init_state[env_ids, 0:3] + \\\n self.reset_position_noise * rand_floats[:, 0:3]\n\n new_object_rot = random_quaternions(num=len(env_ids), device=self.device, order='xyzw')\n\n self.root_state_tensor[self.object_indices[env_ids], 3:7] = new_object_rot\n self.root_state_tensor[self.object_indices[env_ids], 7:13] = torch.zeros_like(\n self.root_state_tensor[self.object_indices[env_ids], 7:13])\n\n object_indices = torch.unique(torch.cat([self.object_indices[env_ids],\n self.goal_object_indices[env_ids],\n self.goal_object_indices[goal_env_ids]]).to(torch.int32))\n self.gym.set_actor_root_state_tensor_indexed(self.sim,\n gymtorch.unwrap_tensor(self.root_state_tensor),\n gymtorch.unwrap_tensor(object_indices), len(object_indices))\n self.random_force_prob[env_ids] = torch.exp(\n (torch.log(self.force_prob_range[0]) - torch.log(self.force_prob_range[1]))\n * torch.rand(len(env_ids), device=self.device) + torch.log(self.force_prob_range[1]))\n\n delta_max = self.dclaw_dof_upper_limits - self.dclaw_default_dof_pos\n delta_min = self.dclaw_dof_lower_limits - self.dclaw_default_dof_pos\n rand_delta = delta_min + (delta_max - delta_min) * rand_floats[:, 3:3 + self.num_dclaw_dofs]\n\n pos = self.dclaw_default_dof_pos + self.reset_dof_pos_noise * rand_delta\n self.dclaw_dof_pos[env_ids, :] = pos\n self.dclaw_dof_vel[env_ids, :] = self.dclaw_default_dof_vel + \\\n self.reset_dof_vel_noise * rand_floats[:,\n 3 + self.num_dclaw_dofs:3 + self.num_dclaw_dofs * 2]\n self.prev_targets[env_ids, :self.num_dclaw_dofs] = pos\n self.cur_targets[env_ids, :self.num_dclaw_dofs] = pos\n\n hand_indices = self.hand_indices[env_ids].to(torch.int32)\n self.gym.set_dof_position_target_tensor_indexed(self.sim,\n gymtorch.unwrap_tensor(self.prev_targets),\n gymtorch.unwrap_tensor(hand_indices), len(env_ids))\n self.gym.set_dof_state_tensor_indexed(self.sim,\n gymtorch.unwrap_tensor(self.dof_state),\n gymtorch.unwrap_tensor(hand_indices), len(env_ids))\n\n self.progress_buf[env_ids] = 0\n self.reset_buf[env_ids] = 0\n self.successes[env_ids] = 0\n\n def get_numpy_rgb_images(self, camera_handles):\n rgb_obs_buf = []\n for cam_handles, env in zip(camera_handles, self.envs):\n cam_ob = []\n if isinstance(cam_handles, list):\n for cam_handle in cam_handles:\n color_image = self.gym.get_camera_image(self.sim, env, cam_handle, gymapi.IMAGE_COLOR)\n color_image = color_image.reshape(color_image.shape[0], -1, 4)[..., :3]\n cam_ob.append(color_image)\n rgb_obs_buf.append(cam_ob)\n else:\n color_image = self.gym.get_camera_image(self.sim, env, cam_handles, gymapi.IMAGE_COLOR)\n color_image = color_image.reshape(color_image.shape[0], -1, 4)[..., :3]\n rgb_obs_buf.append(color_image)\n rgb_obs_buf = np.stack(rgb_obs_buf)\n return rgb_obs_buf\n\n def pre_physics_step(self, actions):\n env_ids = self.reset_buf.nonzero(as_tuple=False).squeeze(-1)\n goal_env_ids = self.reset_goal_buf.nonzero(as_tuple=False).squeeze(-1)\n\n if len(goal_env_ids) > 0 and len(env_ids) == 0:\n self.reset_target_pose(goal_env_ids, apply_reset=True)\n elif len(goal_env_ids) > 0:\n self.reset_target_pose(goal_env_ids)\n\n if len(env_ids) > 0:\n self.reset_idx(env_ids, goal_env_ids)\n\n self.actions = actions.clone().to(self.device)\n\n if self.cfg.env.action_ema is not None:\n self.action_ema_val[env_ids] = 0\n self.action_ema_val[goal_env_ids] = 0\n self.actions = self.actions * self.cfg.env.action_ema + self.action_ema_val * (1 - self.cfg.env.action_ema)\n self.action_ema_val = self.actions.clone()\n if self.cfg.env.dof_vel_pol_limit is not None:\n delta_action = self.actions * self.cfg.env.dof_vel_pol_limit * (self.dt * self.cfg.env.controlFrequencyInv)\n else:\n delta_action = self.dclaw_dof_speed_scale * self.dt * self.actions\n if self.cfg.env.relativeToPrevTarget:\n targets = self.prev_targets[:, self.dof_joint_indices] + delta_action\n else:\n targets = self.dclaw_dof_pos + delta_action\n\n self.cur_targets[:, self.dof_joint_indices] = tensor_clamp(targets,\n self.dclaw_dof_lower_limits[\n self.dof_joint_indices],\n self.dclaw_dof_upper_limits[\n self.dof_joint_indices])\n\n self.prev_targets[:, self.dof_joint_indices] = self.cur_targets[:, self.dof_joint_indices]\n self.gym.set_dof_position_target_tensor(self.sim, gymtorch.unwrap_tensor(self.cur_targets))\n\n if self.force_scale > 0.0:\n self.rb_forces *= torch.pow(self.force_decay, self.dt / self.force_decay_interval)\n # apply new forces\n force_indices = (torch.rand(self.num_envs, device=self.device) < self.random_force_prob).nonzero()\n rb_force_shape = self.rb_forces[force_indices, self.object_rb_handles, :].shape\n rb_force_dir = torch.randn(rb_force_shape, device=self.device)\n rb_force_dir = rb_force_dir / rb_force_dir.norm(dim=-1, keepdim=True)\n self.rb_forces[force_indices, self.object_rb_handles, :] = rb_force_dir * self.object_rb_masses[force_indices] * self.force_scale\n self.gym.apply_rigid_body_force_tensors(self.sim, gymtorch.unwrap_tensor(self.rb_forces), None,\n gymapi.LOCAL_SPACE)\n\n def post_physics_step(self):\n self.progress_buf += 1\n self.randomize_buf += 1\n\n self.compute_observations()\n self.compute_reward(self.actions)\n\n if self.viewer and self.debug_viz:\n # draw axes on target object\n self.gym.clear_lines(self.viewer)\n self.gym.refresh_rigid_body_state_tensor(self.sim)\n\n for i in range(self.num_envs):\n targetx = (self.goal_pos[i] + quat_apply(self.goal_rot[i],\n to_torch([1, 0, 0], device=self.device) * 0.2)).cpu().numpy()\n targety = (self.goal_pos[i] + quat_apply(self.goal_rot[i],\n to_torch([0, 1, 0], device=self.device) * 0.2)).cpu().numpy()\n targetz = (self.goal_pos[i] + quat_apply(self.goal_rot[i],\n to_torch([0, 0, 1], device=self.device) * 0.2)).cpu().numpy()\n\n p0 = self.goal_pos[i].cpu().numpy() + self.goal_displacement_tensor.cpu().numpy()\n self.gym.add_lines(self.viewer, self.envs[i], 1,\n [p0[0], p0[1], p0[2], targetx[0], targetx[1], targetx[2]], [0.85, 0.1, 0.1])\n self.gym.add_lines(self.viewer, self.envs[i], 1,\n [p0[0], p0[1], p0[2], targety[0], targety[1], targety[2]], [0.1, 0.85, 0.1])\n self.gym.add_lines(self.viewer, self.envs[i], 1,\n [p0[0], p0[1], p0[2], targetz[0], targetz[1], targetz[2]], [0.1, 0.1, 0.85])\n\n objectx = (self.object_pos[i] + quat_apply(self.object_rot[i],\n to_torch([1, 0, 0], device=self.device) * 0.2)).cpu().numpy()\n objecty = (self.object_pos[i] + quat_apply(self.object_rot[i],\n to_torch([0, 1, 0], device=self.device) * 0.2)).cpu().numpy()\n objectz = (self.object_pos[i] + quat_apply(self.object_rot[i],\n to_torch([0, 0, 1], device=self.device) * 0.2)).cpu().numpy()\n\n p0 = self.object_pos[i].cpu().numpy()\n self.gym.add_lines(self.viewer, self.envs[i], 1,\n [p0[0], p0[1], p0[2], objectx[0], objectx[1], objectx[2]], [0.85, 0.1, 0.1])\n self.gym.add_lines(self.viewer, self.envs[i], 1,\n [p0[0], p0[1], p0[2], objecty[0], objecty[1], objecty[2]], [0.1, 0.85, 0.1])\n self.gym.add_lines(self.viewer, self.envs[i], 1,\n [p0[0], p0[1], p0[2], objectz[0], objectz[1], objectz[2]], [0.1, 0.1, 0.85])"},{"identifier":"chunker_list","path":"dexenv/utils/common.py","snippet":"def chunker_list(seq_list, nchunks):\n # split the list into n parts/chunks\n return [seq_list[i::nchunks] for i in range(nchunks)]"},{"identifier":"get_all_files_with_name","path":"dexenv/utils/common.py","snippet":"def get_all_files_with_name(directory, name,\n exclude_patterns=None,\n include_patterns=None,\n sort=True,\n ):\n directory = pathlib_file(directory)\n files = directory.glob(f'**/{name}')\n files = [x for x in files if x.is_file() and x.name == name]\n if exclude_patterns is not None:\n files = filter_with_exclude_patterns(files, exclude_patterns)\n if include_patterns is not None:\n files = filter_with_include_patterns(files, include_patterns)\n if sort:\n files = sorted(files)\n return files"},{"identifier":"load_from_pickle","path":"dexenv/utils/common.py","snippet":"def load_from_pickle(file_name):\n file_name = pathlib_file(file_name)\n with file_name.open('rb') as f:\n data = pkl.load(f)\n return data"},{"identifier":"load_a_goal_object_asset","path":"dexenv/utils/isaac_utils.py","snippet":"@torch.no_grad()\ndef load_a_goal_object_asset(gym, sim, asset_root, object_urdf, asset_options=None, vhacd=True):\n if asset_options is None:\n asset_options = gymapi.AssetOptions()\n if vhacd:\n asset_options.convex_decomposition_from_submeshes = True\n asset_options.thickness = 0.001\n asset_options.disable_gravity = True\n asset_options.override_inertia = True\n # asset_options.override_com = True\n\n rela_file = object_urdf.relative_to(asset_root).as_posix()\n obj_asset = gym.load_asset(sim,\n asset_root.as_posix(),\n rela_file,\n asset_options)\n return obj_asset"},{"identifier":"load_an_object_asset","path":"dexenv/utils/isaac_utils.py","snippet":"@torch.no_grad()\ndef load_an_object_asset(gym, sim, asset_root, object_urdf, asset_options=None, vhacd=True):\n if asset_options is None:\n asset_options = gymapi.AssetOptions()\n asset_options.thickness = 0.001\n asset_options.override_inertia = True\n # asset_options.override_com = True\n if vhacd:\n asset_options.convex_decomposition_from_submeshes = True\n rela_file = object_urdf.relative_to(asset_root).as_posix()\n obj_asset = gym.load_asset(sim,\n asset_root.as_posix(),\n rela_file,\n asset_options)\n return obj_asset"},{"identifier":"load_obj_texture","path":"dexenv/utils/isaac_utils.py","snippet":"@torch.no_grad()\ndef load_obj_texture(gym, sim, object_urdf):\n texture_files = get_all_files_with_suffix(object_urdf.parent, 'png')\n num_textures = len(texture_files)\n if num_textures > 1:\n logger.warning(f'Multiple image files exist, will use the first image as the texture!')\n elif num_textures == 0:\n raise RuntimeError(f'No texture file is found!')\n texture_file = texture_files[0]\n texture_handle = gym.create_texture_from_file(sim,\n texture_file.as_posix(),\n )\n return texture_handle"}],"string":"[\n {\n \"identifier\": \"DClawBase\",\n \"path\": \"dexenv/envs/dclaw_base.py\",\n \"snippet\": \"class DClawBase(VecTask):\\n\\n def __init__(self, cfg, sim_device, rl_device, graphics_device_id):\\n\\n self.cfg = cfg\\n headless = self.cfg.headless\\n self.randomize = self.cfg[\\\"task\\\"][\\\"randomize\\\"]\\n if self.randomize:\\n logger.warning(f'Domain randomization is enabled!')\\n self.randomization_params = self.cfg[\\\"task\\\"][\\\"randomization_params\\\"]\\n self.aggregate_mode = self.cfg[\\\"env\\\"][\\\"aggregateMode\\\"]\\n\\n self.dist_reward_scale = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"distRewardScale\\\"]\\n self.rot_reward_scale = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"rotRewardScale\\\"]\\n self.success_tolerance = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"successTolerance\\\"]\\n self.reach_goal_bonus = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"reachGoalBonus\\\"]\\n self.fall_dist = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"fallDistance\\\"]\\n self.fall_penalty = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"fallPenalty\\\"]\\n self.rot_eps = self.cfg[\\\"env\\\"][\\\"rew\\\"][\\\"rotEps\\\"]\\n\\n self.vel_obs_scale = 0.2 # scale factor of velocity based observations\\n self.force_torque_obs_scale = 10.0 # scale factor of velocity based observations\\n\\n self.reset_position_noise = self.cfg[\\\"env\\\"][\\\"resetPositionNoise\\\"]\\n self.reset_rotation_noise = self.cfg[\\\"env\\\"][\\\"resetRotationNoise\\\"]\\n self.reset_dof_pos_noise = self.cfg[\\\"env\\\"][\\\"resetDofPosRandomInterval\\\"]\\n self.reset_dof_vel_noise = self.cfg[\\\"env\\\"][\\\"resetDofVelRandomInterval\\\"]\\n\\n self.force_scale = self.cfg[\\\"env\\\"].get(\\\"forceScale\\\", 0.0)\\n self.force_prob_range = self.cfg[\\\"env\\\"].get(\\\"forceProbRange\\\", [0.001, 0.1])\\n self.force_decay = self.cfg[\\\"env\\\"].get(\\\"forceDecay\\\", 0.99)\\n self.force_decay_interval = self.cfg[\\\"env\\\"].get(\\\"forceDecayInterval\\\", 0.08)\\n\\n self.dclaw_dof_speed_scale = self.cfg[\\\"env\\\"][\\\"dofSpeedScale\\\"]\\n # self.act_moving_average = self.cfg[\\\"env\\\"][\\\"actionsMovingAverage\\\"]\\n\\n self.debug_viz = self.cfg[\\\"env\\\"][\\\"enableDebugVis\\\"]\\n\\n self.max_episode_length = self.cfg[\\\"env\\\"][\\\"episodeLength\\\"]\\n self.reset_time = self.cfg[\\\"env\\\"].get(\\\"resetTime\\\", -1.0)\\n self.print_success_stat = self.cfg[\\\"env\\\"][\\\"printNumSuccesses\\\"]\\n self.max_consecutive_successes = self.cfg[\\\"env\\\"][\\\"maxConsecutiveSuccesses\\\"]\\n self.av_factor = self.cfg[\\\"env\\\"].get(\\\"averFactor\\\", 0.1)\\n\\n self.object_type = self.cfg[\\\"env\\\"][\\\"objectType\\\"]\\n\\n self.asset_files_dict = {\\n \\\"block\\\": \\\"urdf/objects/cube_multicolor.urdf\\\",\\n \\\"egg\\\": \\\"mjcf/open_ai_assets/hand/egg.xml\\\",\\n \\\"airplane\\\": \\\"single_objects/airplane/model.urdf\\\",\\n 'power_drill': 'single_objects/power_drill/model.urdf',\\n 'mug': 'single_objects/mug/model.urdf',\\n 'elephant': 'asymm/train/elephant/var_000/model.urdf',\\n 'train': 'asymm/train/train/var_000/model.urdf',\\n 'stanford_bunny': 'asymm/train/stanford_bunny/var_004/model.urdf'\\n\\n }\\n self.objs_in_isaacgym = ['block', 'egg']\\n\\n if \\\"asset\\\" in self.cfg[\\\"env\\\"]:\\n self.asset_files_dict[\\\"block\\\"] = self.cfg[\\\"env\\\"][\\\"asset\\\"].get(\\\"assetFileNameBlock\\\",\\n self.asset_files_dict[\\\"block\\\"])\\n self.asset_files_dict[\\\"egg\\\"] = self.cfg[\\\"env\\\"][\\\"asset\\\"].get(\\\"assetFileNameEgg\\\",\\n self.asset_files_dict[\\\"egg\\\"])\\n\\n self.obs_type = self.cfg[\\\"env\\\"][\\\"observationType\\\"]\\n\\n if not (self.obs_type in [\\\"full_no_vel\\\", \\\"full\\\", \\\"full_state\\\"]):\\n raise Exception(\\n \\\"Unknown type of observations!\\\\nobservationType should be one of: [openai, full_no_vel, full, full_state]\\\")\\n\\n print(\\\"Obs type:\\\", self.obs_type)\\n\\n ## TODO: change value here\\n self.num_obs_dict = {\\n \\\"full_no_vel\\\": 42,\\n \\\"full\\\": 87,\\n \\\"full_state\\\": 114\\n }\\n\\n self.up_axis = 'z'\\n\\n num_states = 0\\n\\n self.cfg[\\\"env\\\"][\\\"numObservations\\\"] = self.num_obs_dict[self.obs_type]\\n self.cfg[\\\"env\\\"][\\\"numStates\\\"] = num_states\\n self.cfg[\\\"env\\\"][\\\"numActions\\\"] = 12\\n self.hist_buf_reset_env_ids = None\\n\\n super().__init__(config=self.cfg,\\n sim_device=sim_device,\\n rl_device=rl_device,\\n graphics_device_id=graphics_device_id,\\n headless=headless)\\n\\n self.dt = self.sim_params.dt\\n control_freq_inv = self.cfg[\\\"env\\\"].get(\\\"controlFrequencyInv\\\", 1)\\n if self.reset_time > 0.0:\\n self.max_episode_length = int(round(self.reset_time / (control_freq_inv * self.dt)))\\n print(\\\"Reset time: \\\", self.reset_time)\\n print(\\\"New episode length: \\\", self.max_episode_length)\\n\\n if self.viewer != None:\\n cam_pos = gymapi.Vec3(0.16, -0.5, 0.5)\\n cam_target = gymapi.Vec3(0.0, 0.0, 0.15)\\n self.gym.viewer_camera_look_at(self.viewer, None, cam_pos, cam_target)\\n\\n actor_root_state_tensor = self.gym.acquire_actor_root_state_tensor(self.sim)\\n dof_state_tensor = self.gym.acquire_dof_state_tensor(self.sim)\\n rigid_body_tensor = self.gym.acquire_rigid_body_state_tensor(self.sim)\\n dof_force_tensor = self.gym.acquire_dof_force_tensor(self.sim)\\n\\n if self.obs_type == \\\"full_state\\\":\\n sensor_tensor = self.gym.acquire_force_sensor_tensor(self.sim)\\n self.vec_sensor_tensor = gymtorch.wrap_tensor(sensor_tensor).view(self.num_envs, self.num_fingertips * 6)\\n\\n dof_force_tensor = self.gym.acquire_dof_force_tensor(self.sim)\\n self.dof_force_tensor = gymtorch.wrap_tensor(dof_force_tensor).view(self.num_envs,\\n self.num_dclaw_dofs)\\n\\n self.gym.refresh_actor_root_state_tensor(self.sim)\\n self.gym.refresh_dof_state_tensor(self.sim)\\n if self.cfg.env.dof_torque_on:\\n self.gym.refresh_dof_force_tensor(self.sim)\\n self.gym.refresh_rigid_body_state_tensor(self.sim)\\n\\n self.dof_state = gymtorch.wrap_tensor(dof_state_tensor)\\n self.dclaw_dof_state = self.dof_state.view(self.num_envs, -1, 2)[:, :self.num_dclaw_dofs]\\n self.dclaw_dof_pos = self.dclaw_dof_state[..., 0]\\n self.dclaw_dof_vel = self.dclaw_dof_state[..., 1]\\n if self.cfg.env.dof_torque_on:\\n self.dclaw_dof_torque = gymtorch.wrap_tensor(dof_force_tensor).view(self.num_envs, -1)\\n else:\\n self.dclaw_dof_torque = None\\n\\n self.rigid_body_states = gymtorch.wrap_tensor(rigid_body_tensor).view(self.num_envs, -1, 13)\\n self.num_bodies = self.rigid_body_states.shape[1]\\n\\n self.root_state_tensor = gymtorch.wrap_tensor(actor_root_state_tensor).view(-1, 13)\\n\\n if self.cfg.env.rew.pen_tb_contact:\\n _net_cf = self.gym.acquire_net_contact_force_tensor(self.sim)\\n self.net_contact_force = gymtorch.wrap_tensor(_net_cf).view(self.num_envs, -1, 3)\\n table_handle = self.gym.find_actor_handle(self.envs[0], 'table')\\n self.table_body_index = self.gym.find_actor_rigid_body_index(self.envs[0],\\n table_handle,\\n 'table',\\n gymapi.DOMAIN_ENV)\\n logger.warning(f'Table body index:{self.table_body_index}')\\n self.table_contact_force = self.net_contact_force[:, self.table_body_index]\\n\\n self.num_dofs = self.gym.get_sim_dof_count(self.sim) // self.num_envs\\n self.prev_targets = torch.zeros((self.num_envs, self.num_dofs), dtype=torch.float, device=self.device)\\n self.cur_targets = torch.zeros((self.num_envs, self.num_dofs), dtype=torch.float, device=self.device)\\n\\n self.global_indices = torch.arange(self.num_envs * 3, dtype=torch.int32, device=self.device).view(self.num_envs, -1)\\n\\n self.reset_goal_buf = self.reset_buf.clone()\\n self.successes = torch.zeros(self.num_envs, dtype=torch.float, device=self.device)\\n self.consecutive_successes = torch.zeros(1, dtype=torch.float, device=self.device)\\n\\n self.av_factor = to_torch(self.av_factor, dtype=torch.float, device=self.device)\\n\\n self.total_successes = 0\\n self.total_resets = 0\\n\\n self.force_decay = to_torch(self.force_decay, dtype=torch.float, device=self.device)\\n self.force_prob_range = to_torch(self.force_prob_range, dtype=torch.float, device=self.device)\\n self.random_force_prob = torch.exp((torch.log(self.force_prob_range[0]) - torch.log(self.force_prob_range[1]))\\n * torch.rand(self.num_envs, device=self.device) + torch.log(\\n self.force_prob_range[1]))\\n\\n self.rb_forces = torch.zeros((self.num_envs, self.num_bodies, 3), dtype=torch.float, device=self.device)\\n\\n self.num_actions = self.num_dclaw_dofs\\n self.actions = self.zero_actions()\\n DClawBase.compute_observations(self)\\n self.num_observations = self.obs_buf.shape[-1]\\n self.cfg.env.numObservations = self.num_observations\\n self.create_ob_act_space()\\n\\n def create_sim(self):\\n self.dt = self.cfg[\\\"sim\\\"][\\\"dt\\\"]\\n self.up_axis_idx = self.set_sim_params_up_axis(self.sim_params, self.up_axis)\\n\\n self.sim = super().create_sim(self.device_id, self.graphics_device_id, self.physics_engine, self.sim_params)\\n self._create_ground_plane()\\n self._create_envs(self.num_envs, self.cfg[\\\"env\\\"]['envSpacing'], int(np.sqrt(self.num_envs)))\\n\\n if self.randomize:\\n self.apply_randomizations(self.randomization_params)\\n\\n def _create_ground_plane(self):\\n plane_params = gymapi.PlaneParams()\\n plane_params.normal = gymapi.Vec3(0.0, 0.0, 1.0)\\n plane_params.distance = 0.1\\n self.gym.add_ground(self.sim, plane_params)\\n\\n def _create_envs(self, num_envs, spacing, num_per_row):\\n lower = gymapi.Vec3(-spacing, -spacing, 0.0)\\n upper = gymapi.Vec3(spacing, spacing, spacing)\\n\\n asset_root = dexenv.LIB_PATH.joinpath('assets', 'dclaw').as_posix()\\n object_asset_file = self.asset_files_dict[self.object_type]\\n\\n dclaw_asset, dclaw_dof_props = self.get_dclaw_asset(asset_root=asset_root)\\n table_asset = self.get_table_asset()\\n table_pose = self.get_table_pose()\\n\\n if self.obs_type == \\\"full_state\\\":\\n sensor_pose = gymapi.Transform()\\n for ft_handle in self.fingertip_handles:\\n self.gym.create_asset_force_sensor(dclaw_asset, ft_handle, sensor_pose)\\n\\n if self.object_type in self.objs_in_isaacgym:\\n asset_root = get_module_path('isaacgymenvs').parent.joinpath('assets').as_posix()\\n else:\\n asset_root = dexenv.LIB_PATH.joinpath('assets').as_posix()\\n\\n object_asset_options = gymapi.AssetOptions()\\n if self.cfg.env.vhacd:\\n object_asset_options.convex_decomposition_from_submeshes = True\\n\\n object_asset = self.gym.load_asset(self.sim, asset_root, object_asset_file, object_asset_options)\\n\\n object_asset_options.disable_gravity = True\\n goal_asset = self.gym.load_asset(self.sim, asset_root, object_asset_file, object_asset_options)\\n\\n dclaw_start_pose = self.get_dclaw_start_pose()\\n object_start_pose = self.get_object_start_pose(dclaw_start_pose)\\n\\n goal_start_pose = self.get_goal_object_start_pose(object_start_pose=object_start_pose)\\n\\n self.dclaws = []\\n self.envs = []\\n\\n self.object_init_state = []\\n self.hand_start_states = []\\n\\n self.hand_indices = []\\n self.fingertip_indices = []\\n self.object_indices = []\\n self.goal_object_indices = []\\n\\n self.render_camera_handles = []\\n if self.cfg.rgb_render:\\n render_cam_pose, render_cam_params = self.get_visual_render_camera_setup()\\n\\n self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in\\n self.fingertips]\\n print(f'Fingertip handles:{self.fingertip_handles}')\\n\\n dclaw_rb_count = self.gym.get_asset_rigid_body_count(dclaw_asset)\\n object_rb_count = self.gym.get_asset_rigid_body_count(object_asset)\\n object_rs_count = self.gym.get_asset_rigid_shape_count(object_asset)\\n self.object_rb_handles = list(range(dclaw_rb_count, dclaw_rb_count + object_rb_count))\\n self.object_handles = []\\n\\n max_agg_bodies = self.num_dclaw_bodies + 2 * object_rb_count + 1\\n max_agg_shapes = self.num_dclaw_shapes + 2 * object_rs_count + 1\\n\\n for i in range(self.num_envs):\\n env_ptr = self.gym.create_env(\\n self.sim, lower, upper, num_per_row\\n )\\n\\n if self.aggregate_mode >= 1:\\n self.gym.begin_aggregate(env_ptr, max_agg_bodies, max_agg_shapes, True)\\n\\n self.create_hand_actor(env_ptr=env_ptr,\\n dclaw_asset=dclaw_asset,\\n dclaw_start_pose=dclaw_start_pose,\\n dclaw_dof_props=dclaw_dof_props,\\n env_id=i)\\n\\n object_handle = self.gym.create_actor(env_ptr, object_asset, object_start_pose, \\\"object\\\", i, 0, 1)\\n self.object_handles.append(object_handle)\\n self.object_init_state.append([object_start_pose.p.x, object_start_pose.p.y, object_start_pose.p.z,\\n object_start_pose.r.x, object_start_pose.r.y, object_start_pose.r.z,\\n object_start_pose.r.w,\\n 0, 0, 0, 0, 0, 0])\\n object_idx = self.gym.get_actor_index(env_ptr, object_handle, gymapi.DOMAIN_SIM)\\n self.object_indices.append(object_idx)\\n\\n goal_handle = self.gym.create_actor(env_ptr, goal_asset, goal_start_pose, \\\"goal_object\\\", i + self.num_envs,\\n 0, 2)\\n goal_object_idx = self.gym.get_actor_index(env_ptr, goal_handle, gymapi.DOMAIN_SIM)\\n self.goal_object_indices.append(goal_object_idx)\\n\\n if self.cfg.env.blockscale is not None and self.cfg.env.objectType == 'block':\\n blockscale = float(self.cfg.env.blockscale)\\n self.gym.set_actor_scale(env_ptr, object_handle, blockscale)\\n self.gym.set_actor_scale(env_ptr, goal_handle, blockscale)\\n\\n if self.object_type != \\\"block\\\":\\n self.gym.set_rigid_body_color(\\n env_ptr, object_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(0.6, 0.72, 0.98))\\n self.gym.set_rigid_body_color(\\n env_ptr, goal_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(0.6, 0.72, 0.98))\\n table_handle = self.gym.create_actor(env_ptr, table_asset, table_pose, \\\"table\\\", i, 0)\\n\\n if self.cfg.rgb_render:\\n render_camera_handle = self.create_camera(render_cam_pose, env_ptr, render_cam_params)\\n self.render_camera_handles.append(render_camera_handle[0])\\n\\n if self.aggregate_mode > 0:\\n self.gym.end_aggregate(env_ptr)\\n\\n self.envs.append(env_ptr)\\n\\n self.setup_torch_states()\\n\\n def create_camera(self, camera_poses, env_ptr, camera_params):\\n cam_handles = []\\n for ic in range(min(len(camera_poses), self.cfg.cam.cam_num)):\\n camera_handle = self.gym.create_camera_sensor(env_ptr, camera_params)\\n if isinstance(camera_poses[ic], tuple):\\n self.gym.set_camera_location(camera_handle, env_ptr, camera_poses[ic][0], camera_poses[ic][1])\\n else:\\n self.gym.set_camera_transform(camera_handle, env_ptr, camera_poses[ic])\\n cam_handles.append(camera_handle)\\n return cam_handles\\n\\n def get_visual_render_camera_setup(self):\\n cam_pos = np.array([-0.7, 0, 0.5])\\n cam_focus_pt = np.array([0.08, 0, 0.15])\\n cam_focus_pt = gymapi.Vec3(*cam_focus_pt)\\n cam_pos = gymapi.Vec3(*cam_pos)\\n camera_poses = [(cam_pos, cam_focus_pt)]\\n camera_params = get_camera_params(width=self.cfg.cam.visual_render_width,\\n height=self.cfg.cam.visual_render_height,\\n hov=45,\\n cuda=False)\\n return camera_poses, camera_params\\n\\n def create_hand_actor(self, env_ptr, dclaw_asset, dclaw_start_pose, dclaw_dof_props, env_id):\\n dclaw_actor = self.gym.create_actor(env_ptr, dclaw_asset, dclaw_start_pose, \\\"hand\\\", env_id, 0, 0)\\n if self.cfg.env.dof_torque_on:\\n self.gym.enable_actor_dof_force_sensors(env_ptr, dclaw_actor)\\n self.hand_start_states.append(\\n [dclaw_start_pose.p.x, dclaw_start_pose.p.y, dclaw_start_pose.p.z,\\n dclaw_start_pose.r.x, dclaw_start_pose.r.y, dclaw_start_pose.r.z,\\n dclaw_start_pose.r.w,\\n 0, 0, 0, 0, 0, 0])\\n self.gym.set_actor_dof_properties(env_ptr, dclaw_actor, dclaw_dof_props)\\n hand_idx = self.gym.get_actor_index(env_ptr, dclaw_actor, gymapi.DOMAIN_SIM)\\n self.hand_indices.append(hand_idx)\\n\\n self.gym.set_actor_dof_states(env_ptr, dclaw_actor, self.dclaw_default_dof_states, gymapi.STATE_ALL)\\n if self.obs_type == \\\"full_state\\\":\\n self.gym.enable_actor_dof_force_sensors(env_ptr, dclaw_actor)\\n self.dclaws.append(dclaw_actor)\\n self.set_hand_color(env_ptr, dclaw_actor)\\n\\n def set_hand_color(self, env_ptr, dclaw_actor):\\n rgd_dict = self.gym.get_actor_rigid_body_dict(env_ptr, dclaw_actor)\\n for bd, bd_id in rgd_dict.items():\\n if bd not in dclaw_body_color_mapping:\\n continue\\n color = gymapi.Vec3(*dclaw_body_color_mapping[bd])\\n self.gym.set_rigid_body_color(env_ptr, dclaw_actor,\\n bd_id, gymapi.MESH_VISUAL,\\n color)\\n\\n def get_table_asset(self):\\n asset_options = gymapi.AssetOptions()\\n asset_options.armature = 0.001\\n asset_options.fix_base_link = True\\n asset_options.thickness = 0.001\\n asset_options.disable_gravity = True\\n table_dims = gymapi.Vec3(0.6, 0.6, 0.1)\\n table_asset = self.gym.create_box(self.sim,\\n table_dims.x,\\n table_dims.y,\\n table_dims.z,\\n asset_options)\\n table_props = self.gym.get_asset_rigid_shape_properties(table_asset)\\n for p in table_props:\\n p.friction = self.cfg.env.table.friction\\n p.torsion_friction = self.cfg.env.table.torsion_friction\\n p.restitution = self.cfg.env.table.restitution\\n p.rolling_friction = self.cfg.env.table.rolling_friction\\n self.gym.set_asset_rigid_shape_properties(table_asset, table_props)\\n return table_asset\\n\\n def get_table_pose(self):\\n object_start_pose = gymapi.Transform()\\n object_start_pose.p = gymapi.Vec3()\\n object_start_pose.p.x = 0\\n object_start_pose.p.y = 0\\n object_start_pose.p.z = -0.05\\n return object_start_pose\\n\\n def get_dclaw_start_pose(self):\\n dclaw_start_pose = gymapi.Transform()\\n dclaw_start_pose.p = gymapi.Vec3(*get_axis_params(0.25, self.up_axis_idx))\\n dclaw_start_pose.r = gymapi.Quat.from_axis_angle(gymapi.Vec3(0, 1, 0), np.pi)\\n return dclaw_start_pose\\n\\n def setup_torch_states(self):\\n self.render_rgb_obs_buf = None\\n if self.cfg.rgb_render:\\n self.gym.set_light_parameters(self.sim, 0, gymapi.Vec3(0.9, 0.9, 0.9),\\n gymapi.Vec3(0.9, 0.9, 0.9), gymapi.Vec3(0, 0, 0))\\n else:\\n self.gym.set_light_parameters(self.sim, 0, gymapi.Vec3(0.9, 0.9, 0.9),\\n gymapi.Vec3(0.7, 0.7, 0.7), gymapi.Vec3(0, 0, 0))\\n self.object_init_state = to_torch(self.object_init_state, device=self.device, dtype=torch.float).view(\\n self.num_envs, 13)\\n self.goal_states = self.object_init_state.clone()\\n self.goal_states[:, self.up_axis_idx] -= 0.04\\n self.goal_init_state = self.goal_states.clone()\\n self.hand_start_states = to_torch(self.hand_start_states, device=self.device).view(self.num_envs, 13)\\n\\n self.fingertip_handles = to_torch(self.fingertip_handles, dtype=torch.long, device=self.device)\\n self.object_rb_handles = to_torch(self.object_rb_handles, dtype=torch.long, device=self.device)\\n self.object_rb_masses = None\\n self.update_obj_mass()\\n self.hand_indices = to_torch(self.hand_indices, dtype=torch.long, device=self.device)\\n self.object_indices = to_torch(self.object_indices, dtype=torch.long, device=self.device)\\n self.goal_object_indices = to_torch(self.goal_object_indices, dtype=torch.long, device=self.device)\\n\\n def get_dclaw_asset(self, asset_root=None, asset_options=None):\\n # load dclaw asset\\n if asset_options is None:\\n asset_options = gymapi.AssetOptions()\\n asset_options.flip_visual_attachments = False\\n asset_options.fix_base_link = True\\n asset_options.collapse_fixed_joints = False\\n asset_options.disable_gravity = False\\n asset_options.thickness = 0.001\\n asset_options.angular_damping = 0.01\\n asset_options.override_inertia = True\\n asset_options.override_com = True\\n logger.info(f'VHACD:{self.cfg.env.vhacd}')\\n if self.cfg.env.vhacd:\\n asset_options.convex_decomposition_from_submeshes = True\\n if self.cfg.physics_engine == \\\"physx\\\":\\n # if self.physics_engine == gymapi.SIM_PHYSX:\\n asset_options.use_physx_armature = True\\n asset_options.default_dof_drive_mode = gymapi.DOF_MODE_POS\\n\\n if asset_root is None:\\n asset_root = dexenv.LIB_PATH.joinpath('assets', 'dclaw_4f').as_posix()\\n robot_name = self.cfg.env.robot\\n asset_root = pathlib_file(asset_root).parent.joinpath(f'{robot_name}').as_posix()\\n dclaw_asset = self.gym.load_asset(self.sim, asset_root, f\\\"{robot_name}.urdf\\\", asset_options)\\n print(f'Dclaw asset root:{asset_root} robot name:{robot_name}')\\n\\n self.num_dclaw_bodies = self.gym.get_asset_rigid_body_count(dclaw_asset)\\n self.num_dclaw_shapes = self.gym.get_asset_rigid_shape_count(dclaw_asset)\\n self.num_dclaw_dofs = self.gym.get_asset_dof_count(dclaw_asset)\\n\\n print(f'D-Claw:')\\n print(f'\\\\t Number of bodies: {self.num_dclaw_bodies}')\\n print(f'\\\\t Number of shapes: {self.num_dclaw_shapes}')\\n print(f'\\\\t Number of dofs: {self.num_dclaw_dofs}')\\n\\n self.dclaw_asset_dof_dict = self.gym.get_asset_dof_dict(dclaw_asset)\\n joint_names = self.dclaw_asset_dof_dict.keys()\\n logger.info(f'Joint names:{joint_names}')\\n\\n self.dof_joint_indices = list(self.dclaw_asset_dof_dict.values())\\n dinds = np.array(self.dof_joint_indices)\\n assert np.all(np.diff(dinds) > 0) # check if it's in a sorted order (ascending)\\n\\n rb_links = self.gym.get_asset_rigid_body_names(dclaw_asset)\\n self.fingertips = [x for x in rb_links if 'tip_link' in x] # [\\\"one_tip_link\\\", \\\"two_tip_link\\\", \\\"three_tip_link\\\"]\\n self.num_fingertips = len(self.fingertips)\\n\\n print(f'Number of fingertips:{self.num_fingertips} Fingertips:{self.fingertips}')\\n\\n print(f'Actuator --- DoF Index')\\n for act_name, act_index in zip(joint_names, self.dof_joint_indices):\\n print(f'\\\\t {act_name} {act_index}')\\n\\n dclaw_dof_props = self.gym.get_asset_dof_properties(dclaw_asset)\\n\\n def set_dof_prop(props, prop_name, val):\\n if np.isscalar(val):\\n props[prop_name].fill(val)\\n elif len(val) == 3:\\n props[prop_name] = np.array(list(val) * int(len(props[prop_name]) / 3))\\n else:\\n props[prop_name] = np.array(val)\\n\\n if self.cfg[\\\"env\\\"][\\\"dof_vel_hard_limit\\\"] is not None:\\n vel_hard_limit = self.cfg[\\\"env\\\"][\\\"dof_vel_hard_limit\\\"] if not self.cfg.env.soft_control else self.cfg[\\\"env\\\"][\\\"soft_dof_vel_hard_limit\\\"]\\n print(f'Setting DOF velocity limit to:{vel_hard_limit}')\\n set_dof_prop(dclaw_dof_props, 'velocity', vel_hard_limit)\\n if self.cfg[\\\"env\\\"][\\\"effort_limit\\\"] is not None:\\n effort_limit = self.cfg[\\\"env\\\"][\\\"effort_limit\\\"] if not self.cfg.env.soft_control else self.cfg[\\\"env\\\"][\\\"soft_effort_limit\\\"]\\n print(f'Setting DOF effort limit to:{effort_limit}')\\n set_dof_prop(dclaw_dof_props, 'effort', effort_limit)\\n if self.cfg[\\\"env\\\"][\\\"stiffness\\\"] is not None:\\n stiffness = self.cfg[\\\"env\\\"][\\\"stiffness\\\"] if not self.cfg.env.soft_control else self.cfg[\\\"env\\\"][\\\"soft_stiffness\\\"]\\n print(f'Setting stiffness to:{stiffness}')\\n set_dof_prop(dclaw_dof_props, 'stiffness', stiffness)\\n if self.cfg[\\\"env\\\"][\\\"damping\\\"] is not None:\\n damping = self.cfg[\\\"env\\\"][\\\"damping\\\"] if not self.cfg.env.soft_control else self.cfg[\\\"env\\\"][\\\"soft_damping\\\"]\\n print(f'Setting damping to:{damping}')\\n set_dof_prop(dclaw_dof_props, 'damping', damping)\\n\\n self.dclaw_dof_lower_limits = []\\n self.dclaw_dof_upper_limits = []\\n\\n self.dclaw_default_dof_states = np.zeros(self.num_dclaw_dofs, dtype=gymapi.DofState.dtype)\\n self.dclaw_default_dof_pos = self.dclaw_default_dof_states['pos']\\n self.dclaw_default_dof_vel = self.dclaw_default_dof_states['vel']\\n for i in range(self.num_dclaw_dofs):\\n self.dclaw_dof_lower_limits.append(dclaw_dof_props['lower'][i])\\n self.dclaw_dof_upper_limits.append(dclaw_dof_props['upper'][i])\\n if i % 3 == 1:\\n self.dclaw_default_dof_pos[i] = 0.8\\n elif i % 3 == 2:\\n self.dclaw_default_dof_pos[i] = -1.1\\n else:\\n self.dclaw_default_dof_pos[i] = 0.\\n self.dclaw_default_dof_vel[i] = 0.0\\n\\n self.dof_joint_indices = to_torch(self.dof_joint_indices, dtype=torch.long, device=self.device)\\n self.dclaw_dof_lower_limits = to_torch(self.dclaw_dof_lower_limits, device=self.device)\\n self.dclaw_dof_upper_limits = to_torch(self.dclaw_dof_upper_limits, device=self.device)\\n self.dclaw_default_dof_pos = to_torch(self.dclaw_default_dof_pos, device=self.device)\\n self.dclaw_default_dof_vel = to_torch(self.dclaw_default_dof_vel, device=self.device)\\n\\n self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in\\n self.fingertips]\\n\\n dclaw_asset_props = self.gym.get_asset_rigid_shape_properties(dclaw_asset)\\n for p in dclaw_asset_props:\\n p.friction = self.cfg.env.hand.friction\\n p.torsion_friction = self.cfg.env.hand.torsion_friction\\n p.rolling_friction = self.cfg.env.hand.rolling_friction\\n p.restitution = self.cfg.env.hand.restitution\\n self.gym.set_asset_rigid_shape_properties(dclaw_asset, dclaw_asset_props)\\n return dclaw_asset, dclaw_dof_props\\n\\n def get_object_start_pose(self, dclaw_start_pose):\\n object_start_pose = gymapi.Transform()\\n object_start_pose.p = gymapi.Vec3()\\n if self.cfg.env.obj_init_delta_pos is not None:\\n delta_pos = self.cfg.env.obj_init_delta_pos\\n object_start_pose.p.x = dclaw_start_pose.p.x + delta_pos[0]\\n object_start_pose.p.y = dclaw_start_pose.p.y + delta_pos[1]\\n object_start_pose.p.z = dclaw_start_pose.p.z + delta_pos[2]\\n else:\\n object_start_pose.p.x = dclaw_start_pose.p.x\\n pose_dy, pose_dz = 0., -0.13\\n object_start_pose.p.y = dclaw_start_pose.p.y + pose_dy\\n object_start_pose.p.z = dclaw_start_pose.p.z + pose_dz\\n return object_start_pose\\n\\n def get_goal_object_start_pose(self, object_start_pose):\\n self.goal_displacement = gymapi.Vec3(0., 0, 0.25)\\n self.goal_displacement_tensor = to_torch(\\n [self.goal_displacement.x, self.goal_displacement.y, self.goal_displacement.z], device=self.device)\\n goal_start_pose = gymapi.Transform()\\n goal_start_pose.p = object_start_pose.p + self.goal_displacement\\n return goal_start_pose\\n\\n def set_dof_props(self, props_dict):\\n param_setters_map = get_property_setter_map(self.gym)\\n param_getters_map = get_property_getter_map(self.gym)\\n prop_name = 'dof_properties'\\n setter = param_setters_map[prop_name]\\n for env_id in range(len(self.envs)):\\n env = self.envs[env_id]\\n handle = self.gym.find_actor_handle(env, 'hand')\\n prop = param_getters_map[prop_name](env, handle)\\n for dof_prop_name, dof_prop_values in props_dict.items():\\n if env_id == 0:\\n assert len(dof_prop_values) == len(self.envs)\\n prop_val = dof_prop_values[env_id]\\n prop[dof_prop_name].fill(prop_val)\\n success = setter(env, handle, prop)\\n if not success:\\n logger.warning(f'Setting dof properties is not successful!')\\n\\n def update_obj_mass(self, env_ids=None):\\n object_rb_masses = []\\n env_pool = env_ids if env_ids is not None else list(range(self.num_envs))\\n if len(env_pool) < 1:\\n return\\n for env_id, object_handle in zip(env_pool, self.object_handles):\\n env_ptr = self.envs[env_id]\\n object_rb_props = self.gym.get_actor_rigid_body_properties(env_ptr, object_handle)\\n object_rb_masses.append([prop.mass for prop in object_rb_props])\\n if self.object_rb_masses is None:\\n self.object_rb_masses = to_torch(object_rb_masses, dtype=torch.float, device=self.device)\\n else:\\n self.object_rb_masses[env_pool] = to_torch(object_rb_masses, dtype=torch.float, device=self.device)\\n\\n def reset(self) -> torch.Tensor:\\n \\\"\\\"\\\"Reset the environment.\\n Returns:\\n Observation dictionary\\n \\\"\\\"\\\"\\n zero_actions = self.zero_actions()\\n self.reset_buf.fill_(1)\\n self.reset_goal_buf.fill_(1)\\n if self.cfg.env.action_ema is not None:\\n self.action_ema_val = zero_actions.clone()\\n # step the simulator\\n\\n self.step(zero_actions)\\n\\n return self.update_obs()\\n\\n def compute_reward(self, actions):\\n res = compute_dclaw_reward(\\n self.reset_buf, self.reset_goal_buf, self.progress_buf,\\n self.successes, self.max_episode_length,\\n self.object_pos, self.object_rot, self.goal_pos, self.goal_rot,\\n self.cfg['env']['rew'], self.actions,\\n self.fingertip_pos, self.fingertip_vel, self.object_linvel, self.object_angvel,\\n self.dclaw_dof_vel, self.dclaw_dof_torque,\\n table_cf=self.table_contact_force if self.cfg.env.rew.pen_tb_contact else None\\n )\\n self.rew_buf[:] = res[0] * self.cfg.env.rew.rew_scale\\n self.done_buf[:] = res[1]\\n self.reset_buf[:] = res[2]\\n self.reset_goal_buf[:] = res[3]\\n self.progress_buf[:] = res[4]\\n self.successes[:] = res[5]\\n abs_rot_dist = res[6]\\n reward_terms = res[7]\\n timeout_envs = res[8]\\n\\n self.extras['success'] = self.reset_goal_buf.detach().to(self.rl_device).flatten()\\n self.extras['abs_dist'] = abs_rot_dist.detach().to(self.rl_device)\\n self.extras['TimeLimit.truncated'] = timeout_envs.detach().to(self.rl_device)\\n for reward_key, reward_val in reward_terms.items():\\n self.extras[reward_key] = reward_val.detach()\\n\\n def get_images(self):\\n rgb = self.render_rgb_obs_buf\\n return rgb\\n\\n def compute_observations(self):\\n self.gym.refresh_dof_state_tensor(self.sim)\\n if self.cfg.env.dof_torque_on:\\n self.gym.refresh_dof_force_tensor(self.sim)\\n self.gym.refresh_actor_root_state_tensor(self.sim)\\n self.gym.refresh_rigid_body_state_tensor(self.sim)\\n\\n if self.obs_type == \\\"full_state\\\":\\n self.gym.refresh_force_sensor_tensor(self.sim)\\n self.gym.refresh_dof_force_tensor(self.sim)\\n\\n if self.cfg.env.rew.pen_tb_contact:\\n self.gym.refresh_net_contact_force_tensor(self.sim)\\n\\n self.object_pose = self.root_state_tensor[self.object_indices, 0:7]\\n self.object_pos = self.root_state_tensor[self.object_indices, 0:3]\\n self.object_rot = self.root_state_tensor[self.object_indices, 3:7]\\n self.object_linvel = self.root_state_tensor[self.object_indices, 7:10]\\n self.object_angvel = self.root_state_tensor[self.object_indices, 10:13]\\n\\n self.goal_pose = self.goal_states[:, 0:7]\\n self.goal_pos = self.goal_states[:, 0:3]\\n self.goal_rot = self.goal_states[:, 3:7]\\n\\n self.fingertip_state = self.rigid_body_states[:, self.fingertip_handles][:, :, 0:13]\\n self.fingertip_pos = self.rigid_body_states[:, self.fingertip_handles][:, :, 0:3]\\n self.fingertip_vel = self.rigid_body_states[:, self.fingertip_handles][:, :, 7:13]\\n\\n if self.obs_type == \\\"full_no_vel\\\":\\n obs_buf = self.compute_full_observations(no_vel=True)\\n elif self.obs_type == \\\"full\\\":\\n obs_buf = self.compute_full_observations()\\n elif self.obs_type == \\\"full_state\\\":\\n obs_buf = self.compute_full_state()\\n else:\\n print(\\\"Unkown observations type!\\\")\\n self.obs_buf = obs_buf\\n\\n if self.cfg.rgb_render:\\n self.gym.fetch_results(self.sim, True)\\n self.gym.step_graphics(self.sim)\\n self.gym.render_all_camera_sensors(self.sim)\\n self.gym.start_access_image_tensors(self.sim)\\n self.render_rgb_obs_buf = self.get_numpy_rgb_images(self.render_camera_handles)\\n self.gym.end_access_image_tensors(self.sim)\\n\\n def allocate_ob_buffers(self):\\n self.obs_buf = torch.zeros(\\n (self.num_envs, self.num_obs), device=self.device, dtype=torch.float)\\n\\n def compute_full_observations(self, no_vel=False):\\n scaled_dof_pos = unscale(\\n self.dclaw_dof_pos,\\n self.dclaw_dof_lower_limits,\\n self.dclaw_dof_upper_limits\\n )\\n quat_dist = quat_mul(self.object_rot, quat_conjugate(self.goal_rot))\\n\\n if no_vel:\\n out = torch.cat(\\n [\\n scaled_dof_pos,\\n self.object_pose,\\n self.goal_rot,\\n quat_dist,\\n self.fingertip_pos.reshape(self.num_envs, 3 * self.num_fingertips),\\n self.actions\\n ],\\n dim=-1\\n )\\n else:\\n out = torch.cat(\\n [\\n scaled_dof_pos,\\n self.vel_obs_scale * self.dclaw_dof_vel,\\n self.object_pose,\\n self.object_linvel,\\n self.vel_obs_scale * self.object_angvel,\\n self.goal_rot,\\n quat_dist,\\n self.fingertip_state.reshape(self.num_envs, 13 * self.num_fingertips),\\n self.actions\\n ],\\n dim=-1\\n )\\n return out\\n\\n def compute_full_state(self):\\n obs_buf = self.compute_full_observations()\\n obs_no_actions = obs_buf[:, :-9]\\n actions = obs_buf[:, -9:]\\n out = torch.cat(\\n [\\n obs_no_actions,\\n self.force_torque_obs_scale * self.dof_force_tensor,\\n self.force_torque_obs_scale * self.vec_sensor_tensor,\\n actions\\n ],\\n dim=-1\\n )\\n\\n return out\\n\\n def update_obs(self):\\n if self.randomize:\\n self.obs_buf = self.dr_randomizations['observations']['noise_lambda'](self.obs_buf)\\n\\n self.obs_dict[\\\"ob\\\"] = torch.clamp(self.obs_buf, -self.clip_obs, self.clip_obs).to(self.rl_device)\\n if self.num_states > 0:\\n self.obs_dict[\\\"state\\\"] = self.get_state()\\n return self.obs_dict\\n\\n def reset_target_pose(self, env_ids, apply_reset=False):\\n new_rot = random_quaternions(num=len(env_ids), device=self.device, order='xyzw')\\n\\n self.goal_states[env_ids, 0:3] = self.goal_init_state[env_ids, 0:3]\\n self.goal_states[env_ids, 3:7] = new_rot\\n self.root_state_tensor[self.goal_object_indices[env_ids], 0:3] = self.goal_states[env_ids, 0:3] + self.goal_displacement_tensor\\n self.root_state_tensor[self.goal_object_indices[env_ids], 3:7] = self.goal_states[env_ids, 3:7]\\n self.root_state_tensor[self.goal_object_indices[env_ids], 7:13] = torch.zeros_like(\\n self.root_state_tensor[self.goal_object_indices[env_ids], 7:13])\\n\\n if apply_reset:\\n goal_object_indices = self.goal_object_indices[env_ids].to(torch.int32)\\n self.gym.set_actor_root_state_tensor_indexed(self.sim,\\n gymtorch.unwrap_tensor(self.root_state_tensor),\\n gymtorch.unwrap_tensor(goal_object_indices), len(env_ids))\\n self.reset_goal_buf[env_ids] = 0\\n\\n def reset_idx(self, env_ids, goal_env_ids):\\n if self.randomize and not self.cfg.env.rand_once:\\n self.apply_randomizations(self.randomization_params)\\n\\n rand_floats = torch_rand_float(-1.0, 1.0, (len(env_ids), self.num_dclaw_dofs * 2 + 3), device=self.device)\\n\\n self.reset_target_pose(env_ids)\\n self.rb_forces[env_ids, :, :] = 0.0\\n\\n self.root_state_tensor[self.object_indices[env_ids]] = self.object_init_state[env_ids].clone()\\n self.root_state_tensor[self.object_indices[env_ids], 0:3] = self.object_init_state[env_ids, 0:3] + \\\\\\n self.reset_position_noise * rand_floats[:, 0:3]\\n\\n new_object_rot = random_quaternions(num=len(env_ids), device=self.device, order='xyzw')\\n\\n self.root_state_tensor[self.object_indices[env_ids], 3:7] = new_object_rot\\n self.root_state_tensor[self.object_indices[env_ids], 7:13] = torch.zeros_like(\\n self.root_state_tensor[self.object_indices[env_ids], 7:13])\\n\\n object_indices = torch.unique(torch.cat([self.object_indices[env_ids],\\n self.goal_object_indices[env_ids],\\n self.goal_object_indices[goal_env_ids]]).to(torch.int32))\\n self.gym.set_actor_root_state_tensor_indexed(self.sim,\\n gymtorch.unwrap_tensor(self.root_state_tensor),\\n gymtorch.unwrap_tensor(object_indices), len(object_indices))\\n self.random_force_prob[env_ids] = torch.exp(\\n (torch.log(self.force_prob_range[0]) - torch.log(self.force_prob_range[1]))\\n * torch.rand(len(env_ids), device=self.device) + torch.log(self.force_prob_range[1]))\\n\\n delta_max = self.dclaw_dof_upper_limits - self.dclaw_default_dof_pos\\n delta_min = self.dclaw_dof_lower_limits - self.dclaw_default_dof_pos\\n rand_delta = delta_min + (delta_max - delta_min) * rand_floats[:, 3:3 + self.num_dclaw_dofs]\\n\\n pos = self.dclaw_default_dof_pos + self.reset_dof_pos_noise * rand_delta\\n self.dclaw_dof_pos[env_ids, :] = pos\\n self.dclaw_dof_vel[env_ids, :] = self.dclaw_default_dof_vel + \\\\\\n self.reset_dof_vel_noise * rand_floats[:,\\n 3 + self.num_dclaw_dofs:3 + self.num_dclaw_dofs * 2]\\n self.prev_targets[env_ids, :self.num_dclaw_dofs] = pos\\n self.cur_targets[env_ids, :self.num_dclaw_dofs] = pos\\n\\n hand_indices = self.hand_indices[env_ids].to(torch.int32)\\n self.gym.set_dof_position_target_tensor_indexed(self.sim,\\n gymtorch.unwrap_tensor(self.prev_targets),\\n gymtorch.unwrap_tensor(hand_indices), len(env_ids))\\n self.gym.set_dof_state_tensor_indexed(self.sim,\\n gymtorch.unwrap_tensor(self.dof_state),\\n gymtorch.unwrap_tensor(hand_indices), len(env_ids))\\n\\n self.progress_buf[env_ids] = 0\\n self.reset_buf[env_ids] = 0\\n self.successes[env_ids] = 0\\n\\n def get_numpy_rgb_images(self, camera_handles):\\n rgb_obs_buf = []\\n for cam_handles, env in zip(camera_handles, self.envs):\\n cam_ob = []\\n if isinstance(cam_handles, list):\\n for cam_handle in cam_handles:\\n color_image = self.gym.get_camera_image(self.sim, env, cam_handle, gymapi.IMAGE_COLOR)\\n color_image = color_image.reshape(color_image.shape[0], -1, 4)[..., :3]\\n cam_ob.append(color_image)\\n rgb_obs_buf.append(cam_ob)\\n else:\\n color_image = self.gym.get_camera_image(self.sim, env, cam_handles, gymapi.IMAGE_COLOR)\\n color_image = color_image.reshape(color_image.shape[0], -1, 4)[..., :3]\\n rgb_obs_buf.append(color_image)\\n rgb_obs_buf = np.stack(rgb_obs_buf)\\n return rgb_obs_buf\\n\\n def pre_physics_step(self, actions):\\n env_ids = self.reset_buf.nonzero(as_tuple=False).squeeze(-1)\\n goal_env_ids = self.reset_goal_buf.nonzero(as_tuple=False).squeeze(-1)\\n\\n if len(goal_env_ids) > 0 and len(env_ids) == 0:\\n self.reset_target_pose(goal_env_ids, apply_reset=True)\\n elif len(goal_env_ids) > 0:\\n self.reset_target_pose(goal_env_ids)\\n\\n if len(env_ids) > 0:\\n self.reset_idx(env_ids, goal_env_ids)\\n\\n self.actions = actions.clone().to(self.device)\\n\\n if self.cfg.env.action_ema is not None:\\n self.action_ema_val[env_ids] = 0\\n self.action_ema_val[goal_env_ids] = 0\\n self.actions = self.actions * self.cfg.env.action_ema + self.action_ema_val * (1 - self.cfg.env.action_ema)\\n self.action_ema_val = self.actions.clone()\\n if self.cfg.env.dof_vel_pol_limit is not None:\\n delta_action = self.actions * self.cfg.env.dof_vel_pol_limit * (self.dt * self.cfg.env.controlFrequencyInv)\\n else:\\n delta_action = self.dclaw_dof_speed_scale * self.dt * self.actions\\n if self.cfg.env.relativeToPrevTarget:\\n targets = self.prev_targets[:, self.dof_joint_indices] + delta_action\\n else:\\n targets = self.dclaw_dof_pos + delta_action\\n\\n self.cur_targets[:, self.dof_joint_indices] = tensor_clamp(targets,\\n self.dclaw_dof_lower_limits[\\n self.dof_joint_indices],\\n self.dclaw_dof_upper_limits[\\n self.dof_joint_indices])\\n\\n self.prev_targets[:, self.dof_joint_indices] = self.cur_targets[:, self.dof_joint_indices]\\n self.gym.set_dof_position_target_tensor(self.sim, gymtorch.unwrap_tensor(self.cur_targets))\\n\\n if self.force_scale > 0.0:\\n self.rb_forces *= torch.pow(self.force_decay, self.dt / self.force_decay_interval)\\n # apply new forces\\n force_indices = (torch.rand(self.num_envs, device=self.device) < self.random_force_prob).nonzero()\\n rb_force_shape = self.rb_forces[force_indices, self.object_rb_handles, :].shape\\n rb_force_dir = torch.randn(rb_force_shape, device=self.device)\\n rb_force_dir = rb_force_dir / rb_force_dir.norm(dim=-1, keepdim=True)\\n self.rb_forces[force_indices, self.object_rb_handles, :] = rb_force_dir * self.object_rb_masses[force_indices] * self.force_scale\\n self.gym.apply_rigid_body_force_tensors(self.sim, gymtorch.unwrap_tensor(self.rb_forces), None,\\n gymapi.LOCAL_SPACE)\\n\\n def post_physics_step(self):\\n self.progress_buf += 1\\n self.randomize_buf += 1\\n\\n self.compute_observations()\\n self.compute_reward(self.actions)\\n\\n if self.viewer and self.debug_viz:\\n # draw axes on target object\\n self.gym.clear_lines(self.viewer)\\n self.gym.refresh_rigid_body_state_tensor(self.sim)\\n\\n for i in range(self.num_envs):\\n targetx = (self.goal_pos[i] + quat_apply(self.goal_rot[i],\\n to_torch([1, 0, 0], device=self.device) * 0.2)).cpu().numpy()\\n targety = (self.goal_pos[i] + quat_apply(self.goal_rot[i],\\n to_torch([0, 1, 0], device=self.device) * 0.2)).cpu().numpy()\\n targetz = (self.goal_pos[i] + quat_apply(self.goal_rot[i],\\n to_torch([0, 0, 1], device=self.device) * 0.2)).cpu().numpy()\\n\\n p0 = self.goal_pos[i].cpu().numpy() + self.goal_displacement_tensor.cpu().numpy()\\n self.gym.add_lines(self.viewer, self.envs[i], 1,\\n [p0[0], p0[1], p0[2], targetx[0], targetx[1], targetx[2]], [0.85, 0.1, 0.1])\\n self.gym.add_lines(self.viewer, self.envs[i], 1,\\n [p0[0], p0[1], p0[2], targety[0], targety[1], targety[2]], [0.1, 0.85, 0.1])\\n self.gym.add_lines(self.viewer, self.envs[i], 1,\\n [p0[0], p0[1], p0[2], targetz[0], targetz[1], targetz[2]], [0.1, 0.1, 0.85])\\n\\n objectx = (self.object_pos[i] + quat_apply(self.object_rot[i],\\n to_torch([1, 0, 0], device=self.device) * 0.2)).cpu().numpy()\\n objecty = (self.object_pos[i] + quat_apply(self.object_rot[i],\\n to_torch([0, 1, 0], device=self.device) * 0.2)).cpu().numpy()\\n objectz = (self.object_pos[i] + quat_apply(self.object_rot[i],\\n to_torch([0, 0, 1], device=self.device) * 0.2)).cpu().numpy()\\n\\n p0 = self.object_pos[i].cpu().numpy()\\n self.gym.add_lines(self.viewer, self.envs[i], 1,\\n [p0[0], p0[1], p0[2], objectx[0], objectx[1], objectx[2]], [0.85, 0.1, 0.1])\\n self.gym.add_lines(self.viewer, self.envs[i], 1,\\n [p0[0], p0[1], p0[2], objecty[0], objecty[1], objecty[2]], [0.1, 0.85, 0.1])\\n self.gym.add_lines(self.viewer, self.envs[i], 1,\\n [p0[0], p0[1], p0[2], objectz[0], objectz[1], objectz[2]], [0.1, 0.1, 0.85])\"\n },\n {\n \"identifier\": \"chunker_list\",\n \"path\": \"dexenv/utils/common.py\",\n \"snippet\": \"def chunker_list(seq_list, nchunks):\\n # split the list into n parts/chunks\\n return [seq_list[i::nchunks] for i in range(nchunks)]\"\n },\n {\n \"identifier\": \"get_all_files_with_name\",\n \"path\": \"dexenv/utils/common.py\",\n \"snippet\": \"def get_all_files_with_name(directory, name,\\n exclude_patterns=None,\\n include_patterns=None,\\n sort=True,\\n ):\\n directory = pathlib_file(directory)\\n files = directory.glob(f'**/{name}')\\n files = [x for x in files if x.is_file() and x.name == name]\\n if exclude_patterns is not None:\\n files = filter_with_exclude_patterns(files, exclude_patterns)\\n if include_patterns is not None:\\n files = filter_with_include_patterns(files, include_patterns)\\n if sort:\\n files = sorted(files)\\n return files\"\n },\n {\n \"identifier\": \"load_from_pickle\",\n \"path\": \"dexenv/utils/common.py\",\n \"snippet\": \"def load_from_pickle(file_name):\\n file_name = pathlib_file(file_name)\\n with file_name.open('rb') as f:\\n data = pkl.load(f)\\n return data\"\n },\n {\n \"identifier\": \"load_a_goal_object_asset\",\n \"path\": \"dexenv/utils/isaac_utils.py\",\n \"snippet\": \"@torch.no_grad()\\ndef load_a_goal_object_asset(gym, sim, asset_root, object_urdf, asset_options=None, vhacd=True):\\n if asset_options is None:\\n asset_options = gymapi.AssetOptions()\\n if vhacd:\\n asset_options.convex_decomposition_from_submeshes = True\\n asset_options.thickness = 0.001\\n asset_options.disable_gravity = True\\n asset_options.override_inertia = True\\n # asset_options.override_com = True\\n\\n rela_file = object_urdf.relative_to(asset_root).as_posix()\\n obj_asset = gym.load_asset(sim,\\n asset_root.as_posix(),\\n rela_file,\\n asset_options)\\n return obj_asset\"\n },\n {\n \"identifier\": \"load_an_object_asset\",\n \"path\": \"dexenv/utils/isaac_utils.py\",\n \"snippet\": \"@torch.no_grad()\\ndef load_an_object_asset(gym, sim, asset_root, object_urdf, asset_options=None, vhacd=True):\\n if asset_options is None:\\n asset_options = gymapi.AssetOptions()\\n asset_options.thickness = 0.001\\n asset_options.override_inertia = True\\n # asset_options.override_com = True\\n if vhacd:\\n asset_options.convex_decomposition_from_submeshes = True\\n rela_file = object_urdf.relative_to(asset_root).as_posix()\\n obj_asset = gym.load_asset(sim,\\n asset_root.as_posix(),\\n rela_file,\\n asset_options)\\n return obj_asset\"\n },\n {\n \"identifier\": \"load_obj_texture\",\n \"path\": \"dexenv/utils/isaac_utils.py\",\n \"snippet\": \"@torch.no_grad()\\ndef load_obj_texture(gym, sim, object_urdf):\\n texture_files = get_all_files_with_suffix(object_urdf.parent, 'png')\\n num_textures = len(texture_files)\\n if num_textures > 1:\\n logger.warning(f'Multiple image files exist, will use the first image as the texture!')\\n elif num_textures == 0:\\n raise RuntimeError(f'No texture file is found!')\\n texture_file = texture_files[0]\\n texture_handle = gym.create_texture_from_file(sim,\\n texture_file.as_posix(),\\n )\\n return texture_handle\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import numpy as np\nimport torch\nimport dexenv\nfrom gym.utils import seeding\nfrom isaacgym import gymapi\nfrom loguru import logger\nfrom tqdm import tqdm\nfrom dexenv.envs.dclaw_base import DClawBase\nfrom dexenv.utils.common import chunker_list\nfrom dexenv.utils.common import get_all_files_with_name\nfrom dexenv.utils.common import load_from_pickle\nfrom dexenv.utils.isaac_utils import load_a_goal_object_asset\nfrom dexenv.utils.isaac_utils import load_an_object_asset\nfrom dexenv.utils.isaac_utils import load_obj_texture"},"token_num":{"kind":"number","value":14864,"string":"14,864"},"cropped_code":{"kind":"string","value":" self.gym.create_asset_force_sensor(dclaw_asset, ft_handle, sensor_pose)\n\n dclaw_start_pose = self.get_dclaw_start_pose()\n object_start_pose = self.get_object_start_pose(dclaw_start_pose)\n goal_start_pose = self.get_goal_object_start_pose(object_start_pose=object_start_pose)\n\n self.dclaws = []\n self.envs = []\n\n self.object_init_state = []\n self.hand_start_states = []\n\n self.hand_indices = []\n self.fingertip_indices = []\n self.object_indices = []\n self.object_cat_indices = []\n self.goal_object_indices = []\n\n self.render_camera_handles = []\n if self.cfg.rgb_render:\n render_cam_pose, render_cam_params = self.get_visual_render_camera_setup()\n\n self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in\n self.fingertips]\n\n dclaw_rb_count = self.gym.get_asset_rigid_body_count(dclaw_asset)\n object_rb_count = self.gym.get_asset_rigid_body_count(object_assets[0])\n\n self.object_rb_handles = list(range(dclaw_rb_count, dclaw_rb_count + object_rb_count))\n self.object_handles = []\n num_object_assets = len(object_assets)\n env_obj_ids = []\n for i in range(self.num_envs):\n # create env instance\n obj_asset_id = i % num_object_assets\n env_obj_ids.append(object_ids[obj_asset_id])\n env_ptr = self.gym.create_env(\n self.sim, lower, upper, num_per_row\n )\n\n if self.aggregate_mode >= 1:\n # compute aggregate size\n obj_num_bodies = self.gym.get_asset_rigid_body_count(object_assets[obj_asset_id])\n obj_num_shapes = self.gym.get_asset_rigid_shape_count(object_assets[obj_asset_id])\n max_agg_bodies = self.num_dclaw_bodies + obj_num_bodies * 2 + 1\n max_agg_shapes = self.num_dclaw_shapes + obj_num_shapes * 2 + 1\n self.gym.begin_aggregate(env_ptr, max_agg_bodies, max_agg_shapes, True)\n\n self.create_hand_actor(env_ptr=env_ptr,\n dclaw_asset=dclaw_asset,\n dclaw_start_pose=dclaw_start_pose,\n dclaw_dof_props=dclaw_dof_props,\n env_id=i)\n # add object\n object_handle = self.gym.create_actor(env_ptr, object_assets[obj_asset_id],\n object_start_pose, \"object\", i, 0, 1)\n self.object_handles.append(object_handle)\n self.object_init_state.append([object_start_pose.p.x, object_start_pose.p.y, object_start_pose.p.z,\n object_start_pose.r.x, object_start_pose.r.y, object_start_pose.r.z,\n object_start_pose.r.w,\n 0, 0, 0, 0, 0, 0])\n object_idx = self.gym.get_actor_index(env_ptr, object_handle, gymapi.DOMAIN_SIM)\n self.object_indices.append(object_idx)\n self.object_cat_indices.append(object_cat_ids[obj_asset_id])\n\n # add goal object\n goal_handle = self.gym.create_actor(env_ptr, goal_assets[obj_asset_id],\n goal_start_pose, \"goal_object\",\n i + self.num_envs,\n 0, 2)\n goal_object_idx = self.gym.get_actor_index(env_ptr, goal_handle, gymapi.DOMAIN_SIM)\n self.goal_object_indices.append(goal_object_idx)\n\n if self.cfg.obj.load_texture:\n self.gym.set_rigid_body_texture(env_ptr,\n object_handle,\n 0,\n gymapi.MESH_VISUAL_AND_COLLISION,\n object_textures[obj_asset_id]\n )\n self.gym.set_rigid_body_texture(env_ptr,\n goal_handle,\n 0,\n gymapi.MESH_VISUAL_AND_COLLISION,\n object_textures[obj_asset_id]\n )\n else:\n color = np.array([179, 193, 134]) / 255.0\n self.gym.set_rigid_body_color(\n env_ptr, object_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))\n self.gym.set_rigid_body_color(\n env_ptr, goal_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))\n table_handle = self.gym.create_actor(env_ptr, table_asset, table_pose, \"table\", i, 0)\n self.gym.set_rigid_body_color(env_ptr, table_handle, 0, gymapi.MESH_VISUAL,\n gymapi.Vec3(180 / 255., 180 / 255., 180 / 255.))\n\n if self.cfg.rgb_render:\n render_camera_handle = self.create_camera(render_cam_pose, env_ptr, render_cam_params)\n\n self.render_camera_handles.append(render_camera_handle[0])\n if self.aggregate_mode > 0:\n self.gym.end_aggregate(env_ptr)\n self.envs.append(env_ptr)\n\n object_rb_props = self.gym.get_actor_rigid_body_properties(env_ptr, object_handle)\n self.object_rb_masses = [prop.mass for prop in object_rb_props]\n self.setup_torch_states()\n self.env_obj_ids = torch.LongTensor(env_obj_ids).to(self.device).view(-1, 1)\n self.object_cat_indices = torch.LongTensor(self.object_cat_indices).to(self.device).view(-1, 1)\n\n def parse_obj_dataset(self, dataset):\n asset_root = dexenv.LIB_PATH.joinpath('assets')\n split_dataset_name = dataset.split(':')\n if len(split_dataset_name) == 1:\n dataset_path = asset_root.joinpath(dataset, 'train')\n else:\n target_object = split_dataset_name[1]\n dataset_path = asset_root.joinpath(split_dataset_name[0], 'train', target_object)\n\n logger.warning(f'Dataset path:{dataset_path}')\n"},"all_code":{"kind":"string","value":"\n\n\nclass DclawMultiObjs(DClawBase):\n def __init__(self, cfg, sim_device, rl_device, graphics_device_id):\n self.set_random_gen()\n self.object_urdfs, self.dataset_path, self.obj_name_to_cat_id = self.parse_obj_dataset(cfg.obj.dataset)\n self.num_objects = len(self.object_urdfs)\n logger.info(f'Object urdf root path:{self.dataset_path}.')\n logger.info(f'Number of available objects:{self.num_objects}.')\n super().__init__(cfg=cfg,\n sim_device=sim_device,\n rl_device=rl_device,\n graphics_device_id=graphics_device_id)\n\n def set_random_gen(self, seed=12345):\n self.np_random, seed = seeding.np_random(seed)\n\n def _create_envs(self, num_envs, spacing, num_per_row):\n lower = gymapi.Vec3(-spacing, -spacing, 0.0)\n upper = gymapi.Vec3(spacing, spacing, spacing)\n\n asset_root = dexenv.LIB_PATH.joinpath('assets', 'dclaw').as_posix()\n\n dclaw_asset, dclaw_dof_props = self.get_dclaw_asset(asset_root=asset_root)\n # load manipulated object and goal assets\n table_asset = self.get_table_asset()\n table_pose = self.get_table_pose()\n object_assets, goal_assets, object_ids, object_textures, object_ptds, object_cat_ids = self.load_object_asset()\n\n # create fingertip force sensors, if needed\n if self.obs_type == \"full_state\":\n sensor_pose = gymapi.Transform()\n for ft_handle in self.fingertip_handles:\n self.gym.create_asset_force_sensor(dclaw_asset, ft_handle, sensor_pose)\n\n dclaw_start_pose = self.get_dclaw_start_pose()\n object_start_pose = self.get_object_start_pose(dclaw_start_pose)\n goal_start_pose = self.get_goal_object_start_pose(object_start_pose=object_start_pose)\n\n self.dclaws = []\n self.envs = []\n\n self.object_init_state = []\n self.hand_start_states = []\n\n self.hand_indices = []\n self.fingertip_indices = []\n self.object_indices = []\n self.object_cat_indices = []\n self.goal_object_indices = []\n\n self.render_camera_handles = []\n if self.cfg.rgb_render:\n render_cam_pose, render_cam_params = self.get_visual_render_camera_setup()\n\n self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in\n self.fingertips]\n\n dclaw_rb_count = self.gym.get_asset_rigid_body_count(dclaw_asset)\n object_rb_count = self.gym.get_asset_rigid_body_count(object_assets[0])\n\n self.object_rb_handles = list(range(dclaw_rb_count, dclaw_rb_count + object_rb_count))\n self.object_handles = []\n num_object_assets = len(object_assets)\n env_obj_ids = []\n for i in range(self.num_envs):\n # create env instance\n obj_asset_id = i % num_object_assets\n env_obj_ids.append(object_ids[obj_asset_id])\n env_ptr = self.gym.create_env(\n self.sim, lower, upper, num_per_row\n )\n\n if self.aggregate_mode >= 1:\n # compute aggregate size\n obj_num_bodies = self.gym.get_asset_rigid_body_count(object_assets[obj_asset_id])\n obj_num_shapes = self.gym.get_asset_rigid_shape_count(object_assets[obj_asset_id])\n max_agg_bodies = self.num_dclaw_bodies + obj_num_bodies * 2 + 1\n max_agg_shapes = self.num_dclaw_shapes + obj_num_shapes * 2 + 1\n self.gym.begin_aggregate(env_ptr, max_agg_bodies, max_agg_shapes, True)\n\n self.create_hand_actor(env_ptr=env_ptr,\n dclaw_asset=dclaw_asset,\n dclaw_start_pose=dclaw_start_pose,\n dclaw_dof_props=dclaw_dof_props,\n env_id=i)\n # add object\n object_handle = self.gym.create_actor(env_ptr, object_assets[obj_asset_id],\n object_start_pose, \"object\", i, 0, 1)\n self.object_handles.append(object_handle)\n self.object_init_state.append([object_start_pose.p.x, object_start_pose.p.y, object_start_pose.p.z,\n object_start_pose.r.x, object_start_pose.r.y, object_start_pose.r.z,\n object_start_pose.r.w,\n 0, 0, 0, 0, 0, 0])\n object_idx = self.gym.get_actor_index(env_ptr, object_handle, gymapi.DOMAIN_SIM)\n self.object_indices.append(object_idx)\n self.object_cat_indices.append(object_cat_ids[obj_asset_id])\n\n # add goal object\n goal_handle = self.gym.create_actor(env_ptr, goal_assets[obj_asset_id],\n goal_start_pose, \"goal_object\",\n i + self.num_envs,\n 0, 2)\n goal_object_idx = self.gym.get_actor_index(env_ptr, goal_handle, gymapi.DOMAIN_SIM)\n self.goal_object_indices.append(goal_object_idx)\n\n if self.cfg.obj.load_texture:\n self.gym.set_rigid_body_texture(env_ptr,\n object_handle,\n 0,\n gymapi.MESH_VISUAL_AND_COLLISION,\n object_textures[obj_asset_id]\n )\n self.gym.set_rigid_body_texture(env_ptr,\n goal_handle,\n 0,\n gymapi.MESH_VISUAL_AND_COLLISION,\n object_textures[obj_asset_id]\n )\n else:\n color = np.array([179, 193, 134]) / 255.0\n self.gym.set_rigid_body_color(\n env_ptr, object_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))\n self.gym.set_rigid_body_color(\n env_ptr, goal_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))\n table_handle = self.gym.create_actor(env_ptr, table_asset, table_pose, \"table\", i, 0)\n self.gym.set_rigid_body_color(env_ptr, table_handle, 0, gymapi.MESH_VISUAL,\n gymapi.Vec3(180 / 255., 180 / 255., 180 / 255.))\n\n if self.cfg.rgb_render:\n render_camera_handle = self.create_camera(render_cam_pose, env_ptr, render_cam_params)\n\n self.render_camera_handles.append(render_camera_handle[0])\n if self.aggregate_mode > 0:\n self.gym.end_aggregate(env_ptr)\n self.envs.append(env_ptr)\n\n object_rb_props = self.gym.get_actor_rigid_body_properties(env_ptr, object_handle)\n self.object_rb_masses = [prop.mass for prop in object_rb_props]\n self.setup_torch_states()\n self.env_obj_ids = torch.LongTensor(env_obj_ids).to(self.device).view(-1, 1)\n self.object_cat_indices = torch.LongTensor(self.object_cat_indices).to(self.device).view(-1, 1)\n\n def parse_obj_dataset(self, dataset):\n asset_root = dexenv.LIB_PATH.joinpath('assets')\n split_dataset_name = dataset.split(':')\n if len(split_dataset_name) == 1:\n dataset_path = asset_root.joinpath(dataset, 'train')\n else:\n target_object = split_dataset_name[1]\n dataset_path = asset_root.joinpath(split_dataset_name[0], 'train', target_object)\n\n logger.warning(f'Dataset path:{dataset_path}')"},"next_line":{"kind":"string","value":" urdf_files = get_all_files_with_name(dataset_path, name='model.urdf')"},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-10-25 17:22:41+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5688,"cells":{"repo_name":{"kind":"string","value":"ai-safety-foundation/sparse_autoencoder"},"file_path":{"kind":"string","value":"sparse_autoencoder/activation_resampler/tests/test_activation_resampler.py"},"context":{"kind":"list like","value":[{"identifier":"ActivationResampler","path":"sparse_autoencoder/activation_resampler/activation_resampler.py","snippet":"class ActivationResampler:\n \"\"\"Activation resampler.\n\n Collates the number of times each neuron fires over a set number of learned activation vectors,\n and then provides the parameters necessary to reset any dead neurons.\n\n Motivation:\n Over the course of training, a subset of autoencoder neurons will have zero activity across\n a large number of datapoints. The authors of *Towards Monosemanticity: Decomposing Language\n Models With Dictionary Learning* found that “resampling” these dead neurons during training\n improves the number of likely-interpretable features (i.e., those in the high density\n cluster) and reduces total loss. This resampling may be compatible with the Lottery Ticket\n Hypothesis and increase the number of chances the network has to find promising feature\n directions.\n\n An interesting nuance around dead neurons involves the ultralow density cluster. They found\n that if we increase the number of training steps then networks will kill off more of these\n ultralow density neurons. This reinforces the use of the high density cluster as a useful\n metric because there can exist neurons that are de facto dead but will not appear to be when\n looking at the number of dead neurons alone.\n\n This approach is designed to seed new features to fit inputs where the current autoencoder\n performs worst. Resetting the encoder norm and bias are crucial to ensuring this resampled\n neuron will only fire weakly for inputs similar to the one used for its reinitialization.\n This was done to minimize interference with the rest of the network.\n\n Warning:\n The optimizer should be reset after applying this function, as the Adam state will be\n incorrect for the modified weights and biases.\n\n Warning:\n This approach is also known to create sudden loss spikes, and resampling too frequently\n causes training to diverge.\n \"\"\"\n\n _activations_seen_since_last_resample: int = 0\n \"\"\"Number of activations since we last resampled.\"\"\"\n\n _collated_neuron_activity: Float[Tensor, Axis.names(Axis.COMPONENT, Axis.LEARNT_FEATURE)]\n \"\"\"Collated neuron activity, over the current data collection window.\"\"\"\n\n _threshold_is_dead_portion_fires: float\n \"\"\"Threshold for determining if a neuron has fired (or is dead).\"\"\"\n\n _max_n_resamples: int\n \"\"\"Maximum number of times that resampling should be performed.\"\"\"\n\n _n_activations_collated_since_last_resample: int = 0\n \"\"\"Number of activations collated since we last resampled.\n\n Number of vectors used to collate neuron activity, over the current collation window.\n \"\"\"\n\n _n_components: int\n \"\"\"Number of components.\"\"\"\n\n _n_times_resampled: int = 0\n \"\"\"Number of times that resampling has been performed.\"\"\"\n\n neuron_activity_window_end: int\n \"\"\"End of the window for collecting neuron activity.\"\"\"\n\n neuron_activity_window_start: int\n \"\"\"Start of the window for collecting neuron activity.\"\"\"\n\n @validate_call\n def __init__(\n self,\n n_learned_features: PositiveInt,\n n_components: NonNegativeInt = 1,\n resample_interval: PositiveInt = 200_000_000,\n max_n_resamples: NonNegativeInt = 4,\n n_activations_activity_collate: PositiveInt = 100_000_000,\n resample_dataset_size: PositiveInt = 819_200,\n threshold_is_dead_portion_fires: Annotated[float, Field(strict=True, ge=0, le=1)] = 0.0,\n ) -> None:\n r\"\"\"Initialize the activation resampler.\n\n Defaults to values used in the Anthropic Towards Monosemanticity paper.\n\n Args:\n n_learned_features: Number of learned features\n n_components: Number of components that the SAE is being trained on.\n resample_interval: Interval in number of autoencoder input activation vectors trained\n on, before resampling.\n max_n_resamples: Maximum number of resamples to perform throughout the entire pipeline.\n Set to inf if you want to have no limit.\n n_activations_activity_collate: Number of autoencoder learned activation vectors to\n collate before resampling (the activation resampler will start collecting on vector\n $\\text{resample_interval} - \\text{n_steps_collate}$).\n resample_dataset_size: Number of autoencoder input activations to use for calculating\n the loss, as part of the resampling process to create the reset neuron weights.\n threshold_is_dead_portion_fires: Threshold for determining if a neuron is dead (has\n \"fired\" in less than this portion of the collated sample).\n\n Raises:\n ValueError: If any of the arguments are invalid (e.g. negative integers).\n \"\"\"\n if n_activations_activity_collate > resample_interval:\n error_message = (\n \"Number of steps to collate must be less than or equal to the resample interval.\"\n )\n raise ValueError(error_message)\n\n super().__init__()\n self.neuron_activity_window_end = resample_interval\n self.neuron_activity_window_start = resample_interval - n_activations_activity_collate\n self._max_n_resamples = max_n_resamples\n self._collated_neuron_activity = torch.zeros(\n (n_components, n_learned_features), dtype=torch.int64\n )\n self._resample_dataset_size = resample_dataset_size\n self._threshold_is_dead_portion_fires = threshold_is_dead_portion_fires\n self._n_components = n_components\n\n def _get_dead_neuron_indices(\n self,\n ) -> list[Int64[Tensor, Axis.names(Axis.LEARNT_FEATURE_IDX)]]:\n \"\"\"Identify the indices of neurons that are dead.\n\n Identifies any neurons that have fired less than the threshold portion of the collated\n sample size.\n\n Example:\n >>> resampler = ActivationResampler(n_learned_features=6, n_components=2)\n >>> resampler._collated_neuron_activity = torch.tensor(\n ... [[1, 1, 0, 0, 1, 1], [1, 1, 1, 1, 1, 0]]\n ... )\n >>> resampler._get_dead_neuron_indices()\n [tensor([2, 3]), tensor([5])]\n\n Returns:\n List of dead neuron indices for each component.\n\n Raises:\n ValueError: If no neuron activity has been collated yet.\n \"\"\"\n # Check we have already collated some neuron activity\n if torch.all(self._collated_neuron_activity == 0):\n error_message = \"Cannot get dead neuron indices without neuron activity.\"\n raise ValueError(error_message)\n\n # Find any neurons that fire less than the threshold portion of times\n threshold_is_dead_n_fires: int = int(\n self._n_activations_collated_since_last_resample * self._threshold_is_dead_portion_fires\n )\n\n return [\n torch.where(self._collated_neuron_activity[component_idx] <= threshold_is_dead_n_fires)[\n 0\n ].to(dtype=torch.int64)\n for component_idx in range(self._n_components)\n ]\n\n def compute_loss_and_get_activations(\n self,\n store: ActivationStore,\n autoencoder: SparseAutoencoder | DataParallel[SparseAutoencoder] | DeepSpeedEngine,\n loss_fn: AbstractLoss,\n train_batch_size: int,\n ) -> LossInputActivationsTuple:\n \"\"\"Compute the loss on a random subset of inputs.\n\n Motivation:\n Helps find input vectors that have high SAE loss, so that we can resample dead neurons\n in a way that improves performance on these specific input vectors.\n\n Args:\n store: Activation store.\n autoencoder: Sparse autoencoder model.\n loss_fn: Loss function.\n train_batch_size: Train batch size (also used for resampling).\n\n Returns:\n A tuple of loss per item, and all input activations.\n\n Raises:\n ValueError: If the number of items in the store is less than the number of inputs\n \"\"\"\n with torch.no_grad():\n loss_batches: list[Float[Tensor, Axis.BATCH]] = []\n input_activations_batches: list[\n Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)]\n ] = []\n dataloader = DataLoader(store, batch_size=train_batch_size)\n n_inputs = self._resample_dataset_size\n n_batches_required: int = n_inputs // train_batch_size\n model_device: torch.device = get_model_device(autoencoder)\n\n for batch_idx, batch in enumerate(iter(dataloader)):\n input_activations_batches.append(batch)\n source_activations = batch.to(model_device)\n learned_activations, reconstructed_activations = autoencoder(source_activations)\n loss_batches.append(\n loss_fn.forward(\n source_activations, learned_activations, reconstructed_activations\n )\n )\n if batch_idx >= n_batches_required:\n break\n\n loss_per_item = torch.cat(loss_batches).to(model_device)\n input_activations = torch.cat(input_activations_batches).to(model_device)\n\n # Check we generated enough data\n if len(loss_per_item) < n_inputs:\n error_message = (\n f\"Cannot get {n_inputs} items from the store, \"\n f\"as only {len(loss_per_item)} were available.\"\n )\n raise ValueError(error_message)\n\n return LossInputActivationsTuple(loss_per_item, input_activations)\n\n @staticmethod\n def assign_sampling_probabilities(\n loss: Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)],\n ) -> Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]:\n \"\"\"Assign the sampling probabilities for each input activations vector.\n\n Assign each input vector a probability of being picked that is proportional to the square of\n the autoencoder's loss on that input.\n\n Examples:\n >>> loss = torch.tensor([1.0, 2.0, 3.0])\n >>> ActivationResampler.assign_sampling_probabilities(loss).round(decimals=2)\n tensor([0.0700, 0.2900, 0.6400])\n\n >>> loss = torch.tensor([[1.0, 2], [2, 4], [3, 6]])\n >>> ActivationResampler.assign_sampling_probabilities(loss).round(decimals=2)\n tensor([[0.0700, 0.0700],\n [0.2900, 0.2900],\n [0.6400, 0.6400]])\n\n Args:\n loss: Loss per item.\n\n Returns:\n A tensor of probabilities for each item.\n \"\"\"\n square_loss = loss.pow(2)\n return square_loss / square_loss.sum(0)\n\n @staticmethod\n def sample_input(\n probabilities: Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)],\n input_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n n_samples: list[int],\n ) -> list[Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]]:\n \"\"\"Sample an input vector based on the provided probabilities.\n\n Example:\n >>> probabilities = torch.tensor([[0.1], [0.2], [0.7]])\n >>> input_activations = torch.tensor([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]])\n >>> _seed = torch.manual_seed(0) # For reproducibility in example\n >>> sampled_input = ActivationResampler.sample_input(\n ... probabilities, input_activations, [2]\n ... )\n >>> sampled_input[0].tolist()\n [[5.0, 6.0], [3.0, 4.0]]\n\n Args:\n probabilities: Probabilities for each input.\n input_activations: Input activation vectors.\n n_samples: Number of samples to take (number of dead neurons).\n\n Returns:\n Sampled input activation vector.\n\n Raises:\n ValueError: If the number of samples is greater than the number of input activations.\n \"\"\"\n sampled_inputs: list[\n Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]\n ] = []\n\n for component_idx, component_n_samples in enumerate(n_samples):\n component_probabilities: Float[Tensor, Axis.BATCH] = get_component_slice_tensor(\n input_tensor=probabilities,\n n_dim_with_component=2,\n component_dim=1,\n component_idx=component_idx,\n )\n\n component_input_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)\n ] = get_component_slice_tensor(\n input_tensor=input_activations,\n n_dim_with_component=3,\n component_dim=1,\n component_idx=component_idx,\n )\n\n if component_n_samples > len(component_input_activations):\n exception_message = (\n f\"Cannot sample {component_n_samples} inputs from \"\n f\"{len(component_input_activations)} input activations.\"\n )\n raise ValueError(exception_message)\n\n # Handle the 0 dead neurons case\n if component_n_samples == 0:\n sampled_inputs.append(\n torch.empty(\n (0, component_input_activations.shape[-1]),\n dtype=component_input_activations.dtype,\n device=component_input_activations.device,\n )\n )\n continue\n\n # Handle the 1+ dead neuron case\n component_sample_indices: Int64[Tensor, Axis.LEARNT_FEATURE_IDX] = torch.multinomial(\n component_probabilities, num_samples=component_n_samples\n )\n sampled_inputs.append(component_input_activations[component_sample_indices, :])\n\n return sampled_inputs\n\n @staticmethod\n def renormalize_and_scale(\n sampled_input: Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)],\n neuron_activity: Int64[Tensor, Axis.names(Axis.LEARNT_FEATURE)],\n encoder_weight: Float[Tensor, Axis.names(Axis.LEARNT_FEATURE, Axis.INPUT_OUTPUT_FEATURE)],\n ) -> Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]:\n \"\"\"Renormalize and scale the resampled dictionary vectors.\n\n Renormalize the input vector to equal the average norm of the encoder weights for alive\n neurons times 0.2.\n\n Example:\n >>> from torch.nn import Parameter\n >>> _seed = torch.manual_seed(0) # For reproducibility in example\n >>> sampled_input = torch.tensor([[3.0, 4.0]])\n >>> neuron_activity = torch.tensor([3, 0, 5, 0, 1, 3])\n >>> encoder_weight = Parameter(torch.ones((6, 2)))\n >>> rescaled_input = ActivationResampler.renormalize_and_scale(\n ... sampled_input,\n ... neuron_activity,\n ... encoder_weight\n ... )\n >>> rescaled_input.round(decimals=1)\n tensor([[0.2000, 0.2000]])\n\n Args:\n sampled_input: Tensor of the sampled input activation.\n neuron_activity: Tensor representing the number of times each neuron fired.\n encoder_weight: Tensor of encoder weights.\n\n Returns:\n Rescaled sampled input.\n\n Raises:\n ValueError: If there are no alive neurons.\n \"\"\"\n alive_neuron_mask: Bool[Tensor, \" learned_features\"] = neuron_activity > 0\n\n # Check there is at least one alive neuron\n if not torch.any(alive_neuron_mask):\n error_message = \"No alive neurons found.\"\n raise ValueError(error_message)\n\n # Handle no dead neurons\n n_dead_neurons = len(sampled_input)\n if n_dead_neurons == 0:\n return torch.empty(\n (0, sampled_input.shape[-1]), dtype=sampled_input.dtype, device=sampled_input.device\n )\n\n # Calculate the average norm of the encoder weights for alive neurons.\n detached_encoder_weight = encoder_weight.detach() # Don't track gradients\n alive_encoder_weights: Float[\n Tensor, Axis.names(Axis.ALIVE_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\n ] = detached_encoder_weight[alive_neuron_mask, :]\n average_alive_norm: Float[Tensor, Axis.SINGLE_ITEM] = alive_encoder_weights.norm(\n dim=-1\n ).mean()\n\n # Renormalize the input vector to equal the average norm of the encoder weights for alive\n # neurons times 0.2.\n renormalized_input: Float[\n Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\n ] = torch.nn.functional.normalize(sampled_input, dim=-1)\n return renormalized_input * (average_alive_norm * 0.2)\n\n def resample_dead_neurons(\n self,\n activation_store: ActivationStore,\n autoencoder: SparseAutoencoder | DataParallel[SparseAutoencoder] | DeepSpeedEngine,\n loss_fn: AbstractLoss,\n train_batch_size: int,\n ) -> list[ParameterUpdateResults]:\n \"\"\"Resample dead neurons.\n\n Args:\n activation_store: Activation store.\n autoencoder: Sparse autoencoder model.\n loss_fn: Loss function.\n train_batch_size: Train batch size (also used for resampling).\n\n Returns:\n For each component that the SAE is being trained on, the indices of dead neurons and the\n updates for the encoder and decoder weights and biases.\n \"\"\"\n parameter_update_results: list[ParameterUpdateResults] = []\n\n with torch.no_grad():\n dead_neuron_indices: list[\n Int64[Tensor, Axis.names(Axis.LEARNT_FEATURE_IDX)]\n ] = self._get_dead_neuron_indices()\n\n # Compute the loss for the current model on a random subset of inputs and get the\n # activations.\n loss_per_item, input_activations = self.compute_loss_and_get_activations(\n store=activation_store,\n autoencoder=autoencoder,\n loss_fn=loss_fn,\n train_batch_size=train_batch_size,\n )\n\n # Assign each input vector a probability of being picked that is proportional to the\n # square of the autoencoder's loss on that input.\n sample_probabilities: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)\n ] = self.assign_sampling_probabilities(loss_per_item)\n\n # For each dead neuron sample an input according to these probabilities.\n sampled_input: list[\n Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]\n ] = self.sample_input(\n sample_probabilities, input_activations, [len(dead) for dead in dead_neuron_indices]\n )\n\n for component_idx in range(self._n_components):\n # Renormalize each input vector to have unit L2 norm and set this to be the\n # dictionary vector for the dead autoencoder neuron.\n renormalized_input: Float[\n Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\n ] = torch.nn.functional.normalize(sampled_input[component_idx], dim=-1)\n\n dead_decoder_weight_updates = rearrange(\n renormalized_input, \"dead_neuron input_feature -> input_feature dead_neuron\"\n )\n\n # For the corresponding encoder vector, renormalize the input vector to equal the\n # average norm of the encoder weights for alive neurons times 0.2. Set the\n # corresponding encoder bias element to zero.\n encoder_weight: Float[\n Tensor, Axis.names(Axis.LEARNT_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\n ] = get_component_slice_tensor(autoencoder.encoder.weight, 3, 0, component_idx)\n\n rescaled_sampled_input = self.renormalize_and_scale(\n sampled_input=sampled_input[component_idx],\n neuron_activity=self._collated_neuron_activity[component_idx],\n encoder_weight=encoder_weight,\n )\n\n dead_encoder_bias_updates = torch.zeros_like(\n dead_neuron_indices[component_idx],\n dtype=dead_decoder_weight_updates.dtype,\n device=dead_decoder_weight_updates.device,\n )\n\n parameter_update_results.append(\n ParameterUpdateResults(\n dead_neuron_indices=dead_neuron_indices[component_idx],\n dead_encoder_weight_updates=rescaled_sampled_input,\n dead_encoder_bias_updates=dead_encoder_bias_updates,\n dead_decoder_weight_updates=dead_decoder_weight_updates,\n )\n )\n\n return parameter_update_results\n\n def step_resampler(\n self,\n batch_neuron_activity: Int64[Tensor, Axis.names(Axis.COMPONENT, Axis.LEARNT_FEATURE)],\n activation_store: ActivationStore,\n autoencoder: SparseAutoencoder | DataParallel[SparseAutoencoder] | DeepSpeedEngine,\n loss_fn: AbstractLoss,\n train_batch_size: int,\n ) -> list[ParameterUpdateResults] | None:\n \"\"\"Step the resampler, collating neuron activity and resampling if necessary.\n\n Args:\n batch_neuron_activity: Number of times each neuron fired in the current batch.\n activation_store: Activation store.\n autoencoder: Sparse autoencoder model.\n loss_fn: Loss function.\n train_batch_size: Train batch size (also used for resampling).\n\n Returns:\n Parameter update results (for each component that the SAE is being trained on) if\n resampling is due. Otherwise None.\n \"\"\"\n # Update the counter\n self._activations_seen_since_last_resample += len(activation_store)\n\n if self._n_times_resampled < self._max_n_resamples:\n # Collate neuron activity, if in the data collection window. For example in the\n # Anthropic Towards Monosemanticity paper, the window started collecting at 100m\n # activations and stopped at 200m (and then repeated this again a few times until the\n # max times to resample was hit).\n if self._activations_seen_since_last_resample >= self.neuron_activity_window_start:\n detached_neuron_activity = batch_neuron_activity.detach().cpu()\n self._collated_neuron_activity.add_(detached_neuron_activity)\n self._n_activations_collated_since_last_resample += train_batch_size\n\n # Check if we should resample.\n if self._activations_seen_since_last_resample >= self.neuron_activity_window_end:\n # Get resampled dictionary vectors\n resample_res = self.resample_dead_neurons(\n activation_store=activation_store,\n autoencoder=autoencoder,\n loss_fn=loss_fn,\n train_batch_size=train_batch_size,\n )\n\n # Update counters\n self._activations_seen_since_last_resample = 0\n self._n_activations_collated_since_last_resample = 0\n self._n_times_resampled += 1\n\n # Reset the collated neuron activity\n self._collated_neuron_activity.zero_()\n\n return resample_res\n\n return None\n\n def __str__(self) -> str:\n \"\"\"Return a string representation of the activation resampler.\"\"\"\n return (\n f\"ActivationResampler(\"\n f\"n_components={self._n_components}, \"\n f\"neuron_activity_window_start={self.neuron_activity_window_end}, \"\n f\"neuron_activity_window_end={self.neuron_activity_window_end}, \"\n f\"max_resamples={self._max_n_resamples}, \"\n f\"resample_dataset_size={self._resample_dataset_size}, \"\n f\"dead_neuron_threshold={self._threshold_is_dead_portion_fires})\"\n )"},{"identifier":"ActivationStore","path":"sparse_autoencoder/activation_store/base_store.py","snippet":"class ActivationStore(\n Dataset[Float[Tensor, Axis.names(Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)]], ABC\n):\n \"\"\"Activation Store Abstract Class.\n\n Extends the `torch.utils.data.Dataset` class to provide an activation store, with additional\n :meth:`append` and :meth:`extend` methods (the latter of which should typically be\n non-blocking). The resulting activation store can be used with a `torch.utils.data.DataLoader`\n to iterate over the dataset.\n\n Extend this class if you want to create a new activation store (noting you also need to create\n `__getitem__` and `__len__` methods from the underlying `torch.utils.data.Dataset` class).\n\n Example:\n >>> import torch\n >>> class MyActivationStore(ActivationStore):\n ...\n ... @property\n ... def current_activations_stored_per_component(self):\n ... raise NotImplementedError\n ...\n ... @property\n ... def n_components(self):\n ... raise NotImplementedError\n ...\n ... def __init__(self):\n ... super().__init__()\n ... self._data = [] # In this example, we just store in a list\n ...\n ... def append(self, item) -> None:\n ... self._data.append(item)\n ...\n ... def extend(self, batch):\n ... self._data.extend(batch)\n ...\n ... def empty(self):\n ... self._data = []\n ...\n ... def __getitem__(self, index: int):\n ... return self._data[index]\n ...\n ... def __len__(self) -> int:\n ... return len(self._data)\n ...\n >>> store = MyActivationStore()\n >>> store.append(torch.randn(100))\n >>> print(len(store))\n 1\n \"\"\"\n\n @abstractmethod\n def append(\n self,\n item: Float[Tensor, Axis.names(Axis.INPUT_OUTPUT_FEATURE)],\n component_idx: int,\n ) -> Future | None:\n \"\"\"Add a Single Item to the Store.\"\"\"\n\n @abstractmethod\n def extend(\n self,\n batch: Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)],\n component_idx: int,\n ) -> Future | None:\n \"\"\"Add a Batch to the Store.\"\"\"\n\n @abstractmethod\n def empty(self) -> None:\n \"\"\"Empty the Store.\"\"\"\n\n @property\n @abstractmethod\n def n_components(self) -> int:\n \"\"\"Number of components.\"\"\"\n\n @property\n @abstractmethod\n def current_activations_stored_per_component(self) -> list[int]:\n \"\"\"Current activations stored per component.\"\"\"\n\n @abstractmethod\n def __len__(self) -> int:\n \"\"\"Get the Length of the Store.\"\"\"\n\n @abstractmethod\n def __getitem__(\n self, index: tuple[int, ...] | slice | int\n ) -> Float[Tensor, Axis.names(Axis.ANY)]:\n \"\"\"Get an Item from the Store.\"\"\"\n\n def shuffle(self) -> None:\n \"\"\"Optional shuffle method.\"\"\"\n\n @final\n @validate_call\n def fill_with_test_data(\n self,\n n_batches: PositiveInt = 1,\n batch_size: PositiveInt = 16,\n n_components: PositiveInt = 1,\n input_features: PositiveInt = 256,\n ) -> None:\n \"\"\"Fill the store with test data.\n\n For use when testing your code, to ensure it works with a real activation store.\n\n Warning:\n You may want to use `torch.seed(0)` to make the random data deterministic, if your test\n requires inspecting the data itself.\n\n Example:\n >>> from sparse_autoencoder.activation_store.tensor_store import TensorActivationStore\n >>> store = TensorActivationStore(max_items=100, n_neurons=256, n_components=1)\n >>> store.fill_with_test_data(batch_size=100)\n >>> len(store)\n 100\n\n Args:\n n_batches: Number of batches to fill the store with.\n batch_size: Number of items per batch.\n n_components: Number of source model components the SAE is trained on.\n input_features: Number of input features per item.\n \"\"\"\n for _ in range(n_batches):\n for component_idx in range(n_components):\n sample = torch.rand(batch_size, input_features)\n self.extend(sample, component_idx)"},{"identifier":"TensorActivationStore","path":"sparse_autoencoder/activation_store/tensor_store.py","snippet":"class TensorActivationStore(ActivationStore):\n \"\"\"Tensor Activation Store.\n\n Stores tensors in a (large) tensor of shape (item, neuron). Requires the number of activation\n vectors to be stored to be known in advance. Multiprocess safe.\n\n Extends the `torch.utils.data.Dataset` class to provide a list-based activation store, with\n additional :meth:`append` and :meth:`extend` methods (the latter of which is non-blocking).\n\n Examples:\n Create an empty activation dataset:\n\n >>> import torch\n >>> store = TensorActivationStore(max_items=1000, n_neurons=100, n_components=2)\n\n Add a single activation vector to the dataset (for a component):\n\n >>> store.append(torch.randn(100), component_idx=0)\n >>> store.append(torch.randn(100), component_idx=1)\n >>> len(store)\n 1\n\n Add a [batch, neurons] activation tensor to the dataset:\n\n >>> store.empty()\n >>> batch = torch.randn(10, 100)\n >>> store.extend(batch, component_idx=0)\n >>> store.extend(batch, component_idx=1)\n >>> len(store)\n 10\n\n Shuffle the dataset **before passing it to the DataLoader**:\n\n >>> store.shuffle() # Faster than using the DataLoader shuffle argument\n\n Use the dataloader to iterate over the dataset:\n\n >>> loader = torch.utils.data.DataLoader(store, shuffle=False, batch_size=2)\n >>> next_item = next(iter(loader))\n >>> next_item.shape\n torch.Size([2, 2, 100])\n \"\"\"\n\n _data: Float[Tensor, Axis.names(Axis.ITEMS, Axis.COMPONENT, Axis.INPUT_OUTPUT_FEATURE)]\n \"\"\"Underlying Tensor Data Store.\"\"\"\n\n _items_stored: list[int]\n \"\"\"Number of items stored.\"\"\"\n\n max_items: int\n \"\"\"Maximum Number of Items to Store.\"\"\"\n\n _n_components: int\n \"\"\"Number of components\"\"\"\n\n @property\n def n_components(self) -> int:\n \"\"\"Number of components.\"\"\"\n return self._n_components\n\n @property\n def current_activations_stored_per_component(self) -> list[int]:\n \"\"\"Number of activations stored per component.\"\"\"\n return self._items_stored\n\n @validate_call(config={\"arbitrary_types_allowed\": True})\n def __init__(\n self,\n max_items: PositiveInt,\n n_neurons: PositiveInt,\n n_components: PositiveInt,\n device: torch.device | None = None,\n ) -> None:\n \"\"\"Initialise the Tensor Activation Store.\n\n Args:\n max_items: Maximum number of items to store per component (individual activation\n vectors).\n n_neurons: Number of neurons in each activation vector.\n n_components: Number of components to store (i.e. number of source models).\n device: Device to store the activation vectors on.\n \"\"\"\n self._n_components = n_components\n self._items_stored = [0] * n_components\n self._max_items = max_items\n self._data = torch.empty((max_items, n_components, n_neurons), device=device)\n\n def __len__(self) -> int:\n \"\"\"Length Dunder Method.\n\n Returns the number of activation vectors per component in the dataset.\n\n Example:\n >>> import torch\n >>> store = TensorActivationStore(max_items=10_000_000, n_neurons=100, n_components=1)\n >>> store.append(torch.randn(100), component_idx=0)\n >>> store.append(torch.randn(100), component_idx=0)\n >>> len(store)\n 2\n\n Returns:\n The number of activation vectors in the dataset.\n \"\"\"\n # Min as this is the amount of activations that can be fetched by get_item\n return min(self.current_activations_stored_per_component)\n\n def __sizeof__(self) -> int:\n \"\"\"Sizeof Dunder Method.\n\n Example:\n >>> import torch\n >>> store = TensorActivationStore(max_items=2, n_neurons=100, n_components=1)\n >>> store.__sizeof__() # Pre-allocated tensor of 2x100\n 800\n\n Returns:\n The size of the underlying tensor in bytes.\n \"\"\"\n return self._data.element_size() * self._data.nelement()\n\n def __getitem__(\n self, index: tuple[int, ...] | slice | int\n ) -> Float[Tensor, Axis.names(Axis.ANY)]:\n \"\"\"Get Item Dunder Method.\n\n Examples:\n >>> import torch\n >>> store = TensorActivationStore(max_items=2, n_neurons=5, n_components=1)\n >>> store.append(torch.zeros(5), component_idx=0)\n >>> store.append(torch.ones(5), component_idx=0)\n >>> store[1, 0]\n tensor([1., 1., 1., 1., 1.])\n\n Args:\n index: The index of the tensor to fetch.\n\n Returns:\n The activation store item at the given index.\n \"\"\"\n return self._data[index]\n\n def shuffle(self) -> None:\n \"\"\"Shuffle the Data In-Place.\n\n This is much faster than using the shuffle argument on `torch.utils.data.DataLoader`.\n\n Example:\n >>> import torch\n >>> _seed = torch.manual_seed(42)\n >>> store = TensorActivationStore(max_items=10, n_neurons=1, n_components=1)\n >>> store.append(torch.tensor([0.]), component_idx=0)\n >>> store.append(torch.tensor([1.]), component_idx=0)\n >>> store.append(torch.tensor([2.]), component_idx=0)\n >>> store.shuffle()\n >>> [store[i, 0].item() for i in range(3)]\n [0.0, 2.0, 1.0]\n \"\"\"\n # Generate a permutation of the indices for the active data\n perm = torch.randperm(len(self))\n\n # Use this permutation to shuffle the active data in-place\n self._data[: len(self)] = self._data[perm]\n\n def append(self, item: Float[Tensor, Axis.INPUT_OUTPUT_FEATURE], component_idx: int) -> None:\n \"\"\"Add a single item to the store.\n\n Example:\n >>> import torch\n >>> store = TensorActivationStore(max_items=10, n_neurons=5, n_components=1)\n >>> store.append(torch.zeros(5), component_idx=0)\n >>> store.append(torch.ones(5), component_idx=0)\n >>> store[1, 0]\n tensor([1., 1., 1., 1., 1.])\n\n Args:\n item: The item to append to the dataset.\n component_idx: The component index to append the item to.\n\n Raises:\n IndexError: If there is no space remaining.\n \"\"\"\n # Check we have space\n if self._items_stored[component_idx] + 1 > self._max_items:\n raise StoreFullError\n\n self._data[self._items_stored[component_idx], component_idx] = item.to(\n self._data.device,\n )\n self._items_stored[component_idx] += 1\n\n def extend(\n self,\n batch: Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)],\n component_idx: int,\n ) -> None:\n \"\"\"Add a batch to the store.\n\n Examples:\n >>> import torch\n >>> store = TensorActivationStore(max_items=10, n_neurons=5, n_components=1)\n >>> store.extend(torch.zeros(2, 5), component_idx=0)\n >>> len(store)\n 2\n\n Args:\n batch: The batch to append to the dataset.\n component_idx: The component index to append the batch to.\n\n Raises:\n IndexError: If there is no space remaining.\n \"\"\"\n # Check we have space\n n_activation_tensors: int = batch.shape[0]\n if self._items_stored[component_idx] + n_activation_tensors > self._max_items:\n raise StoreFullError\n\n self._data[\n self._items_stored[component_idx] : self._items_stored[component_idx]\n + n_activation_tensors,\n component_idx,\n ] = batch.to(self._data.device)\n self._items_stored[component_idx] += n_activation_tensors\n\n def empty(self) -> None:\n \"\"\"Empty the store.\n\n Example:\n >>> import torch\n >>> store = TensorActivationStore(max_items=10, n_neurons=5, n_components=1)\n >>> store.extend(torch.zeros(2, 5), component_idx=0)\n >>> len(store)\n 2\n >>> store.empty()\n >>> len(store)\n 0\n \"\"\"\n # We don't need to zero the data, just reset the number of items stored\n self._items_stored = [0 for _ in self._items_stored]"},{"identifier":"SparseAutoencoder","path":"sparse_autoencoder/autoencoder/model.py","snippet":"class SparseAutoencoder(Module):\n \"\"\"Sparse Autoencoder Model.\"\"\"\n\n config: SparseAutoencoderConfig\n \"\"\"Model config.\"\"\"\n\n geometric_median_dataset: Float[\n Tensor, Axis.names(Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ]\n \"\"\"Estimated Geometric Median of the Dataset.\n\n Used for initialising :attr:`tied_bias`.\n \"\"\"\n\n tied_bias: Float[\n Parameter, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ]\n \"\"\"Tied Bias Parameter.\n\n The same bias is used pre-encoder and post-decoder.\n \"\"\"\n\n pre_encoder_bias: TiedBias\n \"\"\"Pre-Encoder Bias.\"\"\"\n\n encoder: LinearEncoder\n \"\"\"Encoder.\"\"\"\n\n decoder: UnitNormDecoder\n \"\"\"Decoder.\"\"\"\n\n post_decoder_bias: TiedBias\n \"\"\"Post-Decoder Bias.\"\"\"\n\n def __init__(\n self,\n config: SparseAutoencoderConfig,\n geometric_median_dataset: Float[\n Tensor, Axis.names(Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ]\n | None = None,\n ) -> None:\n \"\"\"Initialize the Sparse Autoencoder Model.\n\n Args:\n config: Model config.\n geometric_median_dataset: Estimated geometric median of the dataset.\n \"\"\"\n super().__init__()\n\n self.config = config\n\n # Store the geometric median of the dataset (so that we can reset parameters). This is not a\n # parameter itself (the tied bias parameter is used for that), so gradients are disabled.\n tied_bias_shape = shape_with_optional_dimensions(\n config.n_components, config.n_input_features\n )\n if geometric_median_dataset is not None:\n self.geometric_median_dataset = geometric_median_dataset.clone()\n self.geometric_median_dataset.requires_grad = False\n else:\n self.geometric_median_dataset = torch.zeros(tied_bias_shape)\n self.geometric_median_dataset.requires_grad = False\n\n # Initialize the tied bias\n self.tied_bias = Parameter(torch.empty(tied_bias_shape))\n self.initialize_tied_parameters()\n\n # Initialize the components\n self.pre_encoder_bias = TiedBias(self.tied_bias, TiedBiasPosition.PRE_ENCODER)\n\n self.encoder = LinearEncoder(\n input_features=config.n_input_features,\n learnt_features=config.n_learned_features,\n n_components=config.n_components,\n )\n\n self.decoder = UnitNormDecoder(\n learnt_features=config.n_learned_features,\n decoded_features=config.n_input_features,\n n_components=config.n_components,\n )\n\n self.post_decoder_bias = TiedBias(self.tied_bias, TiedBiasPosition.POST_DECODER)\n\n def forward(\n self,\n x: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n ) -> ForwardPassResult:\n \"\"\"Forward Pass.\n\n Args:\n x: Input activations (e.g. activations from an MLP layer in a transformer model).\n\n Returns:\n Tuple of learned activations and decoded activations.\n \"\"\"\n x = self.pre_encoder_bias(x)\n learned_activations = self.encoder(x)\n x = self.decoder(learned_activations)\n decoded_activations = self.post_decoder_bias(x)\n\n return ForwardPassResult(learned_activations, decoded_activations)\n\n def initialize_tied_parameters(self) -> None:\n \"\"\"Initialize the tied parameters.\"\"\"\n # The tied bias is initialised as the geometric median of the dataset\n self.tied_bias.data = self.geometric_median_dataset\n\n def reset_parameters(self) -> None:\n \"\"\"Reset the parameters.\"\"\"\n self.initialize_tied_parameters()\n for module in self.network:\n if \"reset_parameters\" in dir(module):\n module.reset_parameters()\n\n @property\n def reset_optimizer_parameter_details(self) -> list[ResetOptimizerParameterDetails]:\n \"\"\"Reset optimizer parameter details.\n\n Details of the parameters that should be reset in the optimizer, when resetting\n dictionary vectors.\n\n Returns:\n List of tuples of the form `(parameter, axis)`, where `parameter` is the parameter to\n reset (e.g. encoder.weight), and `axis` is the axis of the parameter to reset.\n \"\"\"\n return (\n self.encoder.reset_optimizer_parameter_details\n + self.decoder.reset_optimizer_parameter_details\n )\n\n def post_backwards_hook(self) -> None:\n \"\"\"Hook to be called after each learning step.\n\n This can be used to e.g. constrain weights to unit norm.\n \"\"\"\n self.decoder.constrain_weights_unit_norm()\n\n @staticmethod\n @validate_call\n def get_single_component_state_dict(\n state: SparseAutoencoderState, component_idx: NonNegativeInt\n ) -> dict[str, Tensor]:\n \"\"\"Get the state dict for a single component.\n\n Args:\n state: Sparse Autoencoder state.\n component_idx: Index of the component to get the state dict for.\n\n Returns:\n State dict for the component.\n\n Raises:\n ValueError: If the state dict doesn't contain a components dimension.\n \"\"\"\n # Check the state has a components dimension\n if state.config.n_components is None:\n error_message = (\n \"Trying to load a single component from the state dict, but the state dict \"\n \"doesn't contain a components dimension.\"\n )\n raise ValueError(error_message)\n\n # Return the state dict for the component\n return {key: value[component_idx] for key, value in state.state_dict.items()}\n\n def save(self, file_path: Path) -> None:\n \"\"\"Save the model config and state dict to a file.\n\n Args:\n file_path: Path to save the model to.\n \"\"\"\n file_path.parent.mkdir(parents=True, exist_ok=True)\n state = SparseAutoencoderState(config=self.config, state_dict=self.state_dict())\n torch.save(state, file_path)\n\n @staticmethod\n def load(\n file_path: FILE_LIKE,\n component_idx: PositiveInt | None = None,\n ) -> \"SparseAutoencoder\":\n \"\"\"Load the model from a file.\n\n Args:\n file_path: Path to load the model from.\n component_idx: If loading a state dict from a model that has been trained on multiple\n components (e.g. all MLP layers) you may want to to load just one component. In this\n case you can set `component_idx` to the index of the component to load. Note you\n should not set this if you want to load a state dict from a model that has been\n trained on a single component (or if you want to load all components).\n\n Returns:\n The loaded model.\n \"\"\"\n # Load the file\n serialized_state = torch.load(file_path, map_location=torch.device(\"cpu\"))\n state = SparseAutoencoderState.model_validate(serialized_state)\n\n # Initialise the model\n config = SparseAutoencoderConfig(\n n_input_features=state.config.n_input_features,\n n_learned_features=state.config.n_learned_features,\n n_components=state.config.n_components if component_idx is None else None,\n )\n state_dict = (\n SparseAutoencoder.get_single_component_state_dict(state, component_idx)\n if component_idx is not None\n else state.state_dict\n )\n model = SparseAutoencoder(config)\n model.load_state_dict(state_dict)\n\n return model\n\n def save_to_wandb(\n self,\n artifact_name: str,\n directory: DirectoryPath = DEFAULT_TMP_DIR,\n ) -> str:\n \"\"\"Save the model to wandb.\n\n Args:\n artifact_name: A human-readable name for this artifact, which is how you can identify\n this artifact in the UI or reference it in use_artifact calls. Names can contain\n letters, numbers, underscores, hyphens, and dots. The name must be unique across a\n project. Example: \"sweep_name 1e9 activations\".\n directory: Directory to save the model to.\n\n Returns:\n Name of the wandb artifact.\n\n Raises:\n ValueError: If wandb is not initialised.\n \"\"\"\n # Save the file\n directory.mkdir(parents=True, exist_ok=True)\n file_name = artifact_name + \".pt\"\n file_path = directory / file_name\n self.save(file_path)\n\n # Upload to wandb\n if wandb.run is None:\n error_message = \"Trying to save the model to wandb, but wandb is not initialised.\"\n raise ValueError(error_message)\n artifact = wandb.Artifact(\n artifact_name,\n type=\"model\",\n description=\"Sparse Autoencoder model state, created with `sparse_autoencoder`.\",\n )\n artifact.add_file(str(file_path), name=\"sae-model-state.pt\")\n artifact.save()\n wandb.log_artifact(artifact)\n artifact.wait()\n\n return artifact.source_qualified_name\n\n @staticmethod\n def load_from_wandb(\n wandb_artifact_name: str,\n component_idx: PositiveInt | None = None,\n ) -> \"SparseAutoencoder\":\n \"\"\"Load the model from wandb.\n\n Args:\n wandb_artifact_name: Name of the wandb artifact to load the model from (e.g.\n \"username/project/artifact_name:version\").\n component_idx: If loading a state dict from a model that has been trained on multiple\n components (e.g. all MLP layers) you may want to to load just one component. In this\n case you can set `component_idx` to the index of the component to load. Note you\n should not set this if you want to load a state dict from a model that has been\n trained on a single component (or if you want to load all components).\n\n Returns:\n The loaded model.\n \"\"\"\n api = wandb.Api()\n artifact = api.artifact(wandb_artifact_name, type=\"model\")\n download_path = artifact.download()\n return SparseAutoencoder.load(Path(download_path) / \"sae-model-state.pt\", component_idx)\n\n def save_to_hugging_face(\n self,\n file_name: str,\n repo_id: str,\n directory: DirectoryPath = DEFAULT_TMP_DIR,\n hf_access_token: str | None = None,\n ) -> None:\n \"\"\"Save the model to Hugging Face.\n\n Args:\n file_name: Name of the file (e.g. \"model-something.pt\").\n repo_id: ID of the repo to save the model to.\n directory: Directory to save the model to.\n hf_access_token: Hugging Face access token.\n \"\"\"\n # Save the file\n directory.mkdir(parents=True, exist_ok=True)\n file_path = directory / file_name\n self.save(file_path)\n\n # Upload to Hugging Face\n api = HfApi(token=hf_access_token)\n api.upload_file(\n path_or_fileobj=file_path,\n path_in_repo=file_name,\n repo_id=repo_id,\n repo_type=\"model\",\n )\n\n @staticmethod\n def load_from_hugging_face(\n file_name: str,\n repo_id: str,\n component_idx: PositiveInt | None = None,\n ) -> \"SparseAutoencoder\":\n \"\"\"Load the model from Hugging Face.\n\n Args:\n file_name: File name of the .pt state file.\n repo_id: ID of the repo to load the model from.\n component_idx: If loading a state dict from a model that has been trained on multiple\n components (e.g. all MLP layers) you may want to to load just one component. In this\n case you can set `component_idx` to the index of the component to load. Note you\n should not set this if you want to load a state dict from a model that has been\n trained on a single component (or if you want to load all components).\n\n Returns:\n The loaded model.\n \"\"\"\n local_file = hf_hub_download(\n repo_id=repo_id,\n repo_type=\"model\",\n filename=file_name,\n revision=\"main\",\n )\n\n return SparseAutoencoder.load(Path(local_file), component_idx)"},{"identifier":"SparseAutoencoderConfig","path":"sparse_autoencoder/autoencoder/model.py","snippet":"class SparseAutoencoderConfig(BaseModel, frozen=True):\n \"\"\"SAE model config.\"\"\"\n\n n_input_features: PositiveInt\n \"\"\"Number of input features.\n\n E.g. `d_mlp` if training on MLP activations from TransformerLens).\n \"\"\"\n\n n_learned_features: PositiveInt\n \"\"\"Number of learned features.\n\n The initial paper experimented with 1 to 256 times the number of input features, and primarily\n used a multiple of 8.\"\"\"\n\n n_components: PositiveInt | None = None\n \"\"\"Number of source model components the SAE is trained on.\"\"\n\n This is useful if you want to train the SAE on several components of the source model at once.\n If `None`, the SAE is assumed to be trained on just one component (in this case the model won't\n contain a component axis in any of the parameters).\n \"\"\""},{"identifier":"L2ReconstructionLoss","path":"sparse_autoencoder/loss/decoded_activations_l2.py","snippet":"class L2ReconstructionLoss(AbstractLoss):\n \"\"\"L2 Reconstruction loss.\n\n L2 reconstruction loss is calculated as the sum squared error between each each input vector\n and it's corresponding decoded vector. The original paper found that models trained with some\n loss functions such as cross-entropy loss generally prefer to represent features\n polysemantically, whereas models trained with L2 may achieve the same loss for both\n polysemantic and monosemantic representations of true features.\n\n Example:\n >>> import torch\n >>> loss = L2ReconstructionLoss()\n >>> input_activations = torch.tensor([[5.0, 4], [3.0, 4]])\n >>> output_activations = torch.tensor([[1.0, 5], [1.0, 5]])\n >>> unused_activations = torch.zeros_like(input_activations)\n >>> # Outputs both loss and metrics to log\n >>> loss.forward(input_activations, unused_activations, output_activations)\n tensor([8.5000, 2.5000])\n \"\"\"\n\n _reduction: LossReductionType\n \"\"\"MSE reduction type.\"\"\"\n\n def __init__(self, reduction: LossReductionType = LossReductionType.MEAN) -> None:\n \"\"\"Initialise the L2 reconstruction loss.\n\n Args:\n reduction: MSE reduction type.\n \"\"\"\n super().__init__()\n self._reduction = reduction\n\n def log_name(self) -> str:\n \"\"\"Log name.\n\n Returns:\n Name of the loss module for logging.\n \"\"\"\n return \"l2_reconstruction_loss\"\n\n def forward(\n self,\n source_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n learned_activations: Float[ # noqa: ARG002\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\n ],\n decoded_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n ) -> (\n Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]\n | Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)]\n ):\n \"\"\"Calculate the L2 reconstruction loss.\n\n Args:\n source_activations: Source activations (input activations to the autoencoder from the\n source model).\n learned_activations: Learned activations (intermediate activations in the autoencoder).\n decoded_activations: Decoded activations.\n\n Returns:\n Loss per batch item.\n \"\"\"\n square_error_loss = mse_loss(source_activations, decoded_activations, reduction=\"none\")\n\n match self._reduction:\n case LossReductionType.MEAN:\n return square_error_loss.mean(dim=-1)\n case LossReductionType.SUM:\n return square_error_loss.sum(dim=-1)\n case LossReductionType.NONE:\n return square_error_loss"},{"identifier":"LearnedActivationsL1Loss","path":"sparse_autoencoder/loss/learned_activations_l1.py","snippet":"class LearnedActivationsL1Loss(AbstractLoss):\n \"\"\"Learned activations L1 (absolute error) loss.\n\n L1 loss penalty is the absolute sum of the learned activations. The L1 penalty is this\n multiplied by the l1_coefficient (designed to encourage sparsity).\n\n Example:\n >>> l1_loss = LearnedActivationsL1Loss(0.1)\n >>> learned_activations = torch.tensor([[2.0, -3], [2.0, -3]])\n >>> unused_activations = torch.zeros_like(learned_activations)\n >>> # Returns loss and metrics to log\n >>> l1_loss.forward(unused_activations, learned_activations, unused_activations)[0]\n tensor(0.5000)\n \"\"\"\n\n l1_coefficient: float | Float[Tensor, Axis.names(Axis.COMPONENT_OPTIONAL)]\n \"\"\"L1 coefficient.\"\"\"\n\n def log_name(self) -> str:\n \"\"\"Log name.\n\n Returns:\n Name of the loss module for logging.\n \"\"\"\n return \"learned_activations_l1_loss_penalty\"\n\n @validate_call(config={\"arbitrary_types_allowed\": True})\n def __init__(\n self, l1_coefficient: PositiveFloat | Float[Tensor, Axis.names(Axis.COMPONENT_OPTIONAL)]\n ) -> None:\n \"\"\"Initialize the absolute error loss.\n\n Args:\n l1_coefficient: L1 coefficient. The original paper experimented with L1 coefficients of\n [0.01, 0.008, 0.006, 0.004, 0.001]. They used 250 tokens per prompt, so as an\n approximate guide if you use e.g. 2x this number of tokens you might consider using\n 0.5x the l1 coefficient.\n \"\"\"\n self.l1_coefficient = l1_coefficient\n super().__init__()\n\n def _l1_loss(\n self,\n source_activations: Float[ # noqa: ARG002\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n learned_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\n ],\n decoded_activations: Float[ # noqa: ARG002s\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n ) -> _L1LossAndPenalty:\n \"\"\"Learned activations L1 (absolute error) loss.\n\n Args:\n source_activations: Source activations (input activations to the autoencoder from the\n source model).\n learned_activations: Learned activations (intermediate activations in the autoencoder).\n decoded_activations: Decoded activations.\n\n Returns:\n Tuple of itemwise absolute loss, and itemwise absolute loss multiplied by the l1\n coefficient.\n \"\"\"\n # Absolute loss is the summed absolute value of the learned activations (i.e. over the\n # learned feature axis).\n itemwise_absolute_loss: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)\n ] = torch.abs(learned_activations).sum(dim=-1)\n\n itemwise_absolute_loss_penalty: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)\n ] = itemwise_absolute_loss * self.l1_coefficient\n\n return _L1LossAndPenalty(\n itemwise_absolute_loss=itemwise_absolute_loss,\n itemwise_absolute_loss_penalty=itemwise_absolute_loss_penalty,\n )\n\n def forward(\n self,\n source_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n learned_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\n ],\n decoded_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n ) -> Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]:\n \"\"\"Learned activations L1 (absolute error) loss.\n\n Args:\n source_activations: Source activations (input activations to the autoencoder from the\n source model).\n learned_activations: Learned activations (intermediate activations in the autoencoder).\n decoded_activations: Decoded activations.\n\n Returns:\n Loss per batch item.\n \"\"\"\n return self._l1_loss(\n source_activations, learned_activations, decoded_activations\n ).itemwise_absolute_loss_penalty\n\n # Override to add both the loss and the penalty to the log\n def scalar_loss_with_log(\n self,\n source_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n learned_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\n ],\n decoded_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n batch_reduction: LossReductionType = LossReductionType.MEAN,\n component_reduction: LossReductionType = LossReductionType.NONE,\n ) -> LossResultWithMetrics:\n \"\"\"Scalar L1 loss (reduced across the batch and component axis) with logging.\n\n Args:\n source_activations: Source activations (input activations to the autoencoder from the\n source model).\n learned_activations: Learned activations (intermediate activations in the autoencoder).\n decoded_activations: Decoded activations.\n batch_reduction: Batch reduction type. Typically you would choose LossReductionType.MEAN\n to make the loss independent of the batch size.\n component_reduction: Component reduction type.\n\n Returns:\n Tuple of the L1 absolute error batch scalar loss and a dict of the properties to log\n (loss before and after the l1 coefficient).\n\n Raises:\n ValueError: If batch_reduction is LossReductionType.NONE.\n \"\"\"\n itemwise_absolute_loss, itemwise_absolute_loss_penalty = self._l1_loss(\n source_activations, learned_activations, decoded_activations\n )\n\n match batch_reduction:\n case LossReductionType.MEAN:\n batch_scalar_loss = itemwise_absolute_loss.mean(0)\n batch_scalar_loss_penalty = itemwise_absolute_loss_penalty.mean(0)\n case LossReductionType.SUM:\n batch_scalar_loss = itemwise_absolute_loss.sum(0)\n batch_scalar_loss_penalty = itemwise_absolute_loss_penalty.sum(0)\n case LossReductionType.NONE:\n error_message = \"Batch reduction type NONE not supported.\"\n raise ValueError(error_message)\n\n # Create the log\n metrics: list[MetricResult] = [\n MetricResult(\n name=\"loss\",\n postfix=\"learned_activations_l1\",\n component_wise_values=batch_scalar_loss.unsqueeze(0)\n if batch_scalar_loss.ndim == 0\n else batch_scalar_loss,\n location=MetricLocation.TRAIN,\n ),\n MetricResult(\n name=\"loss\",\n postfix=self.log_name(),\n component_wise_values=batch_scalar_loss_penalty.unsqueeze(0)\n if batch_scalar_loss_penalty.ndim == 0\n else batch_scalar_loss_penalty,\n location=MetricLocation.TRAIN,\n ),\n ]\n\n match component_reduction:\n case LossReductionType.MEAN:\n batch_scalar_loss_penalty = batch_scalar_loss_penalty.mean(0)\n case LossReductionType.SUM:\n batch_scalar_loss_penalty = batch_scalar_loss_penalty.sum(0)\n case LossReductionType.NONE:\n pass\n\n return LossResultWithMetrics(loss=batch_scalar_loss_penalty, loss_metrics=metrics)\n\n def extra_repr(self) -> str:\n \"\"\"Extra representation string.\"\"\"\n return f\"l1_coefficient={self.l1_coefficient}\""},{"identifier":"LossReducer","path":"sparse_autoencoder/loss/reducer.py","snippet":"class LossReducer(AbstractLoss):\n \"\"\"Loss reducer.\n\n Reduces multiple loss algorithms into a single loss algorithm (by summing). Analogous to\n nn.Sequential.\n\n Example:\n >>> from sparse_autoencoder.loss.decoded_activations_l2 import L2ReconstructionLoss\n >>> from sparse_autoencoder.loss.learned_activations_l1 import LearnedActivationsL1Loss\n >>> LossReducer(\n ... L2ReconstructionLoss(),\n ... LearnedActivationsL1Loss(0.001),\n ... )\n LossReducer(\n (0): L2ReconstructionLoss()\n (1): LearnedActivationsL1Loss(l1_coefficient=0.001)\n )\n\n \"\"\"\n\n _modules: dict[str, \"AbstractLoss\"]\n \"\"\"Children loss modules.\"\"\"\n\n def log_name(self) -> str:\n \"\"\"Log name.\n\n Returns:\n Name of the loss module for logging.\n \"\"\"\n return \"total_loss\"\n\n def __init__(\n self,\n *loss_modules: AbstractLoss,\n ):\n \"\"\"Initialize the loss reducer.\n\n Args:\n *loss_modules: Loss modules to reduce.\n\n Raises:\n ValueError: If the loss reducer has no loss modules.\n \"\"\"\n super().__init__()\n\n for idx, loss_module in enumerate(loss_modules):\n self._modules[str(idx)] = loss_module\n\n if len(self) == 0:\n error_message = \"Loss reducer must have at least one loss module.\"\n raise ValueError(error_message)\n\n def forward(\n self,\n source_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n learned_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\n ],\n decoded_activations: Float[\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\n ],\n ) -> Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]:\n \"\"\"Reduce loss.\n\n Args:\n source_activations: Source activations (input activations to the autoencoder from the\n source model).\n learned_activations: Learned activations (intermediate activations in the autoencoder).\n decoded_activations: Decoded activations.\n\n Returns:\n Mean loss across the batch, summed across the loss modules.\n \"\"\"\n all_modules_loss: Float[Tensor, \"module train_batch\"] = torch.stack(\n [\n loss_module.forward(source_activations, learned_activations, decoded_activations)\n for loss_module in self._modules.values()\n ]\n )\n\n return all_modules_loss.sum(dim=0)\n\n def __dir__(self) -> list[str]:\n \"\"\"Dir dunder method.\"\"\"\n return list(self._modules.__dir__())\n\n def __getitem__(self, idx: int) -> AbstractLoss:\n \"\"\"Get item dunder method.\"\"\"\n return self._modules[str(idx)]\n\n def __iter__(self) -> Iterator[AbstractLoss]:\n \"\"\"Iterator dunder method.\"\"\"\n return iter(self._modules.values())\n\n def __len__(self) -> int:\n \"\"\"Length dunder method.\"\"\"\n return len(self._modules)"},{"identifier":"Axis","path":"sparse_autoencoder/tensor_types.py","snippet":"class Axis(LowercaseStrEnum):\n \"\"\"Tensor axis names.\n\n Used to annotate tensor types.\n\n Example:\n When used directly it prints a string:\n\n >>> print(Axis.INPUT_OUTPUT_FEATURE)\n input_output_feature\n\n The primary use is to annotate tensor types:\n\n >>> from jaxtyping import Float\n >>> from torch import Tensor\n >>> from typing import TypeAlias\n >>> batch: TypeAlias = Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)]\n >>> print(batch)\n <class 'jaxtyping.Float[Tensor, 'batch input_output_feature']'>\n\n You can also join multiple axis together to represent the dimensions of a tensor:\n\n >>> print(Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE))\n batch input_output_feature\n \"\"\"\n\n # Component idx\n COMPONENT = auto()\n \"\"\"Component index.\"\"\"\n\n COMPONENT_OPTIONAL = \"*component\"\n \"\"\"Optional component index.\"\"\"\n\n # Batches\n SOURCE_DATA_BATCH = auto()\n \"\"\"Batch of prompts used to generate source model activations.\"\"\"\n\n BATCH = auto()\n \"\"\"Batch of items that the SAE is being trained on.\"\"\"\n\n STORE_BATCH = auto()\n \"\"\"Batch of items to be written to the store.\"\"\"\n\n ITEMS = auto()\n \"\"\"Arbitrary number of items.\"\"\"\n\n # Features\n INPUT_OUTPUT_FEATURE = auto()\n \"\"\"Input or output feature (e.g. feature in activation vector from source model).\"\"\"\n\n LEARNT_FEATURE = auto()\n \"\"\"Learn feature (e.g. feature in learnt activation vector).\"\"\"\n\n DEAD_FEATURE = auto()\n \"\"\"Dead feature.\"\"\"\n\n ALIVE_FEATURE = auto()\n \"\"\"Alive feature.\"\"\"\n\n # Feature indices\n INPUT_OUTPUT_FEATURE_IDX = auto()\n \"\"\"Input or output feature index.\"\"\"\n\n LEARNT_FEATURE_IDX = auto()\n \"\"\"Learn feature index.\"\"\"\n\n # Other\n POSITION = auto()\n \"\"\"Token position.\"\"\"\n\n SINGLE_ITEM = \"\"\n \"\"\"Single item axis.\"\"\"\n\n ANY = \"...\"\n \"\"\"Any number of axis.\"\"\"\n\n @staticmethod\n def names(*axis: \"Axis\") -> str:\n \"\"\"Join multiple axis together, to represent the dimensions of a tensor.\n\n Example:\n >>> print(Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE))\n batch input_output_feature\n\n Args:\n *axis: Axis to join.\n\n Returns:\n Joined axis string.\n \"\"\"\n return \" \".join(a.value for a in axis)"}],"string":"[\n {\n \"identifier\": \"ActivationResampler\",\n \"path\": \"sparse_autoencoder/activation_resampler/activation_resampler.py\",\n \"snippet\": \"class ActivationResampler:\\n \\\"\\\"\\\"Activation resampler.\\n\\n Collates the number of times each neuron fires over a set number of learned activation vectors,\\n and then provides the parameters necessary to reset any dead neurons.\\n\\n Motivation:\\n Over the course of training, a subset of autoencoder neurons will have zero activity across\\n a large number of datapoints. The authors of *Towards Monosemanticity: Decomposing Language\\n Models With Dictionary Learning* found that “resampling” these dead neurons during training\\n improves the number of likely-interpretable features (i.e., those in the high density\\n cluster) and reduces total loss. This resampling may be compatible with the Lottery Ticket\\n Hypothesis and increase the number of chances the network has to find promising feature\\n directions.\\n\\n An interesting nuance around dead neurons involves the ultralow density cluster. They found\\n that if we increase the number of training steps then networks will kill off more of these\\n ultralow density neurons. This reinforces the use of the high density cluster as a useful\\n metric because there can exist neurons that are de facto dead but will not appear to be when\\n looking at the number of dead neurons alone.\\n\\n This approach is designed to seed new features to fit inputs where the current autoencoder\\n performs worst. Resetting the encoder norm and bias are crucial to ensuring this resampled\\n neuron will only fire weakly for inputs similar to the one used for its reinitialization.\\n This was done to minimize interference with the rest of the network.\\n\\n Warning:\\n The optimizer should be reset after applying this function, as the Adam state will be\\n incorrect for the modified weights and biases.\\n\\n Warning:\\n This approach is also known to create sudden loss spikes, and resampling too frequently\\n causes training to diverge.\\n \\\"\\\"\\\"\\n\\n _activations_seen_since_last_resample: int = 0\\n \\\"\\\"\\\"Number of activations since we last resampled.\\\"\\\"\\\"\\n\\n _collated_neuron_activity: Float[Tensor, Axis.names(Axis.COMPONENT, Axis.LEARNT_FEATURE)]\\n \\\"\\\"\\\"Collated neuron activity, over the current data collection window.\\\"\\\"\\\"\\n\\n _threshold_is_dead_portion_fires: float\\n \\\"\\\"\\\"Threshold for determining if a neuron has fired (or is dead).\\\"\\\"\\\"\\n\\n _max_n_resamples: int\\n \\\"\\\"\\\"Maximum number of times that resampling should be performed.\\\"\\\"\\\"\\n\\n _n_activations_collated_since_last_resample: int = 0\\n \\\"\\\"\\\"Number of activations collated since we last resampled.\\n\\n Number of vectors used to collate neuron activity, over the current collation window.\\n \\\"\\\"\\\"\\n\\n _n_components: int\\n \\\"\\\"\\\"Number of components.\\\"\\\"\\\"\\n\\n _n_times_resampled: int = 0\\n \\\"\\\"\\\"Number of times that resampling has been performed.\\\"\\\"\\\"\\n\\n neuron_activity_window_end: int\\n \\\"\\\"\\\"End of the window for collecting neuron activity.\\\"\\\"\\\"\\n\\n neuron_activity_window_start: int\\n \\\"\\\"\\\"Start of the window for collecting neuron activity.\\\"\\\"\\\"\\n\\n @validate_call\\n def __init__(\\n self,\\n n_learned_features: PositiveInt,\\n n_components: NonNegativeInt = 1,\\n resample_interval: PositiveInt = 200_000_000,\\n max_n_resamples: NonNegativeInt = 4,\\n n_activations_activity_collate: PositiveInt = 100_000_000,\\n resample_dataset_size: PositiveInt = 819_200,\\n threshold_is_dead_portion_fires: Annotated[float, Field(strict=True, ge=0, le=1)] = 0.0,\\n ) -> None:\\n r\\\"\\\"\\\"Initialize the activation resampler.\\n\\n Defaults to values used in the Anthropic Towards Monosemanticity paper.\\n\\n Args:\\n n_learned_features: Number of learned features\\n n_components: Number of components that the SAE is being trained on.\\n resample_interval: Interval in number of autoencoder input activation vectors trained\\n on, before resampling.\\n max_n_resamples: Maximum number of resamples to perform throughout the entire pipeline.\\n Set to inf if you want to have no limit.\\n n_activations_activity_collate: Number of autoencoder learned activation vectors to\\n collate before resampling (the activation resampler will start collecting on vector\\n $\\\\text{resample_interval} - \\\\text{n_steps_collate}$).\\n resample_dataset_size: Number of autoencoder input activations to use for calculating\\n the loss, as part of the resampling process to create the reset neuron weights.\\n threshold_is_dead_portion_fires: Threshold for determining if a neuron is dead (has\\n \\\"fired\\\" in less than this portion of the collated sample).\\n\\n Raises:\\n ValueError: If any of the arguments are invalid (e.g. negative integers).\\n \\\"\\\"\\\"\\n if n_activations_activity_collate > resample_interval:\\n error_message = (\\n \\\"Number of steps to collate must be less than or equal to the resample interval.\\\"\\n )\\n raise ValueError(error_message)\\n\\n super().__init__()\\n self.neuron_activity_window_end = resample_interval\\n self.neuron_activity_window_start = resample_interval - n_activations_activity_collate\\n self._max_n_resamples = max_n_resamples\\n self._collated_neuron_activity = torch.zeros(\\n (n_components, n_learned_features), dtype=torch.int64\\n )\\n self._resample_dataset_size = resample_dataset_size\\n self._threshold_is_dead_portion_fires = threshold_is_dead_portion_fires\\n self._n_components = n_components\\n\\n def _get_dead_neuron_indices(\\n self,\\n ) -> list[Int64[Tensor, Axis.names(Axis.LEARNT_FEATURE_IDX)]]:\\n \\\"\\\"\\\"Identify the indices of neurons that are dead.\\n\\n Identifies any neurons that have fired less than the threshold portion of the collated\\n sample size.\\n\\n Example:\\n >>> resampler = ActivationResampler(n_learned_features=6, n_components=2)\\n >>> resampler._collated_neuron_activity = torch.tensor(\\n ... [[1, 1, 0, 0, 1, 1], [1, 1, 1, 1, 1, 0]]\\n ... )\\n >>> resampler._get_dead_neuron_indices()\\n [tensor([2, 3]), tensor([5])]\\n\\n Returns:\\n List of dead neuron indices for each component.\\n\\n Raises:\\n ValueError: If no neuron activity has been collated yet.\\n \\\"\\\"\\\"\\n # Check we have already collated some neuron activity\\n if torch.all(self._collated_neuron_activity == 0):\\n error_message = \\\"Cannot get dead neuron indices without neuron activity.\\\"\\n raise ValueError(error_message)\\n\\n # Find any neurons that fire less than the threshold portion of times\\n threshold_is_dead_n_fires: int = int(\\n self._n_activations_collated_since_last_resample * self._threshold_is_dead_portion_fires\\n )\\n\\n return [\\n torch.where(self._collated_neuron_activity[component_idx] <= threshold_is_dead_n_fires)[\\n 0\\n ].to(dtype=torch.int64)\\n for component_idx in range(self._n_components)\\n ]\\n\\n def compute_loss_and_get_activations(\\n self,\\n store: ActivationStore,\\n autoencoder: SparseAutoencoder | DataParallel[SparseAutoencoder] | DeepSpeedEngine,\\n loss_fn: AbstractLoss,\\n train_batch_size: int,\\n ) -> LossInputActivationsTuple:\\n \\\"\\\"\\\"Compute the loss on a random subset of inputs.\\n\\n Motivation:\\n Helps find input vectors that have high SAE loss, so that we can resample dead neurons\\n in a way that improves performance on these specific input vectors.\\n\\n Args:\\n store: Activation store.\\n autoencoder: Sparse autoencoder model.\\n loss_fn: Loss function.\\n train_batch_size: Train batch size (also used for resampling).\\n\\n Returns:\\n A tuple of loss per item, and all input activations.\\n\\n Raises:\\n ValueError: If the number of items in the store is less than the number of inputs\\n \\\"\\\"\\\"\\n with torch.no_grad():\\n loss_batches: list[Float[Tensor, Axis.BATCH]] = []\\n input_activations_batches: list[\\n Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)]\\n ] = []\\n dataloader = DataLoader(store, batch_size=train_batch_size)\\n n_inputs = self._resample_dataset_size\\n n_batches_required: int = n_inputs // train_batch_size\\n model_device: torch.device = get_model_device(autoencoder)\\n\\n for batch_idx, batch in enumerate(iter(dataloader)):\\n input_activations_batches.append(batch)\\n source_activations = batch.to(model_device)\\n learned_activations, reconstructed_activations = autoencoder(source_activations)\\n loss_batches.append(\\n loss_fn.forward(\\n source_activations, learned_activations, reconstructed_activations\\n )\\n )\\n if batch_idx >= n_batches_required:\\n break\\n\\n loss_per_item = torch.cat(loss_batches).to(model_device)\\n input_activations = torch.cat(input_activations_batches).to(model_device)\\n\\n # Check we generated enough data\\n if len(loss_per_item) < n_inputs:\\n error_message = (\\n f\\\"Cannot get {n_inputs} items from the store, \\\"\\n f\\\"as only {len(loss_per_item)} were available.\\\"\\n )\\n raise ValueError(error_message)\\n\\n return LossInputActivationsTuple(loss_per_item, input_activations)\\n\\n @staticmethod\\n def assign_sampling_probabilities(\\n loss: Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)],\\n ) -> Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]:\\n \\\"\\\"\\\"Assign the sampling probabilities for each input activations vector.\\n\\n Assign each input vector a probability of being picked that is proportional to the square of\\n the autoencoder's loss on that input.\\n\\n Examples:\\n >>> loss = torch.tensor([1.0, 2.0, 3.0])\\n >>> ActivationResampler.assign_sampling_probabilities(loss).round(decimals=2)\\n tensor([0.0700, 0.2900, 0.6400])\\n\\n >>> loss = torch.tensor([[1.0, 2], [2, 4], [3, 6]])\\n >>> ActivationResampler.assign_sampling_probabilities(loss).round(decimals=2)\\n tensor([[0.0700, 0.0700],\\n [0.2900, 0.2900],\\n [0.6400, 0.6400]])\\n\\n Args:\\n loss: Loss per item.\\n\\n Returns:\\n A tensor of probabilities for each item.\\n \\\"\\\"\\\"\\n square_loss = loss.pow(2)\\n return square_loss / square_loss.sum(0)\\n\\n @staticmethod\\n def sample_input(\\n probabilities: Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)],\\n input_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n n_samples: list[int],\\n ) -> list[Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]]:\\n \\\"\\\"\\\"Sample an input vector based on the provided probabilities.\\n\\n Example:\\n >>> probabilities = torch.tensor([[0.1], [0.2], [0.7]])\\n >>> input_activations = torch.tensor([[[1.0, 2.0]], [[3.0, 4.0]], [[5.0, 6.0]]])\\n >>> _seed = torch.manual_seed(0) # For reproducibility in example\\n >>> sampled_input = ActivationResampler.sample_input(\\n ... probabilities, input_activations, [2]\\n ... )\\n >>> sampled_input[0].tolist()\\n [[5.0, 6.0], [3.0, 4.0]]\\n\\n Args:\\n probabilities: Probabilities for each input.\\n input_activations: Input activation vectors.\\n n_samples: Number of samples to take (number of dead neurons).\\n\\n Returns:\\n Sampled input activation vector.\\n\\n Raises:\\n ValueError: If the number of samples is greater than the number of input activations.\\n \\\"\\\"\\\"\\n sampled_inputs: list[\\n Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]\\n ] = []\\n\\n for component_idx, component_n_samples in enumerate(n_samples):\\n component_probabilities: Float[Tensor, Axis.BATCH] = get_component_slice_tensor(\\n input_tensor=probabilities,\\n n_dim_with_component=2,\\n component_dim=1,\\n component_idx=component_idx,\\n )\\n\\n component_input_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)\\n ] = get_component_slice_tensor(\\n input_tensor=input_activations,\\n n_dim_with_component=3,\\n component_dim=1,\\n component_idx=component_idx,\\n )\\n\\n if component_n_samples > len(component_input_activations):\\n exception_message = (\\n f\\\"Cannot sample {component_n_samples} inputs from \\\"\\n f\\\"{len(component_input_activations)} input activations.\\\"\\n )\\n raise ValueError(exception_message)\\n\\n # Handle the 0 dead neurons case\\n if component_n_samples == 0:\\n sampled_inputs.append(\\n torch.empty(\\n (0, component_input_activations.shape[-1]),\\n dtype=component_input_activations.dtype,\\n device=component_input_activations.device,\\n )\\n )\\n continue\\n\\n # Handle the 1+ dead neuron case\\n component_sample_indices: Int64[Tensor, Axis.LEARNT_FEATURE_IDX] = torch.multinomial(\\n component_probabilities, num_samples=component_n_samples\\n )\\n sampled_inputs.append(component_input_activations[component_sample_indices, :])\\n\\n return sampled_inputs\\n\\n @staticmethod\\n def renormalize_and_scale(\\n sampled_input: Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)],\\n neuron_activity: Int64[Tensor, Axis.names(Axis.LEARNT_FEATURE)],\\n encoder_weight: Float[Tensor, Axis.names(Axis.LEARNT_FEATURE, Axis.INPUT_OUTPUT_FEATURE)],\\n ) -> Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]:\\n \\\"\\\"\\\"Renormalize and scale the resampled dictionary vectors.\\n\\n Renormalize the input vector to equal the average norm of the encoder weights for alive\\n neurons times 0.2.\\n\\n Example:\\n >>> from torch.nn import Parameter\\n >>> _seed = torch.manual_seed(0) # For reproducibility in example\\n >>> sampled_input = torch.tensor([[3.0, 4.0]])\\n >>> neuron_activity = torch.tensor([3, 0, 5, 0, 1, 3])\\n >>> encoder_weight = Parameter(torch.ones((6, 2)))\\n >>> rescaled_input = ActivationResampler.renormalize_and_scale(\\n ... sampled_input,\\n ... neuron_activity,\\n ... encoder_weight\\n ... )\\n >>> rescaled_input.round(decimals=1)\\n tensor([[0.2000, 0.2000]])\\n\\n Args:\\n sampled_input: Tensor of the sampled input activation.\\n neuron_activity: Tensor representing the number of times each neuron fired.\\n encoder_weight: Tensor of encoder weights.\\n\\n Returns:\\n Rescaled sampled input.\\n\\n Raises:\\n ValueError: If there are no alive neurons.\\n \\\"\\\"\\\"\\n alive_neuron_mask: Bool[Tensor, \\\" learned_features\\\"] = neuron_activity > 0\\n\\n # Check there is at least one alive neuron\\n if not torch.any(alive_neuron_mask):\\n error_message = \\\"No alive neurons found.\\\"\\n raise ValueError(error_message)\\n\\n # Handle no dead neurons\\n n_dead_neurons = len(sampled_input)\\n if n_dead_neurons == 0:\\n return torch.empty(\\n (0, sampled_input.shape[-1]), dtype=sampled_input.dtype, device=sampled_input.device\\n )\\n\\n # Calculate the average norm of the encoder weights for alive neurons.\\n detached_encoder_weight = encoder_weight.detach() # Don't track gradients\\n alive_encoder_weights: Float[\\n Tensor, Axis.names(Axis.ALIVE_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\\n ] = detached_encoder_weight[alive_neuron_mask, :]\\n average_alive_norm: Float[Tensor, Axis.SINGLE_ITEM] = alive_encoder_weights.norm(\\n dim=-1\\n ).mean()\\n\\n # Renormalize the input vector to equal the average norm of the encoder weights for alive\\n # neurons times 0.2.\\n renormalized_input: Float[\\n Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\\n ] = torch.nn.functional.normalize(sampled_input, dim=-1)\\n return renormalized_input * (average_alive_norm * 0.2)\\n\\n def resample_dead_neurons(\\n self,\\n activation_store: ActivationStore,\\n autoencoder: SparseAutoencoder | DataParallel[SparseAutoencoder] | DeepSpeedEngine,\\n loss_fn: AbstractLoss,\\n train_batch_size: int,\\n ) -> list[ParameterUpdateResults]:\\n \\\"\\\"\\\"Resample dead neurons.\\n\\n Args:\\n activation_store: Activation store.\\n autoencoder: Sparse autoencoder model.\\n loss_fn: Loss function.\\n train_batch_size: Train batch size (also used for resampling).\\n\\n Returns:\\n For each component that the SAE is being trained on, the indices of dead neurons and the\\n updates for the encoder and decoder weights and biases.\\n \\\"\\\"\\\"\\n parameter_update_results: list[ParameterUpdateResults] = []\\n\\n with torch.no_grad():\\n dead_neuron_indices: list[\\n Int64[Tensor, Axis.names(Axis.LEARNT_FEATURE_IDX)]\\n ] = self._get_dead_neuron_indices()\\n\\n # Compute the loss for the current model on a random subset of inputs and get the\\n # activations.\\n loss_per_item, input_activations = self.compute_loss_and_get_activations(\\n store=activation_store,\\n autoencoder=autoencoder,\\n loss_fn=loss_fn,\\n train_batch_size=train_batch_size,\\n )\\n\\n # Assign each input vector a probability of being picked that is proportional to the\\n # square of the autoencoder's loss on that input.\\n sample_probabilities: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)\\n ] = self.assign_sampling_probabilities(loss_per_item)\\n\\n # For each dead neuron sample an input according to these probabilities.\\n sampled_input: list[\\n Float[Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)]\\n ] = self.sample_input(\\n sample_probabilities, input_activations, [len(dead) for dead in dead_neuron_indices]\\n )\\n\\n for component_idx in range(self._n_components):\\n # Renormalize each input vector to have unit L2 norm and set this to be the\\n # dictionary vector for the dead autoencoder neuron.\\n renormalized_input: Float[\\n Tensor, Axis.names(Axis.DEAD_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\\n ] = torch.nn.functional.normalize(sampled_input[component_idx], dim=-1)\\n\\n dead_decoder_weight_updates = rearrange(\\n renormalized_input, \\\"dead_neuron input_feature -> input_feature dead_neuron\\\"\\n )\\n\\n # For the corresponding encoder vector, renormalize the input vector to equal the\\n # average norm of the encoder weights for alive neurons times 0.2. Set the\\n # corresponding encoder bias element to zero.\\n encoder_weight: Float[\\n Tensor, Axis.names(Axis.LEARNT_FEATURE, Axis.INPUT_OUTPUT_FEATURE)\\n ] = get_component_slice_tensor(autoencoder.encoder.weight, 3, 0, component_idx)\\n\\n rescaled_sampled_input = self.renormalize_and_scale(\\n sampled_input=sampled_input[component_idx],\\n neuron_activity=self._collated_neuron_activity[component_idx],\\n encoder_weight=encoder_weight,\\n )\\n\\n dead_encoder_bias_updates = torch.zeros_like(\\n dead_neuron_indices[component_idx],\\n dtype=dead_decoder_weight_updates.dtype,\\n device=dead_decoder_weight_updates.device,\\n )\\n\\n parameter_update_results.append(\\n ParameterUpdateResults(\\n dead_neuron_indices=dead_neuron_indices[component_idx],\\n dead_encoder_weight_updates=rescaled_sampled_input,\\n dead_encoder_bias_updates=dead_encoder_bias_updates,\\n dead_decoder_weight_updates=dead_decoder_weight_updates,\\n )\\n )\\n\\n return parameter_update_results\\n\\n def step_resampler(\\n self,\\n batch_neuron_activity: Int64[Tensor, Axis.names(Axis.COMPONENT, Axis.LEARNT_FEATURE)],\\n activation_store: ActivationStore,\\n autoencoder: SparseAutoencoder | DataParallel[SparseAutoencoder] | DeepSpeedEngine,\\n loss_fn: AbstractLoss,\\n train_batch_size: int,\\n ) -> list[ParameterUpdateResults] | None:\\n \\\"\\\"\\\"Step the resampler, collating neuron activity and resampling if necessary.\\n\\n Args:\\n batch_neuron_activity: Number of times each neuron fired in the current batch.\\n activation_store: Activation store.\\n autoencoder: Sparse autoencoder model.\\n loss_fn: Loss function.\\n train_batch_size: Train batch size (also used for resampling).\\n\\n Returns:\\n Parameter update results (for each component that the SAE is being trained on) if\\n resampling is due. Otherwise None.\\n \\\"\\\"\\\"\\n # Update the counter\\n self._activations_seen_since_last_resample += len(activation_store)\\n\\n if self._n_times_resampled < self._max_n_resamples:\\n # Collate neuron activity, if in the data collection window. For example in the\\n # Anthropic Towards Monosemanticity paper, the window started collecting at 100m\\n # activations and stopped at 200m (and then repeated this again a few times until the\\n # max times to resample was hit).\\n if self._activations_seen_since_last_resample >= self.neuron_activity_window_start:\\n detached_neuron_activity = batch_neuron_activity.detach().cpu()\\n self._collated_neuron_activity.add_(detached_neuron_activity)\\n self._n_activations_collated_since_last_resample += train_batch_size\\n\\n # Check if we should resample.\\n if self._activations_seen_since_last_resample >= self.neuron_activity_window_end:\\n # Get resampled dictionary vectors\\n resample_res = self.resample_dead_neurons(\\n activation_store=activation_store,\\n autoencoder=autoencoder,\\n loss_fn=loss_fn,\\n train_batch_size=train_batch_size,\\n )\\n\\n # Update counters\\n self._activations_seen_since_last_resample = 0\\n self._n_activations_collated_since_last_resample = 0\\n self._n_times_resampled += 1\\n\\n # Reset the collated neuron activity\\n self._collated_neuron_activity.zero_()\\n\\n return resample_res\\n\\n return None\\n\\n def __str__(self) -> str:\\n \\\"\\\"\\\"Return a string representation of the activation resampler.\\\"\\\"\\\"\\n return (\\n f\\\"ActivationResampler(\\\"\\n f\\\"n_components={self._n_components}, \\\"\\n f\\\"neuron_activity_window_start={self.neuron_activity_window_end}, \\\"\\n f\\\"neuron_activity_window_end={self.neuron_activity_window_end}, \\\"\\n f\\\"max_resamples={self._max_n_resamples}, \\\"\\n f\\\"resample_dataset_size={self._resample_dataset_size}, \\\"\\n f\\\"dead_neuron_threshold={self._threshold_is_dead_portion_fires})\\\"\\n )\"\n },\n {\n \"identifier\": \"ActivationStore\",\n \"path\": \"sparse_autoencoder/activation_store/base_store.py\",\n \"snippet\": \"class ActivationStore(\\n Dataset[Float[Tensor, Axis.names(Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)]], ABC\\n):\\n \\\"\\\"\\\"Activation Store Abstract Class.\\n\\n Extends the `torch.utils.data.Dataset` class to provide an activation store, with additional\\n :meth:`append` and :meth:`extend` methods (the latter of which should typically be\\n non-blocking). The resulting activation store can be used with a `torch.utils.data.DataLoader`\\n to iterate over the dataset.\\n\\n Extend this class if you want to create a new activation store (noting you also need to create\\n `__getitem__` and `__len__` methods from the underlying `torch.utils.data.Dataset` class).\\n\\n Example:\\n >>> import torch\\n >>> class MyActivationStore(ActivationStore):\\n ...\\n ... @property\\n ... def current_activations_stored_per_component(self):\\n ... raise NotImplementedError\\n ...\\n ... @property\\n ... def n_components(self):\\n ... raise NotImplementedError\\n ...\\n ... def __init__(self):\\n ... super().__init__()\\n ... self._data = [] # In this example, we just store in a list\\n ...\\n ... def append(self, item) -> None:\\n ... self._data.append(item)\\n ...\\n ... def extend(self, batch):\\n ... self._data.extend(batch)\\n ...\\n ... def empty(self):\\n ... self._data = []\\n ...\\n ... def __getitem__(self, index: int):\\n ... return self._data[index]\\n ...\\n ... def __len__(self) -> int:\\n ... return len(self._data)\\n ...\\n >>> store = MyActivationStore()\\n >>> store.append(torch.randn(100))\\n >>> print(len(store))\\n 1\\n \\\"\\\"\\\"\\n\\n @abstractmethod\\n def append(\\n self,\\n item: Float[Tensor, Axis.names(Axis.INPUT_OUTPUT_FEATURE)],\\n component_idx: int,\\n ) -> Future | None:\\n \\\"\\\"\\\"Add a Single Item to the Store.\\\"\\\"\\\"\\n\\n @abstractmethod\\n def extend(\\n self,\\n batch: Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)],\\n component_idx: int,\\n ) -> Future | None:\\n \\\"\\\"\\\"Add a Batch to the Store.\\\"\\\"\\\"\\n\\n @abstractmethod\\n def empty(self) -> None:\\n \\\"\\\"\\\"Empty the Store.\\\"\\\"\\\"\\n\\n @property\\n @abstractmethod\\n def n_components(self) -> int:\\n \\\"\\\"\\\"Number of components.\\\"\\\"\\\"\\n\\n @property\\n @abstractmethod\\n def current_activations_stored_per_component(self) -> list[int]:\\n \\\"\\\"\\\"Current activations stored per component.\\\"\\\"\\\"\\n\\n @abstractmethod\\n def __len__(self) -> int:\\n \\\"\\\"\\\"Get the Length of the Store.\\\"\\\"\\\"\\n\\n @abstractmethod\\n def __getitem__(\\n self, index: tuple[int, ...] | slice | int\\n ) -> Float[Tensor, Axis.names(Axis.ANY)]:\\n \\\"\\\"\\\"Get an Item from the Store.\\\"\\\"\\\"\\n\\n def shuffle(self) -> None:\\n \\\"\\\"\\\"Optional shuffle method.\\\"\\\"\\\"\\n\\n @final\\n @validate_call\\n def fill_with_test_data(\\n self,\\n n_batches: PositiveInt = 1,\\n batch_size: PositiveInt = 16,\\n n_components: PositiveInt = 1,\\n input_features: PositiveInt = 256,\\n ) -> None:\\n \\\"\\\"\\\"Fill the store with test data.\\n\\n For use when testing your code, to ensure it works with a real activation store.\\n\\n Warning:\\n You may want to use `torch.seed(0)` to make the random data deterministic, if your test\\n requires inspecting the data itself.\\n\\n Example:\\n >>> from sparse_autoencoder.activation_store.tensor_store import TensorActivationStore\\n >>> store = TensorActivationStore(max_items=100, n_neurons=256, n_components=1)\\n >>> store.fill_with_test_data(batch_size=100)\\n >>> len(store)\\n 100\\n\\n Args:\\n n_batches: Number of batches to fill the store with.\\n batch_size: Number of items per batch.\\n n_components: Number of source model components the SAE is trained on.\\n input_features: Number of input features per item.\\n \\\"\\\"\\\"\\n for _ in range(n_batches):\\n for component_idx in range(n_components):\\n sample = torch.rand(batch_size, input_features)\\n self.extend(sample, component_idx)\"\n },\n {\n \"identifier\": \"TensorActivationStore\",\n \"path\": \"sparse_autoencoder/activation_store/tensor_store.py\",\n \"snippet\": \"class TensorActivationStore(ActivationStore):\\n \\\"\\\"\\\"Tensor Activation Store.\\n\\n Stores tensors in a (large) tensor of shape (item, neuron). Requires the number of activation\\n vectors to be stored to be known in advance. Multiprocess safe.\\n\\n Extends the `torch.utils.data.Dataset` class to provide a list-based activation store, with\\n additional :meth:`append` and :meth:`extend` methods (the latter of which is non-blocking).\\n\\n Examples:\\n Create an empty activation dataset:\\n\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=1000, n_neurons=100, n_components=2)\\n\\n Add a single activation vector to the dataset (for a component):\\n\\n >>> store.append(torch.randn(100), component_idx=0)\\n >>> store.append(torch.randn(100), component_idx=1)\\n >>> len(store)\\n 1\\n\\n Add a [batch, neurons] activation tensor to the dataset:\\n\\n >>> store.empty()\\n >>> batch = torch.randn(10, 100)\\n >>> store.extend(batch, component_idx=0)\\n >>> store.extend(batch, component_idx=1)\\n >>> len(store)\\n 10\\n\\n Shuffle the dataset **before passing it to the DataLoader**:\\n\\n >>> store.shuffle() # Faster than using the DataLoader shuffle argument\\n\\n Use the dataloader to iterate over the dataset:\\n\\n >>> loader = torch.utils.data.DataLoader(store, shuffle=False, batch_size=2)\\n >>> next_item = next(iter(loader))\\n >>> next_item.shape\\n torch.Size([2, 2, 100])\\n \\\"\\\"\\\"\\n\\n _data: Float[Tensor, Axis.names(Axis.ITEMS, Axis.COMPONENT, Axis.INPUT_OUTPUT_FEATURE)]\\n \\\"\\\"\\\"Underlying Tensor Data Store.\\\"\\\"\\\"\\n\\n _items_stored: list[int]\\n \\\"\\\"\\\"Number of items stored.\\\"\\\"\\\"\\n\\n max_items: int\\n \\\"\\\"\\\"Maximum Number of Items to Store.\\\"\\\"\\\"\\n\\n _n_components: int\\n \\\"\\\"\\\"Number of components\\\"\\\"\\\"\\n\\n @property\\n def n_components(self) -> int:\\n \\\"\\\"\\\"Number of components.\\\"\\\"\\\"\\n return self._n_components\\n\\n @property\\n def current_activations_stored_per_component(self) -> list[int]:\\n \\\"\\\"\\\"Number of activations stored per component.\\\"\\\"\\\"\\n return self._items_stored\\n\\n @validate_call(config={\\\"arbitrary_types_allowed\\\": True})\\n def __init__(\\n self,\\n max_items: PositiveInt,\\n n_neurons: PositiveInt,\\n n_components: PositiveInt,\\n device: torch.device | None = None,\\n ) -> None:\\n \\\"\\\"\\\"Initialise the Tensor Activation Store.\\n\\n Args:\\n max_items: Maximum number of items to store per component (individual activation\\n vectors).\\n n_neurons: Number of neurons in each activation vector.\\n n_components: Number of components to store (i.e. number of source models).\\n device: Device to store the activation vectors on.\\n \\\"\\\"\\\"\\n self._n_components = n_components\\n self._items_stored = [0] * n_components\\n self._max_items = max_items\\n self._data = torch.empty((max_items, n_components, n_neurons), device=device)\\n\\n def __len__(self) -> int:\\n \\\"\\\"\\\"Length Dunder Method.\\n\\n Returns the number of activation vectors per component in the dataset.\\n\\n Example:\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=10_000_000, n_neurons=100, n_components=1)\\n >>> store.append(torch.randn(100), component_idx=0)\\n >>> store.append(torch.randn(100), component_idx=0)\\n >>> len(store)\\n 2\\n\\n Returns:\\n The number of activation vectors in the dataset.\\n \\\"\\\"\\\"\\n # Min as this is the amount of activations that can be fetched by get_item\\n return min(self.current_activations_stored_per_component)\\n\\n def __sizeof__(self) -> int:\\n \\\"\\\"\\\"Sizeof Dunder Method.\\n\\n Example:\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=2, n_neurons=100, n_components=1)\\n >>> store.__sizeof__() # Pre-allocated tensor of 2x100\\n 800\\n\\n Returns:\\n The size of the underlying tensor in bytes.\\n \\\"\\\"\\\"\\n return self._data.element_size() * self._data.nelement()\\n\\n def __getitem__(\\n self, index: tuple[int, ...] | slice | int\\n ) -> Float[Tensor, Axis.names(Axis.ANY)]:\\n \\\"\\\"\\\"Get Item Dunder Method.\\n\\n Examples:\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=2, n_neurons=5, n_components=1)\\n >>> store.append(torch.zeros(5), component_idx=0)\\n >>> store.append(torch.ones(5), component_idx=0)\\n >>> store[1, 0]\\n tensor([1., 1., 1., 1., 1.])\\n\\n Args:\\n index: The index of the tensor to fetch.\\n\\n Returns:\\n The activation store item at the given index.\\n \\\"\\\"\\\"\\n return self._data[index]\\n\\n def shuffle(self) -> None:\\n \\\"\\\"\\\"Shuffle the Data In-Place.\\n\\n This is much faster than using the shuffle argument on `torch.utils.data.DataLoader`.\\n\\n Example:\\n >>> import torch\\n >>> _seed = torch.manual_seed(42)\\n >>> store = TensorActivationStore(max_items=10, n_neurons=1, n_components=1)\\n >>> store.append(torch.tensor([0.]), component_idx=0)\\n >>> store.append(torch.tensor([1.]), component_idx=0)\\n >>> store.append(torch.tensor([2.]), component_idx=0)\\n >>> store.shuffle()\\n >>> [store[i, 0].item() for i in range(3)]\\n [0.0, 2.0, 1.0]\\n \\\"\\\"\\\"\\n # Generate a permutation of the indices for the active data\\n perm = torch.randperm(len(self))\\n\\n # Use this permutation to shuffle the active data in-place\\n self._data[: len(self)] = self._data[perm]\\n\\n def append(self, item: Float[Tensor, Axis.INPUT_OUTPUT_FEATURE], component_idx: int) -> None:\\n \\\"\\\"\\\"Add a single item to the store.\\n\\n Example:\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=10, n_neurons=5, n_components=1)\\n >>> store.append(torch.zeros(5), component_idx=0)\\n >>> store.append(torch.ones(5), component_idx=0)\\n >>> store[1, 0]\\n tensor([1., 1., 1., 1., 1.])\\n\\n Args:\\n item: The item to append to the dataset.\\n component_idx: The component index to append the item to.\\n\\n Raises:\\n IndexError: If there is no space remaining.\\n \\\"\\\"\\\"\\n # Check we have space\\n if self._items_stored[component_idx] + 1 > self._max_items:\\n raise StoreFullError\\n\\n self._data[self._items_stored[component_idx], component_idx] = item.to(\\n self._data.device,\\n )\\n self._items_stored[component_idx] += 1\\n\\n def extend(\\n self,\\n batch: Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)],\\n component_idx: int,\\n ) -> None:\\n \\\"\\\"\\\"Add a batch to the store.\\n\\n Examples:\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=10, n_neurons=5, n_components=1)\\n >>> store.extend(torch.zeros(2, 5), component_idx=0)\\n >>> len(store)\\n 2\\n\\n Args:\\n batch: The batch to append to the dataset.\\n component_idx: The component index to append the batch to.\\n\\n Raises:\\n IndexError: If there is no space remaining.\\n \\\"\\\"\\\"\\n # Check we have space\\n n_activation_tensors: int = batch.shape[0]\\n if self._items_stored[component_idx] + n_activation_tensors > self._max_items:\\n raise StoreFullError\\n\\n self._data[\\n self._items_stored[component_idx] : self._items_stored[component_idx]\\n + n_activation_tensors,\\n component_idx,\\n ] = batch.to(self._data.device)\\n self._items_stored[component_idx] += n_activation_tensors\\n\\n def empty(self) -> None:\\n \\\"\\\"\\\"Empty the store.\\n\\n Example:\\n >>> import torch\\n >>> store = TensorActivationStore(max_items=10, n_neurons=5, n_components=1)\\n >>> store.extend(torch.zeros(2, 5), component_idx=0)\\n >>> len(store)\\n 2\\n >>> store.empty()\\n >>> len(store)\\n 0\\n \\\"\\\"\\\"\\n # We don't need to zero the data, just reset the number of items stored\\n self._items_stored = [0 for _ in self._items_stored]\"\n },\n {\n \"identifier\": \"SparseAutoencoder\",\n \"path\": \"sparse_autoencoder/autoencoder/model.py\",\n \"snippet\": \"class SparseAutoencoder(Module):\\n \\\"\\\"\\\"Sparse Autoencoder Model.\\\"\\\"\\\"\\n\\n config: SparseAutoencoderConfig\\n \\\"\\\"\\\"Model config.\\\"\\\"\\\"\\n\\n geometric_median_dataset: Float[\\n Tensor, Axis.names(Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ]\\n \\\"\\\"\\\"Estimated Geometric Median of the Dataset.\\n\\n Used for initialising :attr:`tied_bias`.\\n \\\"\\\"\\\"\\n\\n tied_bias: Float[\\n Parameter, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ]\\n \\\"\\\"\\\"Tied Bias Parameter.\\n\\n The same bias is used pre-encoder and post-decoder.\\n \\\"\\\"\\\"\\n\\n pre_encoder_bias: TiedBias\\n \\\"\\\"\\\"Pre-Encoder Bias.\\\"\\\"\\\"\\n\\n encoder: LinearEncoder\\n \\\"\\\"\\\"Encoder.\\\"\\\"\\\"\\n\\n decoder: UnitNormDecoder\\n \\\"\\\"\\\"Decoder.\\\"\\\"\\\"\\n\\n post_decoder_bias: TiedBias\\n \\\"\\\"\\\"Post-Decoder Bias.\\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n config: SparseAutoencoderConfig,\\n geometric_median_dataset: Float[\\n Tensor, Axis.names(Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ]\\n | None = None,\\n ) -> None:\\n \\\"\\\"\\\"Initialize the Sparse Autoencoder Model.\\n\\n Args:\\n config: Model config.\\n geometric_median_dataset: Estimated geometric median of the dataset.\\n \\\"\\\"\\\"\\n super().__init__()\\n\\n self.config = config\\n\\n # Store the geometric median of the dataset (so that we can reset parameters). This is not a\\n # parameter itself (the tied bias parameter is used for that), so gradients are disabled.\\n tied_bias_shape = shape_with_optional_dimensions(\\n config.n_components, config.n_input_features\\n )\\n if geometric_median_dataset is not None:\\n self.geometric_median_dataset = geometric_median_dataset.clone()\\n self.geometric_median_dataset.requires_grad = False\\n else:\\n self.geometric_median_dataset = torch.zeros(tied_bias_shape)\\n self.geometric_median_dataset.requires_grad = False\\n\\n # Initialize the tied bias\\n self.tied_bias = Parameter(torch.empty(tied_bias_shape))\\n self.initialize_tied_parameters()\\n\\n # Initialize the components\\n self.pre_encoder_bias = TiedBias(self.tied_bias, TiedBiasPosition.PRE_ENCODER)\\n\\n self.encoder = LinearEncoder(\\n input_features=config.n_input_features,\\n learnt_features=config.n_learned_features,\\n n_components=config.n_components,\\n )\\n\\n self.decoder = UnitNormDecoder(\\n learnt_features=config.n_learned_features,\\n decoded_features=config.n_input_features,\\n n_components=config.n_components,\\n )\\n\\n self.post_decoder_bias = TiedBias(self.tied_bias, TiedBiasPosition.POST_DECODER)\\n\\n def forward(\\n self,\\n x: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n ) -> ForwardPassResult:\\n \\\"\\\"\\\"Forward Pass.\\n\\n Args:\\n x: Input activations (e.g. activations from an MLP layer in a transformer model).\\n\\n Returns:\\n Tuple of learned activations and decoded activations.\\n \\\"\\\"\\\"\\n x = self.pre_encoder_bias(x)\\n learned_activations = self.encoder(x)\\n x = self.decoder(learned_activations)\\n decoded_activations = self.post_decoder_bias(x)\\n\\n return ForwardPassResult(learned_activations, decoded_activations)\\n\\n def initialize_tied_parameters(self) -> None:\\n \\\"\\\"\\\"Initialize the tied parameters.\\\"\\\"\\\"\\n # The tied bias is initialised as the geometric median of the dataset\\n self.tied_bias.data = self.geometric_median_dataset\\n\\n def reset_parameters(self) -> None:\\n \\\"\\\"\\\"Reset the parameters.\\\"\\\"\\\"\\n self.initialize_tied_parameters()\\n for module in self.network:\\n if \\\"reset_parameters\\\" in dir(module):\\n module.reset_parameters()\\n\\n @property\\n def reset_optimizer_parameter_details(self) -> list[ResetOptimizerParameterDetails]:\\n \\\"\\\"\\\"Reset optimizer parameter details.\\n\\n Details of the parameters that should be reset in the optimizer, when resetting\\n dictionary vectors.\\n\\n Returns:\\n List of tuples of the form `(parameter, axis)`, where `parameter` is the parameter to\\n reset (e.g. encoder.weight), and `axis` is the axis of the parameter to reset.\\n \\\"\\\"\\\"\\n return (\\n self.encoder.reset_optimizer_parameter_details\\n + self.decoder.reset_optimizer_parameter_details\\n )\\n\\n def post_backwards_hook(self) -> None:\\n \\\"\\\"\\\"Hook to be called after each learning step.\\n\\n This can be used to e.g. constrain weights to unit norm.\\n \\\"\\\"\\\"\\n self.decoder.constrain_weights_unit_norm()\\n\\n @staticmethod\\n @validate_call\\n def get_single_component_state_dict(\\n state: SparseAutoencoderState, component_idx: NonNegativeInt\\n ) -> dict[str, Tensor]:\\n \\\"\\\"\\\"Get the state dict for a single component.\\n\\n Args:\\n state: Sparse Autoencoder state.\\n component_idx: Index of the component to get the state dict for.\\n\\n Returns:\\n State dict for the component.\\n\\n Raises:\\n ValueError: If the state dict doesn't contain a components dimension.\\n \\\"\\\"\\\"\\n # Check the state has a components dimension\\n if state.config.n_components is None:\\n error_message = (\\n \\\"Trying to load a single component from the state dict, but the state dict \\\"\\n \\\"doesn't contain a components dimension.\\\"\\n )\\n raise ValueError(error_message)\\n\\n # Return the state dict for the component\\n return {key: value[component_idx] for key, value in state.state_dict.items()}\\n\\n def save(self, file_path: Path) -> None:\\n \\\"\\\"\\\"Save the model config and state dict to a file.\\n\\n Args:\\n file_path: Path to save the model to.\\n \\\"\\\"\\\"\\n file_path.parent.mkdir(parents=True, exist_ok=True)\\n state = SparseAutoencoderState(config=self.config, state_dict=self.state_dict())\\n torch.save(state, file_path)\\n\\n @staticmethod\\n def load(\\n file_path: FILE_LIKE,\\n component_idx: PositiveInt | None = None,\\n ) -> \\\"SparseAutoencoder\\\":\\n \\\"\\\"\\\"Load the model from a file.\\n\\n Args:\\n file_path: Path to load the model from.\\n component_idx: If loading a state dict from a model that has been trained on multiple\\n components (e.g. all MLP layers) you may want to to load just one component. In this\\n case you can set `component_idx` to the index of the component to load. Note you\\n should not set this if you want to load a state dict from a model that has been\\n trained on a single component (or if you want to load all components).\\n\\n Returns:\\n The loaded model.\\n \\\"\\\"\\\"\\n # Load the file\\n serialized_state = torch.load(file_path, map_location=torch.device(\\\"cpu\\\"))\\n state = SparseAutoencoderState.model_validate(serialized_state)\\n\\n # Initialise the model\\n config = SparseAutoencoderConfig(\\n n_input_features=state.config.n_input_features,\\n n_learned_features=state.config.n_learned_features,\\n n_components=state.config.n_components if component_idx is None else None,\\n )\\n state_dict = (\\n SparseAutoencoder.get_single_component_state_dict(state, component_idx)\\n if component_idx is not None\\n else state.state_dict\\n )\\n model = SparseAutoencoder(config)\\n model.load_state_dict(state_dict)\\n\\n return model\\n\\n def save_to_wandb(\\n self,\\n artifact_name: str,\\n directory: DirectoryPath = DEFAULT_TMP_DIR,\\n ) -> str:\\n \\\"\\\"\\\"Save the model to wandb.\\n\\n Args:\\n artifact_name: A human-readable name for this artifact, which is how you can identify\\n this artifact in the UI or reference it in use_artifact calls. Names can contain\\n letters, numbers, underscores, hyphens, and dots. The name must be unique across a\\n project. Example: \\\"sweep_name 1e9 activations\\\".\\n directory: Directory to save the model to.\\n\\n Returns:\\n Name of the wandb artifact.\\n\\n Raises:\\n ValueError: If wandb is not initialised.\\n \\\"\\\"\\\"\\n # Save the file\\n directory.mkdir(parents=True, exist_ok=True)\\n file_name = artifact_name + \\\".pt\\\"\\n file_path = directory / file_name\\n self.save(file_path)\\n\\n # Upload to wandb\\n if wandb.run is None:\\n error_message = \\\"Trying to save the model to wandb, but wandb is not initialised.\\\"\\n raise ValueError(error_message)\\n artifact = wandb.Artifact(\\n artifact_name,\\n type=\\\"model\\\",\\n description=\\\"Sparse Autoencoder model state, created with `sparse_autoencoder`.\\\",\\n )\\n artifact.add_file(str(file_path), name=\\\"sae-model-state.pt\\\")\\n artifact.save()\\n wandb.log_artifact(artifact)\\n artifact.wait()\\n\\n return artifact.source_qualified_name\\n\\n @staticmethod\\n def load_from_wandb(\\n wandb_artifact_name: str,\\n component_idx: PositiveInt | None = None,\\n ) -> \\\"SparseAutoencoder\\\":\\n \\\"\\\"\\\"Load the model from wandb.\\n\\n Args:\\n wandb_artifact_name: Name of the wandb artifact to load the model from (e.g.\\n \\\"username/project/artifact_name:version\\\").\\n component_idx: If loading a state dict from a model that has been trained on multiple\\n components (e.g. all MLP layers) you may want to to load just one component. In this\\n case you can set `component_idx` to the index of the component to load. Note you\\n should not set this if you want to load a state dict from a model that has been\\n trained on a single component (or if you want to load all components).\\n\\n Returns:\\n The loaded model.\\n \\\"\\\"\\\"\\n api = wandb.Api()\\n artifact = api.artifact(wandb_artifact_name, type=\\\"model\\\")\\n download_path = artifact.download()\\n return SparseAutoencoder.load(Path(download_path) / \\\"sae-model-state.pt\\\", component_idx)\\n\\n def save_to_hugging_face(\\n self,\\n file_name: str,\\n repo_id: str,\\n directory: DirectoryPath = DEFAULT_TMP_DIR,\\n hf_access_token: str | None = None,\\n ) -> None:\\n \\\"\\\"\\\"Save the model to Hugging Face.\\n\\n Args:\\n file_name: Name of the file (e.g. \\\"model-something.pt\\\").\\n repo_id: ID of the repo to save the model to.\\n directory: Directory to save the model to.\\n hf_access_token: Hugging Face access token.\\n \\\"\\\"\\\"\\n # Save the file\\n directory.mkdir(parents=True, exist_ok=True)\\n file_path = directory / file_name\\n self.save(file_path)\\n\\n # Upload to Hugging Face\\n api = HfApi(token=hf_access_token)\\n api.upload_file(\\n path_or_fileobj=file_path,\\n path_in_repo=file_name,\\n repo_id=repo_id,\\n repo_type=\\\"model\\\",\\n )\\n\\n @staticmethod\\n def load_from_hugging_face(\\n file_name: str,\\n repo_id: str,\\n component_idx: PositiveInt | None = None,\\n ) -> \\\"SparseAutoencoder\\\":\\n \\\"\\\"\\\"Load the model from Hugging Face.\\n\\n Args:\\n file_name: File name of the .pt state file.\\n repo_id: ID of the repo to load the model from.\\n component_idx: If loading a state dict from a model that has been trained on multiple\\n components (e.g. all MLP layers) you may want to to load just one component. In this\\n case you can set `component_idx` to the index of the component to load. Note you\\n should not set this if you want to load a state dict from a model that has been\\n trained on a single component (or if you want to load all components).\\n\\n Returns:\\n The loaded model.\\n \\\"\\\"\\\"\\n local_file = hf_hub_download(\\n repo_id=repo_id,\\n repo_type=\\\"model\\\",\\n filename=file_name,\\n revision=\\\"main\\\",\\n )\\n\\n return SparseAutoencoder.load(Path(local_file), component_idx)\"\n },\n {\n \"identifier\": \"SparseAutoencoderConfig\",\n \"path\": \"sparse_autoencoder/autoencoder/model.py\",\n \"snippet\": \"class SparseAutoencoderConfig(BaseModel, frozen=True):\\n \\\"\\\"\\\"SAE model config.\\\"\\\"\\\"\\n\\n n_input_features: PositiveInt\\n \\\"\\\"\\\"Number of input features.\\n\\n E.g. `d_mlp` if training on MLP activations from TransformerLens).\\n \\\"\\\"\\\"\\n\\n n_learned_features: PositiveInt\\n \\\"\\\"\\\"Number of learned features.\\n\\n The initial paper experimented with 1 to 256 times the number of input features, and primarily\\n used a multiple of 8.\\\"\\\"\\\"\\n\\n n_components: PositiveInt | None = None\\n \\\"\\\"\\\"Number of source model components the SAE is trained on.\\\"\\\"\\n\\n This is useful if you want to train the SAE on several components of the source model at once.\\n If `None`, the SAE is assumed to be trained on just one component (in this case the model won't\\n contain a component axis in any of the parameters).\\n \\\"\\\"\\\"\"\n },\n {\n \"identifier\": \"L2ReconstructionLoss\",\n \"path\": \"sparse_autoencoder/loss/decoded_activations_l2.py\",\n \"snippet\": \"class L2ReconstructionLoss(AbstractLoss):\\n \\\"\\\"\\\"L2 Reconstruction loss.\\n\\n L2 reconstruction loss is calculated as the sum squared error between each each input vector\\n and it's corresponding decoded vector. The original paper found that models trained with some\\n loss functions such as cross-entropy loss generally prefer to represent features\\n polysemantically, whereas models trained with L2 may achieve the same loss for both\\n polysemantic and monosemantic representations of true features.\\n\\n Example:\\n >>> import torch\\n >>> loss = L2ReconstructionLoss()\\n >>> input_activations = torch.tensor([[5.0, 4], [3.0, 4]])\\n >>> output_activations = torch.tensor([[1.0, 5], [1.0, 5]])\\n >>> unused_activations = torch.zeros_like(input_activations)\\n >>> # Outputs both loss and metrics to log\\n >>> loss.forward(input_activations, unused_activations, output_activations)\\n tensor([8.5000, 2.5000])\\n \\\"\\\"\\\"\\n\\n _reduction: LossReductionType\\n \\\"\\\"\\\"MSE reduction type.\\\"\\\"\\\"\\n\\n def __init__(self, reduction: LossReductionType = LossReductionType.MEAN) -> None:\\n \\\"\\\"\\\"Initialise the L2 reconstruction loss.\\n\\n Args:\\n reduction: MSE reduction type.\\n \\\"\\\"\\\"\\n super().__init__()\\n self._reduction = reduction\\n\\n def log_name(self) -> str:\\n \\\"\\\"\\\"Log name.\\n\\n Returns:\\n Name of the loss module for logging.\\n \\\"\\\"\\\"\\n return \\\"l2_reconstruction_loss\\\"\\n\\n def forward(\\n self,\\n source_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n learned_activations: Float[ # noqa: ARG002\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\\n ],\\n decoded_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n ) -> (\\n Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]\\n | Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)]\\n ):\\n \\\"\\\"\\\"Calculate the L2 reconstruction loss.\\n\\n Args:\\n source_activations: Source activations (input activations to the autoencoder from the\\n source model).\\n learned_activations: Learned activations (intermediate activations in the autoencoder).\\n decoded_activations: Decoded activations.\\n\\n Returns:\\n Loss per batch item.\\n \\\"\\\"\\\"\\n square_error_loss = mse_loss(source_activations, decoded_activations, reduction=\\\"none\\\")\\n\\n match self._reduction:\\n case LossReductionType.MEAN:\\n return square_error_loss.mean(dim=-1)\\n case LossReductionType.SUM:\\n return square_error_loss.sum(dim=-1)\\n case LossReductionType.NONE:\\n return square_error_loss\"\n },\n {\n \"identifier\": \"LearnedActivationsL1Loss\",\n \"path\": \"sparse_autoencoder/loss/learned_activations_l1.py\",\n \"snippet\": \"class LearnedActivationsL1Loss(AbstractLoss):\\n \\\"\\\"\\\"Learned activations L1 (absolute error) loss.\\n\\n L1 loss penalty is the absolute sum of the learned activations. The L1 penalty is this\\n multiplied by the l1_coefficient (designed to encourage sparsity).\\n\\n Example:\\n >>> l1_loss = LearnedActivationsL1Loss(0.1)\\n >>> learned_activations = torch.tensor([[2.0, -3], [2.0, -3]])\\n >>> unused_activations = torch.zeros_like(learned_activations)\\n >>> # Returns loss and metrics to log\\n >>> l1_loss.forward(unused_activations, learned_activations, unused_activations)[0]\\n tensor(0.5000)\\n \\\"\\\"\\\"\\n\\n l1_coefficient: float | Float[Tensor, Axis.names(Axis.COMPONENT_OPTIONAL)]\\n \\\"\\\"\\\"L1 coefficient.\\\"\\\"\\\"\\n\\n def log_name(self) -> str:\\n \\\"\\\"\\\"Log name.\\n\\n Returns:\\n Name of the loss module for logging.\\n \\\"\\\"\\\"\\n return \\\"learned_activations_l1_loss_penalty\\\"\\n\\n @validate_call(config={\\\"arbitrary_types_allowed\\\": True})\\n def __init__(\\n self, l1_coefficient: PositiveFloat | Float[Tensor, Axis.names(Axis.COMPONENT_OPTIONAL)]\\n ) -> None:\\n \\\"\\\"\\\"Initialize the absolute error loss.\\n\\n Args:\\n l1_coefficient: L1 coefficient. The original paper experimented with L1 coefficients of\\n [0.01, 0.008, 0.006, 0.004, 0.001]. They used 250 tokens per prompt, so as an\\n approximate guide if you use e.g. 2x this number of tokens you might consider using\\n 0.5x the l1 coefficient.\\n \\\"\\\"\\\"\\n self.l1_coefficient = l1_coefficient\\n super().__init__()\\n\\n def _l1_loss(\\n self,\\n source_activations: Float[ # noqa: ARG002\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n learned_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\\n ],\\n decoded_activations: Float[ # noqa: ARG002s\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n ) -> _L1LossAndPenalty:\\n \\\"\\\"\\\"Learned activations L1 (absolute error) loss.\\n\\n Args:\\n source_activations: Source activations (input activations to the autoencoder from the\\n source model).\\n learned_activations: Learned activations (intermediate activations in the autoencoder).\\n decoded_activations: Decoded activations.\\n\\n Returns:\\n Tuple of itemwise absolute loss, and itemwise absolute loss multiplied by the l1\\n coefficient.\\n \\\"\\\"\\\"\\n # Absolute loss is the summed absolute value of the learned activations (i.e. over the\\n # learned feature axis).\\n itemwise_absolute_loss: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)\\n ] = torch.abs(learned_activations).sum(dim=-1)\\n\\n itemwise_absolute_loss_penalty: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)\\n ] = itemwise_absolute_loss * self.l1_coefficient\\n\\n return _L1LossAndPenalty(\\n itemwise_absolute_loss=itemwise_absolute_loss,\\n itemwise_absolute_loss_penalty=itemwise_absolute_loss_penalty,\\n )\\n\\n def forward(\\n self,\\n source_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n learned_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\\n ],\\n decoded_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n ) -> Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]:\\n \\\"\\\"\\\"Learned activations L1 (absolute error) loss.\\n\\n Args:\\n source_activations: Source activations (input activations to the autoencoder from the\\n source model).\\n learned_activations: Learned activations (intermediate activations in the autoencoder).\\n decoded_activations: Decoded activations.\\n\\n Returns:\\n Loss per batch item.\\n \\\"\\\"\\\"\\n return self._l1_loss(\\n source_activations, learned_activations, decoded_activations\\n ).itemwise_absolute_loss_penalty\\n\\n # Override to add both the loss and the penalty to the log\\n def scalar_loss_with_log(\\n self,\\n source_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n learned_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\\n ],\\n decoded_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n batch_reduction: LossReductionType = LossReductionType.MEAN,\\n component_reduction: LossReductionType = LossReductionType.NONE,\\n ) -> LossResultWithMetrics:\\n \\\"\\\"\\\"Scalar L1 loss (reduced across the batch and component axis) with logging.\\n\\n Args:\\n source_activations: Source activations (input activations to the autoencoder from the\\n source model).\\n learned_activations: Learned activations (intermediate activations in the autoencoder).\\n decoded_activations: Decoded activations.\\n batch_reduction: Batch reduction type. Typically you would choose LossReductionType.MEAN\\n to make the loss independent of the batch size.\\n component_reduction: Component reduction type.\\n\\n Returns:\\n Tuple of the L1 absolute error batch scalar loss and a dict of the properties to log\\n (loss before and after the l1 coefficient).\\n\\n Raises:\\n ValueError: If batch_reduction is LossReductionType.NONE.\\n \\\"\\\"\\\"\\n itemwise_absolute_loss, itemwise_absolute_loss_penalty = self._l1_loss(\\n source_activations, learned_activations, decoded_activations\\n )\\n\\n match batch_reduction:\\n case LossReductionType.MEAN:\\n batch_scalar_loss = itemwise_absolute_loss.mean(0)\\n batch_scalar_loss_penalty = itemwise_absolute_loss_penalty.mean(0)\\n case LossReductionType.SUM:\\n batch_scalar_loss = itemwise_absolute_loss.sum(0)\\n batch_scalar_loss_penalty = itemwise_absolute_loss_penalty.sum(0)\\n case LossReductionType.NONE:\\n error_message = \\\"Batch reduction type NONE not supported.\\\"\\n raise ValueError(error_message)\\n\\n # Create the log\\n metrics: list[MetricResult] = [\\n MetricResult(\\n name=\\\"loss\\\",\\n postfix=\\\"learned_activations_l1\\\",\\n component_wise_values=batch_scalar_loss.unsqueeze(0)\\n if batch_scalar_loss.ndim == 0\\n else batch_scalar_loss,\\n location=MetricLocation.TRAIN,\\n ),\\n MetricResult(\\n name=\\\"loss\\\",\\n postfix=self.log_name(),\\n component_wise_values=batch_scalar_loss_penalty.unsqueeze(0)\\n if batch_scalar_loss_penalty.ndim == 0\\n else batch_scalar_loss_penalty,\\n location=MetricLocation.TRAIN,\\n ),\\n ]\\n\\n match component_reduction:\\n case LossReductionType.MEAN:\\n batch_scalar_loss_penalty = batch_scalar_loss_penalty.mean(0)\\n case LossReductionType.SUM:\\n batch_scalar_loss_penalty = batch_scalar_loss_penalty.sum(0)\\n case LossReductionType.NONE:\\n pass\\n\\n return LossResultWithMetrics(loss=batch_scalar_loss_penalty, loss_metrics=metrics)\\n\\n def extra_repr(self) -> str:\\n \\\"\\\"\\\"Extra representation string.\\\"\\\"\\\"\\n return f\\\"l1_coefficient={self.l1_coefficient}\\\"\"\n },\n {\n \"identifier\": \"LossReducer\",\n \"path\": \"sparse_autoencoder/loss/reducer.py\",\n \"snippet\": \"class LossReducer(AbstractLoss):\\n \\\"\\\"\\\"Loss reducer.\\n\\n Reduces multiple loss algorithms into a single loss algorithm (by summing). Analogous to\\n nn.Sequential.\\n\\n Example:\\n >>> from sparse_autoencoder.loss.decoded_activations_l2 import L2ReconstructionLoss\\n >>> from sparse_autoencoder.loss.learned_activations_l1 import LearnedActivationsL1Loss\\n >>> LossReducer(\\n ... L2ReconstructionLoss(),\\n ... LearnedActivationsL1Loss(0.001),\\n ... )\\n LossReducer(\\n (0): L2ReconstructionLoss()\\n (1): LearnedActivationsL1Loss(l1_coefficient=0.001)\\n )\\n\\n \\\"\\\"\\\"\\n\\n _modules: dict[str, \\\"AbstractLoss\\\"]\\n \\\"\\\"\\\"Children loss modules.\\\"\\\"\\\"\\n\\n def log_name(self) -> str:\\n \\\"\\\"\\\"Log name.\\n\\n Returns:\\n Name of the loss module for logging.\\n \\\"\\\"\\\"\\n return \\\"total_loss\\\"\\n\\n def __init__(\\n self,\\n *loss_modules: AbstractLoss,\\n ):\\n \\\"\\\"\\\"Initialize the loss reducer.\\n\\n Args:\\n *loss_modules: Loss modules to reduce.\\n\\n Raises:\\n ValueError: If the loss reducer has no loss modules.\\n \\\"\\\"\\\"\\n super().__init__()\\n\\n for idx, loss_module in enumerate(loss_modules):\\n self._modules[str(idx)] = loss_module\\n\\n if len(self) == 0:\\n error_message = \\\"Loss reducer must have at least one loss module.\\\"\\n raise ValueError(error_message)\\n\\n def forward(\\n self,\\n source_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n learned_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.LEARNT_FEATURE)\\n ],\\n decoded_activations: Float[\\n Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL, Axis.INPUT_OUTPUT_FEATURE)\\n ],\\n ) -> Float[Tensor, Axis.names(Axis.BATCH, Axis.COMPONENT_OPTIONAL)]:\\n \\\"\\\"\\\"Reduce loss.\\n\\n Args:\\n source_activations: Source activations (input activations to the autoencoder from the\\n source model).\\n learned_activations: Learned activations (intermediate activations in the autoencoder).\\n decoded_activations: Decoded activations.\\n\\n Returns:\\n Mean loss across the batch, summed across the loss modules.\\n \\\"\\\"\\\"\\n all_modules_loss: Float[Tensor, \\\"module train_batch\\\"] = torch.stack(\\n [\\n loss_module.forward(source_activations, learned_activations, decoded_activations)\\n for loss_module in self._modules.values()\\n ]\\n )\\n\\n return all_modules_loss.sum(dim=0)\\n\\n def __dir__(self) -> list[str]:\\n \\\"\\\"\\\"Dir dunder method.\\\"\\\"\\\"\\n return list(self._modules.__dir__())\\n\\n def __getitem__(self, idx: int) -> AbstractLoss:\\n \\\"\\\"\\\"Get item dunder method.\\\"\\\"\\\"\\n return self._modules[str(idx)]\\n\\n def __iter__(self) -> Iterator[AbstractLoss]:\\n \\\"\\\"\\\"Iterator dunder method.\\\"\\\"\\\"\\n return iter(self._modules.values())\\n\\n def __len__(self) -> int:\\n \\\"\\\"\\\"Length dunder method.\\\"\\\"\\\"\\n return len(self._modules)\"\n },\n {\n \"identifier\": \"Axis\",\n \"path\": \"sparse_autoencoder/tensor_types.py\",\n \"snippet\": \"class Axis(LowercaseStrEnum):\\n \\\"\\\"\\\"Tensor axis names.\\n\\n Used to annotate tensor types.\\n\\n Example:\\n When used directly it prints a string:\\n\\n >>> print(Axis.INPUT_OUTPUT_FEATURE)\\n input_output_feature\\n\\n The primary use is to annotate tensor types:\\n\\n >>> from jaxtyping import Float\\n >>> from torch import Tensor\\n >>> from typing import TypeAlias\\n >>> batch: TypeAlias = Float[Tensor, Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE)]\\n >>> print(batch)\\n <class 'jaxtyping.Float[Tensor, 'batch input_output_feature']'>\\n\\n You can also join multiple axis together to represent the dimensions of a tensor:\\n\\n >>> print(Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE))\\n batch input_output_feature\\n \\\"\\\"\\\"\\n\\n # Component idx\\n COMPONENT = auto()\\n \\\"\\\"\\\"Component index.\\\"\\\"\\\"\\n\\n COMPONENT_OPTIONAL = \\\"*component\\\"\\n \\\"\\\"\\\"Optional component index.\\\"\\\"\\\"\\n\\n # Batches\\n SOURCE_DATA_BATCH = auto()\\n \\\"\\\"\\\"Batch of prompts used to generate source model activations.\\\"\\\"\\\"\\n\\n BATCH = auto()\\n \\\"\\\"\\\"Batch of items that the SAE is being trained on.\\\"\\\"\\\"\\n\\n STORE_BATCH = auto()\\n \\\"\\\"\\\"Batch of items to be written to the store.\\\"\\\"\\\"\\n\\n ITEMS = auto()\\n \\\"\\\"\\\"Arbitrary number of items.\\\"\\\"\\\"\\n\\n # Features\\n INPUT_OUTPUT_FEATURE = auto()\\n \\\"\\\"\\\"Input or output feature (e.g. feature in activation vector from source model).\\\"\\\"\\\"\\n\\n LEARNT_FEATURE = auto()\\n \\\"\\\"\\\"Learn feature (e.g. feature in learnt activation vector).\\\"\\\"\\\"\\n\\n DEAD_FEATURE = auto()\\n \\\"\\\"\\\"Dead feature.\\\"\\\"\\\"\\n\\n ALIVE_FEATURE = auto()\\n \\\"\\\"\\\"Alive feature.\\\"\\\"\\\"\\n\\n # Feature indices\\n INPUT_OUTPUT_FEATURE_IDX = auto()\\n \\\"\\\"\\\"Input or output feature index.\\\"\\\"\\\"\\n\\n LEARNT_FEATURE_IDX = auto()\\n \\\"\\\"\\\"Learn feature index.\\\"\\\"\\\"\\n\\n # Other\\n POSITION = auto()\\n \\\"\\\"\\\"Token position.\\\"\\\"\\\"\\n\\n SINGLE_ITEM = \\\"\\\"\\n \\\"\\\"\\\"Single item axis.\\\"\\\"\\\"\\n\\n ANY = \\\"...\\\"\\n \\\"\\\"\\\"Any number of axis.\\\"\\\"\\\"\\n\\n @staticmethod\\n def names(*axis: \\\"Axis\\\") -> str:\\n \\\"\\\"\\\"Join multiple axis together, to represent the dimensions of a tensor.\\n\\n Example:\\n >>> print(Axis.names(Axis.BATCH, Axis.INPUT_OUTPUT_FEATURE))\\n batch input_output_feature\\n\\n Args:\\n *axis: Axis to join.\\n\\n Returns:\\n Joined axis string.\\n \\\"\\\"\\\"\\n return \\\" \\\".join(a.value for a in axis)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from jaxtyping import Float, Int64\nfrom torch import Tensor\nfrom torch.nn import Parameter\nfrom sparse_autoencoder.activation_resampler.activation_resampler import ActivationResampler\nfrom sparse_autoencoder.activation_store.base_store import ActivationStore\nfrom sparse_autoencoder.activation_store.tensor_store import TensorActivationStore\nfrom sparse_autoencoder.autoencoder.model import SparseAutoencoder, SparseAutoencoderConfig\nfrom sparse_autoencoder.loss.decoded_activations_l2 import L2ReconstructionLoss\nfrom sparse_autoencoder.loss.learned_activations_l1 import LearnedActivationsL1Loss\nfrom sparse_autoencoder.loss.reducer import LossReducer\nfrom sparse_autoencoder.tensor_types import Axis\nimport pytest\nimport torch"},"token_num":{"kind":"number","value":16481,"string":"16,481"},"cropped_code":{"kind":"string","value":"\"\"\"Tests for the resample_neurons module.\"\"\"\n\n\n\n\nDEFAULT_N_ACTIVATIONS_STORE: int = 100\nDEFAULT_N_INPUT_FEATURES: int = 3\nDEFAULT_N_LEARNED_FEATURES: int = 5\nDEFAULT_N_COMPONENTS: int = 2\n\n\n@pytest.fixture()\ndef full_activation_store() -> ActivationStore:\n \"\"\"Create a dummy activation store, pre-populated with data.\"\"\"\n store = TensorActivationStore(\n max_items=DEFAULT_N_ACTIVATIONS_STORE,\n n_components=DEFAULT_N_COMPONENTS,\n n_neurons=DEFAULT_N_INPUT_FEATURES,\n )\n store.fill_with_test_data(\n batch_size=DEFAULT_N_ACTIVATIONS_STORE,\n input_features=DEFAULT_N_INPUT_FEATURES,\n n_batches=1,\n n_components=DEFAULT_N_COMPONENTS,\n )\n return store\n\n\n@pytest.fixture()\ndef autoencoder_model() -> SparseAutoencoder:\n \"\"\"Create a dummy autoencoder model.\"\"\"\n return SparseAutoencoder(\n"},"all_code":{"kind":"string","value":"\"\"\"Tests for the resample_neurons module.\"\"\"\n\n\n\n\nDEFAULT_N_ACTIVATIONS_STORE: int = 100\nDEFAULT_N_INPUT_FEATURES: int = 3\nDEFAULT_N_LEARNED_FEATURES: int = 5\nDEFAULT_N_COMPONENTS: int = 2\n\n\n@pytest.fixture()\ndef full_activation_store() -> ActivationStore:\n \"\"\"Create a dummy activation store, pre-populated with data.\"\"\"\n store = TensorActivationStore(\n max_items=DEFAULT_N_ACTIVATIONS_STORE,\n n_components=DEFAULT_N_COMPONENTS,\n n_neurons=DEFAULT_N_INPUT_FEATURES,\n )\n store.fill_with_test_data(\n batch_size=DEFAULT_N_ACTIVATIONS_STORE,\n input_features=DEFAULT_N_INPUT_FEATURES,\n n_batches=1,\n n_components=DEFAULT_N_COMPONENTS,\n )\n return store\n\n\n@pytest.fixture()\ndef autoencoder_model() -> SparseAutoencoder:\n \"\"\"Create a dummy autoencoder model.\"\"\"\n return SparseAutoencoder("},"next_line":{"kind":"string","value":" SparseAutoencoderConfig("},"gold_snippet_index":{"kind":"number","value":4,"string":"4"},"created_at":{"kind":"string","value":"2023-10-27 07:37:15+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5689,"cells":{"repo_name":{"kind":"string","value":"OATML-Markslab/ProteinNPT"},"file_path":{"kind":"string","value":"scripts/train.py"},"context":{"kind":"list like","value":[{"identifier":"ProteinNPTModel","path":"proteinnpt/model.py","snippet":"class ProteinNPTModel(nn.Module):\n def __init__(self, args, alphabet):\n super().__init__()\n self.args = args\n self.alphabet = alphabet\n self.alphabet_size = len(alphabet)\n self.padding_idx = alphabet.padding_idx\n self.mask_idx = alphabet.mask_idx\n self.cls_idx = alphabet.cls_idx\n self.eos_idx = alphabet.eos_idx\n self.prepend_bos = alphabet.prepend_bos\n self.append_eos = alphabet.append_eos\n self.target_names_input = self.args.target_config.keys()\n self.target_names = [x for x in self.args.target_config.keys() if self.args.target_config[x][\"in_NPT_loss\"]]\n self.num_targets_input = len(self.target_names_input) #Includes all targets, incl. zero-shot fitness predictions\n self.num_targets = len(self.target_names) #Number of actual targets we want to predict\n self.MSA_sample_sequences = None\n self.training_sample_sequences_indices = None\n self.device = None\n self.optimizer = None\n self.model_type = args.model_type\n self.PNPT_ensemble_test_num_seeds = -1\n self.PNPT_no_reconstruction_error = False\n self.deactivate_col_attention = False\n self.tranception_attention = False\n \n assert self.args.embed_dim % self.args.attention_heads ==0, \"Embedding size {} needs to be a multiple of number of heads {}\".format(self.args.embed_dim, self.args.attention_heads)\n if self.args.aa_embeddings in [\"MSA_Transformer\",\"ESM1v\"]:\n model, _ = utils.esm.pretrained.load_model_and_alphabet(args.embedding_model_location)\n self.aa_embedding = model\n self.aa_embedding_dim = self.aa_embedding.embed_tokens.weight.shape[-1]\n elif self.args.aa_embeddings == \"Tranception\":\n self.aa_embedding_dim = 1280\n config = json.load(open(args.embedding_model_location+os.sep+'config.json'))\n config = utils.tranception.config.TranceptionConfig(**config)\n config.tokenizer = self.alphabet\n config.inference_time_retrieval_type = None\n config.retrieval_aggregation_mode = None\n self.aa_embedding = utils.tranception.model_pytorch.TranceptionLMHeadModel.from_pretrained(pretrained_model_name_or_path=args.embedding_model_location,config=config)\n elif self.args.aa_embeddings == \"Linear_embedding\":\n self.aa_embedding = nn.Embedding(\n self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx\n )\n self.aa_positions_embedding = LearnedPositionalEmbedding(\n self.args.max_positions,\n self.args.embed_dim,\n self.padding_idx,\n )\n self.aa_embedding_dim = self.args.embed_dim\n\n if self.aa_embedding_dim != self.args.embed_dim: #Need to project internally\n self.token_embedding_projection = nn.Linear(\n self.aa_embedding_dim,\n self.args.embed_dim\n )\n self.token_embedding_expansion = nn.Linear(\n self.args.embed_dim,\n self.aa_embedding_dim\n )\n\n self.target_embedding = nn.ModuleDict(\n { \n target_name:\n nn.Linear(\n self.args.target_config[target_name][\"dim\"] + 1, #Need to add one as we append the mask flag to each input target \n self.args.embed_dim\n )\n if self.args.target_config[target_name][\"type\"]==\"continuous\"\n else \n nn.Embedding(\n self.args.target_config[target_name][\"dim\"],\n self.args.embed_dim\n )\n for target_name in self.target_names_input\n }\n )\n \n self.dropout_module = nn.Dropout(self.args.dropout)\n\n self.layers = nn.ModuleList(\n [\n AxialTransformerLayer(\n self.args.embed_dim,\n self.args.ffn_embed_dim,\n self.args.attention_heads,\n self.args.dropout,\n self.args.attention_dropout,\n self.args.activation_dropout,\n getattr(self.args, \"max_tokens_per_msa\", self.args.max_tokens_per_msa),\n self.deactivate_col_attention,\n self.tranception_attention,\n self.num_targets_input,\n )\n for _ in range(self.args.num_protein_npt_layers)\n ]\n )\n self.emb_layer_norm_before = ESM1bLayerNorm(self.args.embed_dim)\n self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)\n \n if self.args.aa_embeddings in [\"MSA_Transformer\",\"ESM1v\"]:\n weight = self.aa_embedding.embed_tokens.weight\n elif self.args.aa_embeddings == \"Tranception\":\n weight = self.aa_embedding.lm_head.weight\n else:\n weight = self.aa_embedding.weight\n\n self.lm_head = RobertaLMHead(\n embed_dim=self.aa_embedding_dim,\n output_dim=self.alphabet_size,\n weight=weight\n )\n \n target_pred_input_dim = self.args.embed_dim\n\n if args.target_prediction_model==\"MLP\": \n self.layer_pre_head = nn.ModuleDict(\n {\n target_name:\n nn.Sequential(\n nn.Linear(target_pred_input_dim, target_pred_input_dim),\n nn.Dropout(self.args.dropout),\n nn.ReLU()\n ) \n for target_name in self.target_names\n }\n )\n \n if args.target_prediction_model==\"ConvBERT\":\n configuration = ConvBertConfig(\n hidden_size = self.args.embed_dim,\n num_attention_heads = self.args.attention_heads,\n conv_kernel_size = self.args.conv_kernel_size,\n hidden_act = \"gelu\",\n hidden_dropout_prob = self.args.dropout,\n attention_probs_dropout_prob = self.args.dropout\n )\n self.layer_pre_head = ConvBertLayer(configuration)\n \n if args.target_prediction_model==\"CNN\":\n self.layer_pre_head = nn.Sequential(\n nn.Conv1d(in_channels=target_pred_input_dim, out_channels=target_pred_input_dim, kernel_size = self.args.conv_kernel_size, padding='same'),\n nn.Dropout(self.args.dropout),\n nn.ReLU()\n )\n \n if self.args.target_prediction_head == \"Target_embeddings_only\":\n target_pred_input_dim = target_pred_input_dim\n elif self.args.target_prediction_head == \"Target_embeddings_and_AA_embeddings_mean_pooled\":\n target_pred_input_dim = target_pred_input_dim * (1 + self.num_targets_input)\n\n if self.args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n self.zero_shot_fitness_prediction_weight = nn.ModuleDict(\n { \n target_name: nn.Linear(1, self.args.target_config[target_name][\"dim\"], bias=False)\n for target_name in self.target_names\n }\n )\n for target_name in self.target_names:\n torch.nn.init.constant_(self.zero_shot_fitness_prediction_weight[target_name].weight,1e-4)\n\n self.target_pred_head = nn.ModuleDict(\n { \n target_name: nn.Linear(target_pred_input_dim, self.args.target_config[target_name][\"dim\"])\n for target_name in self.target_names\n }\n )\n \n def set_device(self):\n if self.device is None:\n self.device = next(self.parameters()).device\n print(\"Model device: {}\".format(self.device))\n \n def forward(self, tokens, targets=None, zero_shot_fitness_predictions=None, sequence_embeddings=None, repr_layers=[], need_head_weights=False):\n padding_mask = tokens.eq(self.padding_idx) \n if not padding_mask.any(): padding_mask = None\n \n if self.args.aa_embeddings == \"MSA_Transformer\" and self.args.sequence_embeddings_location is None:\n assert tokens.ndim == 3, \"Finding dimension of tokens to be: {}\".format(tokens.ndim)\n num_MSAs_in_batch, num_sequences_in_alignments, seqlen = tokens.size() # N, B, L (seqs with labels, seqs in MSA, seq length)\n batch_size = num_MSAs_in_batch\n else:\n assert tokens.ndim == 2, \"Finding dimension of tokens to be: {}\".format(tokens.ndim)\n batch_size, seqlen = tokens.size() # N, L (seqs with labels, seq length)\n \n if sequence_embeddings is not None:\n x = sequence_embeddings.to(self.device)\n else:\n if self.args.aa_embeddings == \"MSA_Transformer\":\n output = self.aa_embedding(tokens, repr_layers=[12])\n x = output[\"representations\"][12][:] # N, B, L, D\n x = x[:,0,:,:] # N, L, D. #In each MSA batch the first sequence is what we care about. The other MSA sequences were just to compute embeddings and logits\n elif self.args.aa_embeddings == \"ESM1v\":\n last_layer_index = 33\n output = self.aa_embedding(tokens, repr_layers=[last_layer_index])\n x = output[\"representations\"][last_layer_index][:] # N, L, D\n elif self.args.aa_embeddings ==\"Linear_embedding\":\n x = self.aa_embedding(tokens)\n x = x + self.aa_positions_embedding(tokens.view(batch_size, seqlen)).view(x.size()) # Need position embedding in PNPT since we will apply axial attention\n else:\n print(\"AA embeddings not recognized\")\n sys.exit(0)\n \n if self.aa_embedding_dim != self.args.embed_dim: x = self.token_embedding_projection(x)\n \n if self.args.target_prediction_head != \"Target_embeddings_and_AA_embeddings_mean_pooled\": #We mix AA embeddings pre NPT\n if self.args.target_prediction_model == \"CNN\": \n assert len(x.size())==3, \"Size error input\"\n N, L, D = x.size()\n x = x.permute(0,2,1) #N, D, L\n x = self.layer_pre_head(x)\n x = x.permute(0,2,1)\n elif self.args.target_prediction_model == \"ConvBERT\":\n x = self.layer_pre_head(x)[0]\n\n x = x.view(1, batch_size, seqlen, self.args.embed_dim) # 1, N, L, D\n \n #Dimensions for each target (there are self.num_targets of them):\n y = []\n for target_name in self.target_names_input:\n num_sequences_with_target, dim_targets = targets[target_name].shape # N, D_t #In most cases dim_targets = D_t = 2 (original dimension of continuous input + 1 dim for mask)\n y.append(self.target_embedding[target_name](targets[target_name]).view(num_sequences_with_target,1,self.args.embed_dim))\n y = torch.cat(y, dim=-2) #concatenate across second to last dimension # N, num_targets, D\n assert y.shape == (num_sequences_with_target, self.num_targets_input, self.args.embed_dim), \"Error in y shape: {}\".format(y.shape)\n y = y.view(1, num_sequences_with_target, self.num_targets_input, self.args.embed_dim) # 1, N, num_targets, D\n \n #Concatenate AA tokens and targets\n x = torch.cat((x,y),dim=-2) # 1, N, (L+num_targets), D\n x = self.emb_layer_norm_before(x)\n x = self.dropout_module(x)\n\n if padding_mask is not None:\n padding_mask_with_targets = torch.zeros(num_MSAs_in_batch, num_sequences_in_alignments, seqlen + self.num_targets_input)\n padding_mask_with_targets[...,:seqlen] = padding_mask\n padding_mask = padding_mask_with_targets\n x = x * (1 - padding_mask.unsqueeze(-1).type_as(x))\n \n repr_layers = set(repr_layers)\n hidden_representations = {}\n if 0 in repr_layers: hidden_representations[0] = x\n if need_head_weights:\n row_attn_weights = []\n col_attn_weights = []\n\n # 1 x N x L x D -> N x L x 1 x D\n x = x.permute(1, 2, 0, 3)\n for layer_idx, layer in enumerate(self.layers):\n x = layer(\n x,\n self_attn_padding_mask=padding_mask,\n need_head_weights=need_head_weights,\n )\n if need_head_weights:\n x, col_attn, row_attn = x\n col_attn_weights.append(col_attn.permute(2, 0, 1, 3, 4).cpu())\n row_attn_weights.append(row_attn.permute(1, 0, 2, 3).cpu())\n if (layer_idx + 1) in repr_layers:\n hidden_representations[layer_idx + 1] = x.permute(2, 0, 1, 3)\n x = self.emb_layer_norm_after(x)\n x = x.permute(2, 0, 1, 3) # N x L x 1 x D -> 1 x N x L x D\n assert x.shape == (1, num_sequences_with_target, seqlen + self.num_targets_input, self.args.embed_dim), \"Error with axial transformer\"\n # last hidden representation should have layer norm applied\n if (layer_idx + 1) in repr_layers: hidden_representations[layer_idx + 1] = x\n \n # Loss over NPT MLM objective\n if self.aa_embedding_dim != self.args.embed_dim:\n logits_protein_sequence = self.lm_head(self.token_embedding_expansion(x[...,:seqlen,:]))\n else:\n logits_protein_sequence = self.lm_head(x[...,:seqlen,:]) #Remove dependency on targets for final AA predictions. logits size: (1, N, L, Vocab)\n \n x = x.view(num_sequences_with_target, seqlen + self.num_targets_input, self.args.embed_dim)\n x, y = x[:,:seqlen,:], x[:,seqlen:,:] # (N,L,D) and (N,num_targets,D)\n assert y.shape == (num_sequences_with_target, self.num_targets_input, self.args.embed_dim)\n if self.args.target_prediction_head == \"Target_embeddings_and_AA_embeddings_mean_pooled\": \n if self.args.target_prediction_model == \"CNN\": \n assert len(x.size())==3, \"Size error input\"\n N, L, D = x.size()\n x = x.permute(0,2,1) #N, D, L\n x = self.layer_pre_head(x)\n x = x.permute(0,2,1)\n elif self.args.target_prediction_model == \"ConvBERT\":\n x = self.layer_pre_head(x)[0]\n x = x.mean(dim=-2) # N, D\n y = y.view(num_sequences_with_target,self.num_targets_input * self.args.embed_dim)\n y = torch.cat((x,y),dim=-1) # N, (1+num_targets) * D\n \n target_predictions = {}\n for target_index, target_name in enumerate(self.target_names):\n if self.args.target_prediction_head == \"Target_embeddings_and_AA_embeddings_mean_pooled\": \n target_predictions[target_name] = self.target_pred_head[target_name](y).view(-1) #We use the concatenated X and target embeddings (all of them) to predict each target\n else:\n if self.args.target_prediction_model == \"MLP\": y[:,target_index,:] = self.layer_pre_head[target_name](y[:,target_index,:])\n target_predictions[target_name] = self.target_pred_head[target_name](y[:,target_index,:]).view(-1) #input the embedding with the relevant target_index\n if self.args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n target_predictions[target_name] += self.zero_shot_fitness_prediction_weight[target_name](zero_shot_fitness_predictions).squeeze()\n \n result = {\"logits_protein_sequence\": logits_protein_sequence, \"target_predictions\": target_predictions, \"representations\": hidden_representations}\n \n if need_head_weights:\n col_attentions = torch.stack(col_attn_weights, 1)\n row_attentions = torch.stack(row_attn_weights, 1)\n result[\"col_attentions\"] = col_attentions\n result[\"row_attentions\"] = row_attentions\n\n return result\n\n def forward_with_uncertainty(self, tokens, targets, zero_shot_fitness_predictions=None, sequence_embeddings=None, num_MC_dropout_samples=10, number_of_mutated_seqs_to_score=None):\n \"\"\"\n Performs MC dropout to compute predictions and the corresponding uncertainties.\n Assumes 1D predictions (eg., prediction of continuous output)\n \"\"\"\n self.eval() \n for m in self.modules(): #Move all dropout layers in train mode to support MC dropout. Keep everything else in eval mode.\n if m.__class__.__name__.startswith('Dropout'):\n m.train()\n with torch.no_grad():\n predictions_dict = defaultdict(list)\n for _ in range(num_MC_dropout_samples):\n target_predictions_sample = self.forward(tokens, targets, zero_shot_fitness_predictions=zero_shot_fitness_predictions, sequence_embeddings=sequence_embeddings)[\"target_predictions\"]\n for target_name in self.target_names:\n predictions_dict[target_name].append(target_predictions_sample[target_name])\n results_with_uncertainty={}\n for target_name in self.target_names:\n concatenated_target_pred = torch.cat([x.view(-1,1) for x in predictions_dict[target_name]],dim=-1)\n results_with_uncertainty[target_name] = {}\n results_with_uncertainty[target_name]['predictions_avg'] = concatenated_target_pred.mean(dim=-1)\n results_with_uncertainty[target_name]['uncertainty'] = concatenated_target_pred.std(dim=-1)\n return results_with_uncertainty\n \n @property\n def num_layers(self):\n return self.args.num_protein_npt_layers\n \n def max_tokens_per_msa_(self, value: int) -> None:\n \"\"\"\n Batching attention computations when gradients are disabled as per MSA_Transformer\n Set this value to infinity to disable this behavior.\n \"\"\"\n for module in self.modules():\n if isinstance(module, (RowSelfAttention, ColumnSelfAttention)):\n module.max_tokens_per_msa = value\n\n def protein_npt_loss(self, token_predictions_logits, token_labels, target_predictions, target_labels, MLM_reconstruction_loss_weight, label_smoothing=0.0):\n target_prediction_loss_weight = 1.0 - MLM_reconstruction_loss_weight\n total_loss = 0.0\n if (token_labels is not None) and (MLM_reconstruction_loss_weight > 0.0):\n if self.args.aa_embeddings == \"MSA_Transformer\" and self.args.sequence_embeddings_location is None: token_labels = token_labels[:,0,:] #Only keep the token labels for seq to score. Drops the token labels for MSA sequences\n masked_lm_loss = CrossEntropyLoss(reduction=\"mean\", label_smoothing=label_smoothing)(token_predictions_logits.reshape(-1, self.alphabet_size), token_labels.reshape(-1))\n reconstruction_loss = masked_lm_loss\n total_loss += MLM_reconstruction_loss_weight * reconstruction_loss\n else:\n reconstruction_loss = torch.tensor(0.0)\n target_prediction_loss = {}\n for target_name in self.target_names:\n if self.args.target_config[target_name][\"in_NPT_loss\"]:\n if self.args.target_config[target_name][\"type\"]==\"continuous\":\n loss_masked_targets = ~target_labels[target_name].eq(-100) #Masked items are the ones for which the label was not set to -100\n if loss_masked_targets.sum()==0 or torch.isnan(target_labels[target_name][loss_masked_targets]).sum() > 0: #First condition true if we dont mask anything (eg., all target missing at eval). Second condition true if we force-mask one value at train time (to satisfy min_num_labels_masked in mast_target()) and corresponding target value is missing\n tgt_loss = torch.tensor(0.0)\n else:\n tgt_loss = MSELoss(reduction=\"mean\")(target_predictions[target_name][loss_masked_targets], target_labels[target_name][loss_masked_targets]) #we do not average the loss per batch, so that it's easier to do 1 full average across all batches\n if torch.isnan(tgt_loss).sum() > 0:\n print(\"Detected nan loss\")\n print(target_predictions[target_name])\n else:\n tgt_loss = CrossEntropyLoss(reduction=\"mean\", label_smoothing=label_smoothing)(target_predictions[target_name].view(-1, self.args.target_config[target_name][\"dim\"]), target_labels[target_name].view(-1)) # Note: we dont add one to the # of categories in the CE loss here (we dont predict <mask>)\n target_prediction_loss[target_name] = tgt_loss\n \n total_loss += target_prediction_loss_weight * target_prediction_loss[target_name]\n return total_loss, reconstruction_loss, target_prediction_loss\n\n def create_optimizer(self):\n \"\"\"\n Setup the optimizer.\n We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the\n Trainer's init through `optimizers`, or subclass and override this method in a subclass.\n Adapted from Huggingface Transformers library.\n \"\"\"\n if self.optimizer is None:\n all_parameters = utils.model_utils.get_parameter_names(self, [nn.LayerNorm])\n decay_parameters = [name for name in all_parameters if (\"bias\" not in name and \"pseudo_likelihood_weight\" not in name and 'zero_shot_fitness_prediction_weight' not in name)]\n psl_decay_parameters = [name for name in all_parameters if (\"bias\" not in name and (\"pseudo_likelihood_weight\" in name or \"zero_shot_fitness_prediction_weight\" in name))]\n optimizer_grouped_parameters = [\n {\n \"params\": [p for n, p in self.named_parameters() if n in decay_parameters],\n \"weight_decay\": self.args.weight_decay,\n },\n {\n \"params\": [p for n, p in self.named_parameters() if n in psl_decay_parameters],\n \"weight_decay\": 1e-8, #Small decay on pseudo-likelihood as in Hsu et al.\n },\n {\n \"params\": [p for n, p in self.named_parameters() if (n not in decay_parameters and n not in psl_decay_parameters)],\n \"weight_decay\": 0.0,\n },\n ] \n optimizer_kwargs = {\n \"betas\": (self.args.adam_beta1, self.args.adam_beta2),\n \"eps\": self.args.adam_epsilon,\n \"lr\": self.args.max_learning_rate\n }\n optimizer = AdamW(optimizer_grouped_parameters, **optimizer_kwargs)\n return optimizer"},{"identifier":"AugmentedPropertyPredictor","path":"baselines/model.py","snippet":"class AugmentedPropertyPredictor(nn.Module):\n def __init__(self, args, alphabet):\n super().__init__()\n self.args = args\n self.alphabet = alphabet\n self.alphabet_size = len(alphabet)\n print(\"Alphabet: {}\".format(alphabet))\n print(\"Alphabet size: {}\".format(self.alphabet_size))\n self.padding_idx = alphabet.padding_idx\n self.mask_idx = alphabet.mask_idx\n self.cls_idx = alphabet.cls_idx\n self.eos_idx = alphabet.eos_idx\n self.prepend_bos = alphabet.prepend_bos\n self.append_eos = alphabet.append_eos\n self.target_names = self.args.target_config.keys() \n self.MSA_sample_sequences = None \n self.device = None\n self.model_type = args.model_type \n if self.args.aa_embeddings in [\"MSA_Transformer\",\"ESM1v\"]:\n model, _ = utils.esm.pretrained.load_model_and_alphabet(args.embedding_model_location)\n self.aa_embedding = model\n if self.args.aa_embeddings == \"MSA_Transformer\": self.args.seq_len = self.args.MSA_seq_len #If MSA does not cover full sequence length, we adjust seq_len param to be MSA_len (sequences truncated as needed in preprocessing)\n elif self.args.aa_embeddings == \"Linear_embedding\":\n self.aa_embedding = nn.Sequential(\n nn.Embedding(\n self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx\n ),\n nn.ReLU()\n )\n elif self.args.aa_embeddings == \"One_hot_encoding\":\n self.args.target_prediction_head == \"One_hot_encoding\"\n elif self.args.aa_embeddings == \"Tranception\":\n self.aa_embedding_dim = 1280\n config = json.load(open(args.embedding_model_location+os.sep+'config.json'))\n config = utils.tranception.config.TranceptionConfig(**config)\n config.tokenizer = get_tranception_tokenizer()\n config.inference_time_retrieval_type = None\n config.retrieval_aggregation_mode = None\n self.aa_embedding = utils.tranception.model_pytorch.TranceptionLMHeadModel.from_pretrained(pretrained_model_name_or_path=args.embedding_model_location,config=config)\n self.config = config\n else:\n print(\"Error: Specified AA embedding invalid\")\n sys.exit(0)\n\n if self.args.aa_embeddings != \"One_hot_encoding\": \n self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)\n self.dropout_module = nn.Dropout(self.args.dropout)\n\n if self.args.target_prediction_head == \"AA_embeddings_mean_pooled\":\n target_pred_input_dim = self.args.embed_dim\n elif self.args.target_prediction_head == \"One_hot_encoding\":\n target_pred_input_dim = (self.args.seq_len + 1) * self.alphabet_size if args.target_prediction_model!=\"CNN\" else self.alphabet_size #Add one for the BOS token\n else:\n print(self.args.target_prediction_head)\n print(\"Error: Specified embedding aggregation invalid\")\n sys.exit(0)\n \n if args.target_prediction_model==\"MLP\":\n self.layer_pre_head = nn.Sequential(\n nn.Linear(target_pred_input_dim, target_pred_input_dim),\n nn.Dropout(self.args.dropout),\n nn.ReLU()\n )\n elif args.target_prediction_model==\"ConvBERT\":\n configuration = ConvBertConfig(\n hidden_size = self.args.embed_dim,\n num_attention_heads = self.args.attention_heads if self.args.attention_heads is not None else 4,\n conv_kernel_size = self.args.conv_kernel_size,\n hidden_act = \"gelu\",\n hidden_dropout_prob = self.args.dropout,\n attention_probs_dropout_prob = self.args.dropout\n )\n self.layer_pre_head = ConvBertLayer(configuration)\n elif args.target_prediction_model==\"CNN\":\n self.layer_pre_head = nn.Sequential(\n nn.Conv1d(in_channels=target_pred_input_dim, out_channels=target_pred_input_dim, kernel_size = self.args.conv_kernel_size, padding='same'),\n nn.Dropout(self.args.dropout),\n nn.ReLU()\n )\n target_pred_input_dim = target_pred_input_dim if self.args.target_prediction_head != \"One_hot_encoding\" else target_pred_input_dim * (self.args.seq_len + 1)\n elif args.target_prediction_model==\"light_attention\":\n # Adapted from Stark et al (https://github.com/HannesStark/protein-localization)\n self.feature_convolution = nn.Conv1d(self.args.embed_dim, self.args.embed_dim, self.args.conv_kernel_size, stride=1, padding='same')\n self.attention_convolution = nn.Conv1d(self.args.embed_dim, self.args.embed_dim, self.args.conv_kernel_size, stride=1, padding='same')\n self.softmax = nn.Softmax(dim=-1)\n self.dropout = nn.Dropout(self.args.dropout)\n self.linear = nn.Sequential(\n nn.Linear(2 * self.args.embed_dim, 32),\n nn.Dropout(self.args.dropout),\n nn.ReLU(),\n nn.BatchNorm1d(32)\n )\n target_pred_input_dim = 32\n elif args.target_prediction_model==\"linear\":\n pass\n else:\n print(\"Error: Specified layer_pre_head invalid\")\n sys.exit(0)\n\n if self.args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n self.zero_shot_fitness_prediction_weight = nn.ModuleDict(\n { \n target_name: nn.Linear(1, self.args.target_config[target_name][\"dim\"], bias=False)\n for target_name in self.target_names\n }\n )\n for target_name in self.target_names:\n torch.nn.init.constant_(self.zero_shot_fitness_prediction_weight[target_name].weight,1.0)\n\n self.target_pred_head = nn.ModuleDict(\n { \n target_name: nn.Linear(target_pred_input_dim, self.args.target_config[target_name][\"dim\"])\n for target_name in self.target_names #If multiple targets, we learn a separate linear head for each separately\n }\n )\n \n def set_device(self):\n if self.device is None:\n self.device = next(self.parameters()).device\n print(\"Model device: {}\".format(self.device))\n\n def forward(self, tokens, zero_shot_fitness_predictions=None, sequence_embeddings=None, repr_layers=[]):\n if self.args.aa_embeddings == \"MSA_Transformer\" and self.args.sequence_embeddings_location is None:\n assert tokens.ndim == 3, \"Finding dimension of tokens to be: {}\".format(tokens.ndim)\n num_MSAs_in_batch, num_sequences_in_alignments, seqlen = tokens.size()\n batch_size = num_MSAs_in_batch\n else:\n assert tokens.ndim == 2, \"Finding dimension of tokens to be: {}\".format(tokens.ndim)\n batch_size, seqlen = tokens.size()\n \n if sequence_embeddings is not None:\n x = sequence_embeddings.to(self.device)\n else:\n if self.args.aa_embeddings == \"MSA_Transformer\":\n output = self.aa_embedding(tokens, repr_layers=[12])\n x = output[\"representations\"][12][:] # B, N, L, D\n x = x[:,0,:,:] #In each MSA batch the first sequence is what we care about. The other MSA sequences were just to compute embeddings and logits\n elif self.args.aa_embeddings == \"ESM1v\":\n last_layer_index = 33\n output = self.aa_embedding(tokens, repr_layers=[last_layer_index])\n x = output[\"representations\"][last_layer_index][:] # N, L, D\n elif self.args.aa_embeddings == \"Tranception\":\n processed_batch = {'input_ids': tokens, 'labels': tokens}\n output = self.aa_embedding(**processed_batch, return_dict=True, output_hidden_states=True)\n x = output.hidden_states[0]\n elif self.args.aa_embeddings ==\"Linear_embedding\":\n x = self.aa_embedding(tokens)\n elif self.args.aa_embeddings == \"One_hot_encoding\":\n x = nn.functional.one_hot(tokens, num_classes=self.alphabet_size).view(batch_size,-1).float()\n if self.args.target_prediction_model == \"CNN\": x = x.view(batch_size,seqlen,self.alphabet_size)\n\n if self.args.aa_embeddings != \"One_hot_encoding\":\n x = self.emb_layer_norm_after(x)\n x = self.dropout_module(x)\n \n repr_layers = set(repr_layers)\n hidden_representations = {}\n if 0 in repr_layers:\n hidden_representations[0] = x\n\n if self.args.target_prediction_model == \"CNN\": \n assert len(x.size())==3, \"Size error input\"\n N, L, D = x.size()\n x = x.permute(0,2,1) #N, D, L\n x = self.layer_pre_head(x)\n x = x.permute(0,2,1)\n elif self.args.target_prediction_model == \"ConvBERT\":\n x = self.layer_pre_head(x)[0]\n elif self.args.target_prediction_model==\"light_attention\":\n x = x.permute(0,2,1) #N, D, L\n o = self.feature_convolution(x) \n o = self.dropout(o)\n attention = self.attention_convolution(x)\n o1 = torch.sum(o * self.softmax(attention), dim=-1)\n o2, _ = torch.max(o, dim=-1)\n o = torch.cat([o1, o2], dim=-1)\n x = self.linear(o)\n \n if self.args.target_prediction_head == \"AA_embeddings_mean_pooled\": x = x.mean(dim=-2)\n \n if self.args.target_prediction_model == \"MLP\": x = self.layer_pre_head(x)\n \n target_predictions = {}\n for target_name in self.target_names:\n target_predictions[target_name] = self.target_pred_head[target_name](x).view(-1)\n if self.args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n target_predictions[target_name] += self.zero_shot_fitness_prediction_weight[target_name](zero_shot_fitness_predictions).squeeze()\n\n result = {\"target_predictions\": target_predictions, \"representations\": hidden_representations}\n \n return result\n \n def forward_with_uncertainty(self, tokens, zero_shot_fitness_predictions=None, sequence_embeddings=None, num_MC_dropout_samples=10):\n \"\"\"\n Performs MC dropout to compute predictions and the corresponding uncertainties.\n Assumes 1D predictions (eg., prediction of continuous output).\n \"\"\"\n self.eval() \n for m in self.modules(): #Move all dropout layers in train mode to support MC dropout. Keep everything else in eval mode.\n if m.__class__.__name__.startswith('Dropout'):\n m.train()\n with torch.no_grad(): \n predictions_dict = defaultdict(list)\n for _ in range(num_MC_dropout_samples):\n target_predictions_sample = self.forward(tokens, zero_shot_fitness_predictions=zero_shot_fitness_predictions, sequence_embeddings=sequence_embeddings)[\"target_predictions\"]\n for target_name in self.target_names:\n predictions_dict[target_name].append(target_predictions_sample[target_name])\n results_with_uncertainty={}\n for target_name in self.target_names:\n concatenated_target_pred = torch.cat([x.view(-1,1) for x in predictions_dict[target_name]],dim=-1)\n results_with_uncertainty[target_name] = {}\n results_with_uncertainty[target_name]['predictions_avg'] = concatenated_target_pred.mean(dim=-1)\n results_with_uncertainty[target_name]['uncertainty'] = concatenated_target_pred.std(dim=-1)\n return results_with_uncertainty\n\n @property\n def num_layers(self):\n return self.args.num_protein_npt_layers\n \n def max_tokens_per_msa_(self, value: int) -> None:\n \"\"\"\n Batching attention computations when gradients are disabled as per MSA_Transformer\n Set this value to infinity to disable this behavior.\n \"\"\"\n for module in self.modules():\n if isinstance(module, (RowSelfAttention, ColumnSelfAttention)):\n module.max_tokens_per_msa = value\n\n def prediction_loss(self, target_predictions, target_labels, label_smoothing=0.1):\n total_target_prediction_loss = 0.0\n target_prediction_loss_dict = {}\n for target_name in self.target_names:\n non_missing_target_indicator = ~torch.isnan(target_labels[target_name])\n if self.args.target_config[target_name][\"type\"]==\"continuous\":\n tgt_loss = MSELoss(reduction=\"sum\")(target_predictions[target_name][non_missing_target_indicator], target_labels[target_name][non_missing_target_indicator])\n else:\n tgt_loss = CrossEntropyLoss(reduction=\"none\",label_smoothing=label_smoothing)(target_predictions[target_name].view(-1, self.args.target_config[target_name][\"dim\"]), target_labels[target_name].view(-1))\n target_prediction_loss_dict[target_name] = tgt_loss\n total_target_prediction_loss += tgt_loss\n return total_target_prediction_loss, target_prediction_loss_dict\n\n def create_optimizer(self):\n \"\"\"\n Setup the optimizer.\n We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the\n Trainer's init through `optimizers`, or subclass and override this method in a subclass.\n Adapted from Huggingface Transformers library.\n \"\"\"\n all_parameters = utils.model_utils.get_parameter_names(self, [nn.LayerNorm])\n decay_parameters = [name for name in all_parameters if (\"bias\" not in name and \"pseudo_likelihood_weight\" not in name and 'zero_shot_fitness_prediction_weight' not in name)]\n psl_decay_parameters = [name for name in all_parameters if (\"bias\" not in name and (\"pseudo_likelihood_weight\" in name or \"zero_shot_fitness_prediction_weight\" in name))]\n optimizer_grouped_parameters = [\n {\n \"params\": [p for n, p in self.named_parameters() if n in decay_parameters],\n \"weight_decay\": self.args.weight_decay,\n },\n {\n \"params\": [p for n, p in self.named_parameters() if n in psl_decay_parameters],\n \"weight_decay\": 1e-8, #Small decay on pseudo-likelihood as in Hsu et al.\n },\n {\n \"params\": [p for n, p in self.named_parameters() if (n not in decay_parameters and n not in psl_decay_parameters)],\n \"weight_decay\": 0.0,\n },\n ] \n optimizer_kwargs = {\n \"betas\": (self.args.adam_beta1, self.args.adam_beta2),\n \"eps\": self.args.adam_epsilon,\n \"lr\": self.args.max_learning_rate\n }\n optimizer = AdamW(optimizer_grouped_parameters, **optimizer_kwargs)\n return optimizer"},{"identifier":"Alphabet","path":"utils/esm/data.py","snippet":"class Alphabet(object):\n def __init__(\n self,\n standard_toks: Sequence[str],\n prepend_toks: Sequence[str] = (\"<null_0>\", \"<pad>\", \"<eos>\", \"<unk>\"),\n append_toks: Sequence[str] = (\"<cls>\", \"<mask>\", \"<sep>\"),\n prepend_bos: bool = True,\n append_eos: bool = False,\n use_msa: bool = False,\n ):\n #ESM Alphabet: {'<cls>': 0, '<pad>': 1, '<eos>': 2, '<unk>': 3, 'L': 4, 'A': 5, 'G': 6, 'V': 7, 'S': 8, 'E': 9, 'R': 10, 'T': 11, 'I': 12, 'D': 13, 'P': 14, 'K': 15, 'Q': 16, 'N': 17, 'F': 18, 'Y': 19, 'M': 20, 'H': 21, 'W': 22, 'C': 23, 'X': 24, 'B': 25, 'U': 26, 'Z': 27, 'O': 28, '.': 29, '-': 30, '<null_1>': 31, '<mask>': 32}\n self.standard_toks = list(standard_toks)\n self.prepend_toks = list(prepend_toks)\n self.append_toks = list(append_toks)\n self.prepend_bos = prepend_bos\n self.append_eos = append_eos\n self.use_msa = use_msa\n\n self.all_toks = list(self.prepend_toks)\n self.all_toks.extend(self.standard_toks)\n for i in range((8 - (len(self.all_toks) % 8)) % 8):\n self.all_toks.append(f\"<null_{i + 1}>\")\n self.all_toks.extend(self.append_toks)\n\n self.tok_to_idx = {tok: i for i, tok in enumerate(self.all_toks)}\n\n self.unk_idx = self.tok_to_idx[\"<unk>\"]\n self.padding_idx = self.get_idx(\"<pad>\")\n self.cls_idx = self.get_idx(\"<cls>\")\n self.mask_idx = self.get_idx(\"<mask>\")\n self.eos_idx = self.get_idx(\"<eos>\")\n self.all_special_tokens = ['<eos>', '<unk>', '<pad>', '<cls>', '<mask>']\n self.unique_no_split_tokens = self.all_toks\n\n def __len__(self):\n return len(self.all_toks)\n\n def get_idx(self, tok):\n return self.tok_to_idx.get(tok, self.unk_idx)\n\n def get_tok(self, ind):\n return self.all_toks[ind]\n\n def to_dict(self):\n return self.tok_to_idx.copy()\n\n def get_batch_converter(self, truncation_seq_length: int = None):\n if self.use_msa:\n return MSABatchConverter(self, truncation_seq_length)\n else:\n return BatchConverter(self, truncation_seq_length)\n\n @classmethod\n def from_architecture(cls, name: str) -> \"Alphabet\":\n if name in (\"ESM-1\", \"protein_bert_base\"):\n standard_toks = proteinseq_toks[\"toks\"]\n prepend_toks: Tuple[str, ...] = (\"<null_0>\", \"<pad>\", \"<eos>\", \"<unk>\")\n append_toks: Tuple[str, ...] = (\"<cls>\", \"<mask>\", \"<sep>\")\n prepend_bos = True\n append_eos = False\n use_msa = False\n elif name in (\"ESM-1b\", \"roberta_large\"):\n standard_toks = proteinseq_toks[\"toks\"]\n prepend_toks = (\"<cls>\", \"<pad>\", \"<eos>\", \"<unk>\")\n append_toks = (\"<mask>\",)\n prepend_bos = True\n append_eos = True\n use_msa = False\n elif name in (\"MSA Transformer\", \"msa_transformer\"):\n standard_toks = proteinseq_toks[\"toks\"]\n prepend_toks = (\"<cls>\", \"<pad>\", \"<eos>\", \"<unk>\")\n append_toks = (\"<mask>\",)\n prepend_bos = True\n append_eos = False\n use_msa = True\n elif \"invariant_gvp\" in name.lower():\n standard_toks = proteinseq_toks[\"toks\"]\n prepend_toks = (\"<null_0>\", \"<pad>\", \"<eos>\", \"<unk>\")\n append_toks = (\"<mask>\", \"<cath>\", \"<af2>\")\n prepend_bos = True\n append_eos = False\n use_msa = False\n else:\n raise ValueError(\"Unknown architecture selected\")\n return cls(standard_toks, prepend_toks, append_toks, prepend_bos, append_eos, use_msa)\n\n def _tokenize(self, text) -> str:\n return text.split()\n\n def tokenize(self, text, **kwargs) -> List[str]:\n \"\"\"\n Inspired by https://github.com/huggingface/transformers/blob/master/src/transformers/tokenization_utils.py\n Converts a string in a sequence of tokens, using the tokenizer.\n\n Args:\n text (:obj:`str`):\n The sequence to be encoded.\n\n Returns:\n :obj:`List[str]`: The list of tokens.\n \"\"\"\n\n def split_on_token(tok, text):\n result = []\n split_text = text.split(tok)\n for i, sub_text in enumerate(split_text):\n # AddedToken can control whitespace stripping around them.\n # We use them for GPT2 and Roberta to have different behavior depending on the special token\n # Cf. https://github.com/huggingface/transformers/pull/2778\n # and https://github.com/huggingface/transformers/issues/3788\n # We strip left and right by default\n if i < len(split_text) - 1:\n sub_text = sub_text.rstrip()\n if i > 0:\n sub_text = sub_text.lstrip()\n\n if i == 0 and not sub_text:\n result.append(tok)\n elif i == len(split_text) - 1:\n if sub_text:\n result.append(sub_text)\n else:\n pass\n else:\n if sub_text:\n result.append(sub_text)\n result.append(tok)\n return result\n\n def split_on_tokens(tok_list, text):\n if not text.strip():\n return []\n\n tokenized_text = []\n text_list = [text]\n for tok in tok_list:\n tokenized_text = []\n for sub_text in text_list:\n if sub_text not in self.unique_no_split_tokens:\n tokenized_text.extend(split_on_token(tok, sub_text))\n else:\n tokenized_text.append(sub_text)\n text_list = tokenized_text\n\n return list(\n itertools.chain.from_iterable(\n (\n self._tokenize(token)\n if token not in self.unique_no_split_tokens\n else [token]\n for token in tokenized_text\n )\n )\n )\n\n no_split_token = self.unique_no_split_tokens\n tokenized_text = split_on_tokens(no_split_token, text)\n return tokenized_text\n\n def encode(self, text):\n return [self.tok_to_idx[tok] for tok in self.tokenize(text)]"},{"identifier":"get_tranception_tokenizer","path":"utils/tranception/model_pytorch.py","snippet":"def get_tranception_tokenizer():\n #Tranception Alphabet: \"vocab\":{\"[UNK]\":0,\"[CLS]\":1,\"[SEP]\":2,\"[PAD]\":3,\"[MASK]\":4,\"A\":5,\"C\":6,\"D\":7,\"E\":8,\"F\":9,\"G\":10,\"H\":11,\"I\":12,\"K\":13,\"L\":14,\"M\":15,\"N\":16,\"P\":17,\"Q\":18,\"R\":19,\"S\":20,\"T\":21,\"V\":22,\"W\":23,\"Y\":24}\n dir_path = os.path.dirname(os.path.abspath(__file__))\n tokenizer = PreTrainedTokenizerFast(tokenizer_file=dir_path + os.sep + \"utils/tokenizers/Basic_tokenizer\", unk_token=\"[UNK]\", sep_token=\"[SEP]\", pad_token=\"[PAD]\", cls_token=\"[CLS]\",mask_token=\"[MASK]\")\n os.environ[\"TOKENIZERS_PARALLELISM\"] = \"false\"\n tokenizer.tok_to_idx = tokenizer.vocab\n tokenizer.padding_idx = tokenizer.tok_to_idx[\"[PAD]\"]\n tokenizer.mask_idx = tokenizer.tok_to_idx[\"[MASK]\"]\n tokenizer.cls_idx = tokenizer.tok_to_idx[\"[CLS]\"]\n tokenizer.eos_idx = tokenizer.tok_to_idx[\"[SEP]\"]\n tokenizer.prepend_bos = True\n tokenizer.append_eos = True\n return tokenizer"},{"identifier":"get_train_val_test_data","path":"utils/data_utils.py","snippet":"def get_train_val_test_data(args, assay_file_names):\n target_names = args.target_config.keys() \n assay_data={}\n merge = None\n main_target_name = None\n main_target_name_count = 0\n for target in target_names:\n if args.target_config[target][\"main_target\"]: \n main_target_name=target\n main_target_name_count+=1\n assert main_target_name is not None, \"No main target referenced. Please update config to select a unique main target.\"\n assert main_target_name_count <= 1, \"Several main targets referenced. Please update config to select a unique main target.\"\n \n assay_data[main_target_name] = pd.read_csv(args.target_config[main_target_name][\"location\"] + os.sep + assay_file_names[main_target_name])[['mutant','mutated_sequence',args.target_config[main_target_name][\"var_name\"],args.fold_variable_name]] \n assay_data[main_target_name].columns = ['mutant','mutated_sequence', main_target_name, args.fold_variable_name]\n merge = assay_data[main_target_name]\n \n for target_name in target_names:\n if target_name!=main_target_name:\n print(target_name)\n print(args.target_config)\n print(assay_file_names)\n assay_data[target_name] = pd.read_csv(args.target_config[target_name][\"location\"] + os.sep + assay_file_names[target_name])[['mutant',args.target_config[target_name][\"var_name\"]]] \n assay_data[target_name].columns = ['mutant',target_name]\n merge = pd.merge(merge, assay_data[target_name], how='left', on='mutant')\n \n if args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n zero_shot_fitness_predictions = pd.read_csv(args.zero_shot_fitness_predictions_location + os.sep + assay_file_names[main_target_name])[['mutant',args.zero_shot_fitness_predictions_var_name]]\n zero_shot_fitness_predictions.columns = ['mutant','zero_shot_fitness_predictions']\n zero_shot_fitness_predictions['zero_shot_fitness_predictions'] = standardize(zero_shot_fitness_predictions['zero_shot_fitness_predictions'])\n merge = pd.merge(merge,zero_shot_fitness_predictions,how='inner',on='mutant')\n\n train_val_test_splits = split_data_based_on_test_fold_index(\n dataframe = merge, \n fold_variable_name = args.fold_variable_name,\n test_fold_index = args.test_fold_index,\n use_validation_set = args.use_validation_set\n )\n splits_dict = {}\n for split_name, split in zip(['train','val','test'], train_val_test_splits):\n if split_name=='val' and not args.use_validation_set: continue\n splits_dict[split_name] = {}\n splits_dict[split_name]['mutant_mutated_seq_pairs'] = list(zip(list(split['mutant']),list(split['mutated_sequence'])))\n raw_targets = {target_name: split[target_name] for target_name in target_names}\n if args.augmentation==\"zero_shot_fitness_predictions_covariate\": raw_targets['zero_shot_fitness_predictions'] = split['zero_shot_fitness_predictions']\n if split_name==\"train\":\n raw_targets, target_processing = preprocess_training_targets(raw_targets, args.target_config)\n else:\n raw_targets = preprocess_test_targets(raw_targets, args.target_config, target_processing)\n for target_name in target_names: \n splits_dict[split_name][target_name] = raw_targets[target_name]\n if args.augmentation==\"zero_shot_fitness_predictions_covariate\": splits_dict[split_name]['zero_shot_fitness_predictions'] = raw_targets['zero_shot_fitness_predictions']\n # load dict into dataset objects\n train_data = Dataset.from_dict(splits_dict['train'])\n val_data = Dataset.from_dict(splits_dict['val']) if args.use_validation_set else None\n test_data = Dataset.from_dict(splits_dict['test'])\n return train_data, val_data, test_data, target_processing"},{"identifier":"standardize","path":"utils/data_utils.py","snippet":"def standardize(x):\n return (x - x.mean()) / x.std()"},{"identifier":"pnpt_count_non_nan","path":"utils/data_utils.py","snippet":"def pnpt_count_non_nan(x):\n missing_mask = np.isnan(x) | np.equal(x,-100)\n return np.count_nonzero(~missing_mask)"},{"identifier":"pnpt_spearmanr","path":"utils/data_utils.py","snippet":"def pnpt_spearmanr(prediction,target):\n mask_missing_values = np.isnan(target) | np.equal(target, -100) #In PNPT missing values are never masked so corresponding labels are always set to -100\n return spearmanr(prediction[~mask_missing_values], target[~mask_missing_values])[0] #first value is spearman rho, second is the corresponding p-value "},{"identifier":"process_MSA","path":"utils/msa_utils.py","snippet":"def process_MSA(args, MSA_filename, MSA_weights_filename):\n filtered_MSA_filename = filter_msa(filename = args.MSA_data_folder + os.sep + MSA_filename, path_to_hhfilter = args.path_to_hhfilter)\n MSA_all_sequences, MSA_non_ref_sequences_weights = compute_sequence_weights(MSA_filename = filtered_MSA_filename, MSA_weights_filename = args.MSA_weight_data_folder + os.sep + MSA_weights_filename)\n return MSA_all_sequences, MSA_non_ref_sequences_weights"},{"identifier":"Trainer","path":"utils/model_utils.py","snippet":"class Trainer():\n def __init__(self, \n model,\n args,\n train_data, \n val_data,\n MSA_sequences, \n MSA_weights,\n MSA_start_position,\n MSA_end_position,\n target_processing,\n distributed_training=False\n ):\n self.model = model\n self.args = args\n self.train_data = train_data\n self.val_data = val_data\n self.MSA_sequences = MSA_sequences\n self.MSA_weights = MSA_weights\n self.MSA_start_position = MSA_start_position\n self.MSA_end_position = MSA_end_position\n self.target_processing = target_processing\n self.distributed_training = distributed_training\n \n def train(self):\n \"\"\"\n Returns the last value of training_step (useful in case of early stopping for isntance)\n \"\"\"\n \n self.model.train()\n self.model.cuda()\n self.model.set_device()\n\n if self.distributed_training:\n self.model = torch.nn.parallel.DistributedDataParallel(self.model)\n train_sampler = torch.utils.data.distributed.DistributedSampler(self.train_data)\n else:\n train_sampler = None\n \n #To ensure reproducibility with seed setting\n def seed_worker(worker_id):\n worker_seed = torch.initial_seed() % 2**32\n np.random.seed(worker_seed)\n random.seed(worker_seed)\n g = torch.Generator()\n g.manual_seed(0)\n train_loader = torch.utils.data.DataLoader(\n dataset=self.train_data, \n batch_size=self.args.training_num_assay_sequences_per_batch_per_gpu, \n shuffle=(train_sampler is None),\n num_workers=self.args.num_data_loaders_workers, \n pin_memory=True, \n sampler=train_sampler,\n collate_fn=collate_fn_protein_npt,\n worker_init_fn=seed_worker,\n generator=g,\n )\n optimizer = self.model.create_optimizer()\n scheduler = learning_rate_scheduler(\n num_warmup_steps=self.args.num_warmup_steps, \n num_total_training_steps=self.args.num_total_training_steps, \n max_learning_rate=self.args.max_learning_rate, \n min_learning_rate=self.args.min_learning_rate\n )\n \n train_iterator = iter(train_loader)\n num_epochs = 0\n prior_log_time = time.time()\n total_train_time = 0\n log_train_total_loss = 0\n if self.model.model_type==\"ProteinNPT\":\n log_train_reconstruction_loss = 0\n log_train_num_masked_tokens = 0\n log_train_num_target_masked_tokens_dict = defaultdict(int)\n else:\n log_num_sequences_predicted = 0\n log_train_target_prediction_loss_dict = defaultdict(int)\n all_spearmans_eval_during_training = []\n max_average_spearman_across_targets = - math.inf\n if self.args.training_fp16: scaler = torch.cuda.amp.GradScaler()\n\n for training_step in tqdm.tqdm(range(1, self.args.num_total_training_steps+1)):\n optimizer.zero_grad(set_to_none=True)\n lr = scheduler(training_step)\n update_lr_optimizer(optimizer, lr)\n reconstruction_loss_coeff = get_reconstruction_loss_coefficient(training_step, num_total_training_steps=self.args.num_total_training_steps) if (self.model.model_type==\"ProteinNPT\" and not self.model.PNPT_no_reconstruction_error) else 0\n for gradient_accum_step in range(self.args.gradient_accumulation):\n try:\n batch = next(train_iterator)\n except:\n num_epochs +=1\n train_iterator = iter(train_loader)\n batch = next(train_iterator)\n \n if self.model.model_type==\"ProteinNPT\":\n processed_batch = proteinnpt.data_processing.process_batch(\n batch = batch,\n model = self.model,\n alphabet = self.model.alphabet, \n args = self.args, \n MSA_sequences = self.MSA_sequences, \n MSA_weights = self.MSA_weights,\n MSA_start_position = self.MSA_start_position, \n MSA_end_position = self.MSA_end_position,\n target_processing = self.target_processing,\n training_sequences = None,\n proba_target_mask = 0.15,\n proba_aa_mask = 0.15,\n eval_mode = False,\n device=self.model.device,\n indel_mode=self.args.indel_mode\n )\n else:\n processed_batch = baselines.data_processing.process_batch(\n batch = batch,\n model = self.model,\n alphabet = self.model.alphabet, \n args = self.args, \n MSA_sequences = self.MSA_sequences, \n MSA_weights = self.MSA_weights,\n MSA_start_position = self.MSA_start_position, \n MSA_end_position = self.MSA_end_position,\n device=self.model.device,\n eval_mode=False,\n indel_mode=self.args.indel_mode\n )\n\n if self.args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n zero_shot_fitness_predictions = processed_batch['target_labels']['zero_shot_fitness_predictions'].view(-1,1)\n del processed_batch['target_labels']['zero_shot_fitness_predictions']\n else:\n zero_shot_fitness_predictions = None\n \n if self.args.training_fp16:\n with torch.cuda.amp.autocast():\n if self.model.model_type==\"ProteinNPT\":\n output = self.model(\n tokens=processed_batch['masked_tokens'],\n targets=processed_batch['masked_targets'],\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\n sequence_embeddings=processed_batch['sequence_embeddings']\n )\n total_loss, reconstruction_loss, target_prediction_loss_dict = self.model.protein_npt_loss(\n token_predictions_logits=output['logits_protein_sequence'], \n token_labels=processed_batch['token_labels'], \n target_predictions=output['target_predictions'], \n target_labels=processed_batch['target_labels'], \n MLM_reconstruction_loss_weight=reconstruction_loss_coeff, \n label_smoothing=self.args.label_smoothing\n )\n else:\n output = self.model(\n tokens=processed_batch['input_tokens'],\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\n sequence_embeddings=processed_batch['sequence_embeddings']\n )\n total_loss, target_prediction_loss_dict = self.model.prediction_loss(\n target_predictions=output[\"target_predictions\"], \n target_labels=processed_batch['target_labels'],\n label_smoothing=self.args.label_smoothing\n )\n scaler.scale(total_loss).backward()\n else:\n if self.model.model_type==\"ProteinNPT\":\n output = self.model(\n tokens=processed_batch['masked_tokens'],\n targets=processed_batch['masked_targets'],\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\n sequence_embeddings=processed_batch['sequence_embeddings']\n )\n total_loss, reconstruction_loss, target_prediction_loss_dict = self.model.protein_npt_loss(\n token_predictions_logits=output['logits_protein_sequence'], \n token_labels=processed_batch['token_labels'], \n target_predictions=output['target_predictions'], \n target_labels=processed_batch['target_labels'], \n MLM_reconstruction_loss_weight=reconstruction_loss_coeff, \n label_smoothing=self.args.label_smoothing\n )\n if total_loss.item() > 10.0 and training_step >= 100:\n print(\"High training loss detected: {}\".format(total_loss.item()))\n else:\n output = self.model(\n tokens=processed_batch['input_tokens'],\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\n sequence_embeddings=processed_batch['sequence_embeddings']\n )\n total_loss, target_prediction_loss_dict = self.model.prediction_loss(\n target_predictions=output[\"target_predictions\"], \n target_labels=processed_batch['target_labels'],\n label_smoothing=self.args.label_smoothing\n )\n total_loss.backward()\n torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.args.grad_norm_clip)\n # Taking optimizer update out of the inner loop to support gradient accumulation\n if self.args.training_fp16:\n with torch.cuda.amp.autocast():\n scaler.step(optimizer)\n scaler.update()\n else:\n optimizer.step()\n\n log_train_total_loss += total_loss\n for target_name in self.model.target_names:\n log_train_target_prediction_loss_dict[target_name] += target_prediction_loss_dict[target_name]\n if self.model.model_type==\"ProteinNPT\": \n log_train_reconstruction_loss += reconstruction_loss\n log_train_num_masked_tokens += processed_batch['masked_tokens'].eq(self.model.alphabet.mask_idx).sum()\n for target_name in self.model.target_names:\n log_train_num_target_masked_tokens_dict[target_name] += processed_batch['masked_targets'][target_name][:,-1].eq(1.0).sum().item() # Masked targets are encoded by 1.0. Mask column is the very last one\n else:\n log_num_sequences_predicted += len(batch['mutant_mutated_seq_pairs'])\n \n if training_step % self.args.num_logging_training_steps == 0 and self.args.use_wandb:\n time_end_step = time.time()\n delta_time_since_last_log = time_end_step - prior_log_time\n total_train_time += delta_time_since_last_log\n prior_log_time = time_end_step\n train_logs = {\n \"training_step\": training_step, \n \"step_time\": delta_time_since_last_log / (self.args.num_logging_training_steps)\n }\n if self.model.model_type==\"ProteinNPT\": \n train_logs[\"train_total_loss_per_step\"]: log_train_total_loss / self.args.num_logging_training_steps\n train_logs[\"train_reconstruction_loss_per_masked_token\"] = log_train_reconstruction_loss / log_train_num_masked_tokens\n for target_name in self.model.target_names:\n train_logs[\"train_prediction_\"+str(target_name)+\"_loss_per_masked_token\"] = log_train_target_prediction_loss_dict[target_name] / log_train_num_target_masked_tokens_dict[target_name]\n else:\n train_logs[\"train_total_loss_per_seq\"]: log_train_total_loss / log_num_sequences_predicted\n for target_name in self.model.target_names:\n train_logs[\"train_prediction_\"+str(target_name)+\"_loss_per_seq\"] = log_train_target_prediction_loss_dict[target_name] / log_num_sequences_predicted\n wandb.log(train_logs)\n log_train_total_loss = 0\n log_train_target_prediction_loss_dict = defaultdict(int)\n if self.model.model_type==\"ProteinNPT\":\n log_train_reconstruction_loss = 0\n log_train_num_masked_tokens = 0\n log_train_num_target_masked_tokens_dict = defaultdict(int)\n else:\n log_num_sequences_predicted = 0 \n \n if self.args.save_model_checkpoint and (training_step % self.args.num_saving_training_steps) == 0:\n if not os.path.exists(self.args.model_location): os.mkdir(self.args.model_location)\n if not os.path.exists(self.args.model_location + os.sep + 'checkpoint-'+str(training_step)): os.mkdir(self.args.model_location + os.sep + 'checkpoint-'+str(training_step))\n torch.save({\n 'training_step': training_step,\n 'args': self.args,\n 'state_dict': self.model.state_dict(),\n 'optimizer' : optimizer.state_dict()\n }, \n self.args.model_location + os.sep + 'checkpoint-'+str(training_step) + os.sep + 'checkpoint.t7'\n )\n \n if training_step % self.args.num_eval_steps == 0 and self.args.use_validation_set:\n if self.model.model_type==\"ProteinNPT\":\n eval_results = self.eval(\n test_data=self.val_data,\n train_data=self.train_data,\n reconstruction_loss_weight=0.0,\n output_all_predictions=True\n )\n else:\n eval_results = self.eval(\n test_data=self.val_data, \n output_all_predictions=True\n )\n eval_logs = {\"Training step\": training_step} \n if self.model.model_type==\"ProteinNPT\":\n normalization = 0\n for target_name in self.model.target_names: normalization += eval_results['eval_num_masked_targets'][target_name]\n else:\n normalization = eval_results['eval_num_predicted_targets']\n eval_logs['Eval total loss per seq.']: eval_results['eval_total_loss'] / normalization\n average_spearman_across_targets = 0 #If early stopping based on validation spearman and multiple targets, we check that avg spearman is not decreasing for a certain # of times in a row\n for target_name in self.model.target_names:\n if self.model.model_type==\"ProteinNPT\": normalization = eval_results['eval_num_masked_targets'][target_name] #Update for PNPT (keeep the same normalization constant otherwise)\n eval_logs['Eval loss '+str(target_name)+' per seq.'] = eval_results['eval_target_prediction_loss_dict'][target_name] / normalization\n eval_logs['Eval spearman '+target_name] = spearmanr(eval_results['output_scores']['predictions_'+target_name], eval_results['output_scores']['labels_'+target_name])[0]\n average_spearman_across_targets += eval_logs['Eval spearman '+target_name]\n average_spearman_across_targets /= len(self.model.target_names)\n print(\" | \".join([key + \": \"+str(round(eval_logs[key],5)) for key in eval_logs.keys()]))\n if self.args.use_wandb: wandb.log(eval_logs)\n # Early stopping\n all_spearmans_eval_during_training.append(average_spearman_across_targets)\n if average_spearman_across_targets > max_average_spearman_across_targets: max_average_spearman_across_targets = average_spearman_across_targets\n if (training_step >= 1000) and (self.args.early_stopping_patience is not None) and (np.array(all_spearmans_eval_during_training)[-self.args.early_stopping_patience:].max() < max_average_spearman_across_targets):\n print(\"Early stopping. Training step: {}. Total eval loss: {}. Avg spearman: {}\".format(training_step, eval_results['eval_total_loss'], average_spearman_across_targets))\n break\n self.model.train() #Move back the model to train mode after eval loop\n trainer_final_status = {\n 'total_training_steps': training_step,\n 'total_train_time': total_train_time,\n 'total_training_epochs': num_epochs\n }\n return trainer_final_status\n\n def eval(self, test_data, output_all_predictions=False, need_head_weights=False, train_data = None, reconstruction_loss_weight=0.5, selected_indices_seed=0):\n \"\"\"\n total_eval_target_prediction_loss is the sum of all target prediction losses across all targets\n total_eval_target_prediction_loss contains the breakdown by target\n num_predicted_targets has the number of predicted items\n output_scores is a dict with sequences, predictions and labels\n \"\"\"\n self.model.eval()\n self.model.cuda()\n self.model.set_device()\n with torch.no_grad():\n eval_loader = torch.utils.data.DataLoader(\n dataset=test_data, \n batch_size=self.args.eval_num_sequences_to_score_per_batch_per_gpu, \n shuffle=False,\n num_workers=self.args.num_data_loaders_workers, \n pin_memory=True,\n collate_fn=collate_fn_protein_npt\n )\n eval_iterator = iter(eval_loader)\n \n eval_total_loss = 0\n if self.model.model_type==\"ProteinNPT\": \n eval_reconstruction_loss = 0\n eval_num_masked_tokens = 0\n eval_num_masked_targets = defaultdict(int)\n else:\n num_predicted_targets = 0\n eval_target_prediction_loss_dict = defaultdict(int)\n output_scores = defaultdict(list) if output_all_predictions else None\n\n if need_head_weights:\n col_attentions=[]\n row_attentions=[]\n\n for batch in tqdm.tqdm(eval_iterator):\n if output_all_predictions: \n output_scores['mutated_sequence'] += list(zip(*batch['mutant_mutated_seq_pairs']))[1]\n output_scores['mutant'] += list(zip(*batch['mutant_mutated_seq_pairs']))[0]\n if self.model.model_type==\"ProteinNPT\":\n processed_batch = proteinnpt.data_processing.process_batch(\n batch = batch,\n model = self.model,\n alphabet = self.model.alphabet, \n args = self.args, \n MSA_sequences = self.MSA_sequences, \n MSA_weights = self.MSA_weights,\n MSA_start_position = self.MSA_start_position, \n MSA_end_position = self.MSA_end_position,\n target_processing = self.target_processing,\n training_sequences = train_data,\n proba_target_mask = 1.0, \n proba_aa_mask = 0.0,\n eval_mode = True,\n device=self.model.device,\n selected_indices_seed=selected_indices_seed,\n indel_mode=self.args.indel_mode\n )\n else:\n processed_batch = baselines.data_processing.process_batch(\n batch = batch,\n model = self.model,\n alphabet = self.model.alphabet, \n args = self.args, \n MSA_sequences = self.MSA_sequences, \n MSA_weights = self.MSA_weights,\n MSA_start_position = self.MSA_start_position, \n MSA_end_position = self.MSA_end_position,\n device=self.model.device,\n eval_mode=True,\n indel_mode=self.args.indel_mode\n )\n if self.args.augmentation==\"zero_shot_fitness_predictions_covariate\":\n zero_shot_fitness_predictions = processed_batch['target_labels']['zero_shot_fitness_predictions'].view(-1,1)\n del processed_batch['target_labels']['zero_shot_fitness_predictions']\n else:\n zero_shot_fitness_predictions = None\n \n if self.model.model_type==\"ProteinNPT\":\n output = self.model(\n tokens=processed_batch['masked_tokens'],\n targets=processed_batch['masked_targets'],\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\n sequence_embeddings=processed_batch['sequence_embeddings'],\n need_head_weights=need_head_weights\n )\n batch_loss, batch_reconstruction_loss, batch_target_prediction_loss_dict = self.model.protein_npt_loss(\n token_predictions_logits=output['logits_protein_sequence'], \n token_labels=processed_batch['token_labels'], \n target_predictions=output['target_predictions'], \n target_labels=processed_batch['target_labels'], \n MLM_reconstruction_loss_weight=reconstruction_loss_weight, \n label_smoothing=self.args.label_smoothing\n )\n if batch_loss.item() > 10.0:\n print(\"High eval loss detected: {}\".format(batch_loss.item()))\n else:\n output = self.model(\n tokens=processed_batch['input_tokens'],\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\n sequence_embeddings=processed_batch['sequence_embeddings']\n )\n batch_loss, batch_target_prediction_loss_dict = self.model.prediction_loss(\n target_predictions=output[\"target_predictions\"], \n target_labels=processed_batch['target_labels'],\n label_smoothing=self.args.label_smoothing\n )\n \n eval_total_loss += batch_loss.item()\n for target_name in self.model.target_names:\n eval_target_prediction_loss_dict[target_name] += batch_target_prediction_loss_dict[target_name].item()\n if self.model.model_type==\"ProteinNPT\":\n eval_reconstruction_loss += batch_reconstruction_loss.item()\n eval_num_masked_tokens += processed_batch['masked_tokens'].eq(self.model.alphabet.mask_idx).sum().item()\n for target_name in self.model.target_names:\n eval_num_masked_targets[target_name] += processed_batch['masked_targets'][target_name][:,-1].eq(1.0).sum().item()\n else:\n num_predicted_targets += len(batch['mutant_mutated_seq_pairs'])\n if output_all_predictions:\n num_of_mutated_seqs_to_score = processed_batch['num_of_mutated_seqs_to_score'] if self.model.model_type==\"ProteinNPT\" else len(processed_batch['mutant_mutated_seq_pairs'])\n for target_name in self.model.target_names:\n output_scores['predictions_'+target_name] += list(output[\"target_predictions\"][target_name][:num_of_mutated_seqs_to_score].cpu().numpy())\n output_scores['labels_'+target_name] += list(processed_batch['target_labels'][target_name][:num_of_mutated_seqs_to_score].cpu().numpy())\n if need_head_weights:\n col_attentions.append(output[\"col_attentions\"])\n row_attentions.append(output[\"row_attentions\"])\n\n output_scores = pd.DataFrame.from_dict(output_scores)\n output_scores_numeric_cols = [col_name for col_name in output_scores.columns if col_name not in ['mutant','mutated_sequence']]\n output_scores = output_scores.groupby(['mutant'])[output_scores_numeric_cols].mean().reset_index() \n mutated_seqs_dict = {}\n mutant_mutated_seqs = list(zip(*test_data['mutant_mutated_seq_pairs']))\n mutated_seqs_dict['mutant'] = mutant_mutated_seqs[0]\n mutated_seqs_dict['mutated_sequence'] = mutant_mutated_seqs[1]\n mutated_seqs_df = pd.DataFrame.from_dict(mutated_seqs_dict)\n output_scores = pd.merge(output_scores, mutated_seqs_df, on='mutant', how='left')\n \n\n eval_results = {\n 'eval_total_loss':eval_total_loss,\n 'eval_target_prediction_loss_dict':eval_target_prediction_loss_dict,\n 'output_scores': output_scores\n }\n if need_head_weights:\n print(\"dimension of first attention column {}\".format(col_attentions[0].shape))\n eval_results['col_attentions'] = torch.stack(col_attentions, dim=0).cpu().numpy()\n eval_results['row_attentions'] = torch.stack(row_attentions, dim=0).cpu().numpy()\n \n if self.model.model_type==\"ProteinNPT\":\n eval_results['eval_reconstruction_loss']=eval_reconstruction_loss\n eval_results['eval_num_masked_tokens']=eval_num_masked_tokens\n eval_results['eval_num_masked_targets']=eval_num_masked_targets\n else:\n eval_results['eval_num_predicted_targets']=num_predicted_targets\n return eval_results"}],"string":"[\n {\n \"identifier\": \"ProteinNPTModel\",\n \"path\": \"proteinnpt/model.py\",\n \"snippet\": \"class ProteinNPTModel(nn.Module):\\n def __init__(self, args, alphabet):\\n super().__init__()\\n self.args = args\\n self.alphabet = alphabet\\n self.alphabet_size = len(alphabet)\\n self.padding_idx = alphabet.padding_idx\\n self.mask_idx = alphabet.mask_idx\\n self.cls_idx = alphabet.cls_idx\\n self.eos_idx = alphabet.eos_idx\\n self.prepend_bos = alphabet.prepend_bos\\n self.append_eos = alphabet.append_eos\\n self.target_names_input = self.args.target_config.keys()\\n self.target_names = [x for x in self.args.target_config.keys() if self.args.target_config[x][\\\"in_NPT_loss\\\"]]\\n self.num_targets_input = len(self.target_names_input) #Includes all targets, incl. zero-shot fitness predictions\\n self.num_targets = len(self.target_names) #Number of actual targets we want to predict\\n self.MSA_sample_sequences = None\\n self.training_sample_sequences_indices = None\\n self.device = None\\n self.optimizer = None\\n self.model_type = args.model_type\\n self.PNPT_ensemble_test_num_seeds = -1\\n self.PNPT_no_reconstruction_error = False\\n self.deactivate_col_attention = False\\n self.tranception_attention = False\\n \\n assert self.args.embed_dim % self.args.attention_heads ==0, \\\"Embedding size {} needs to be a multiple of number of heads {}\\\".format(self.args.embed_dim, self.args.attention_heads)\\n if self.args.aa_embeddings in [\\\"MSA_Transformer\\\",\\\"ESM1v\\\"]:\\n model, _ = utils.esm.pretrained.load_model_and_alphabet(args.embedding_model_location)\\n self.aa_embedding = model\\n self.aa_embedding_dim = self.aa_embedding.embed_tokens.weight.shape[-1]\\n elif self.args.aa_embeddings == \\\"Tranception\\\":\\n self.aa_embedding_dim = 1280\\n config = json.load(open(args.embedding_model_location+os.sep+'config.json'))\\n config = utils.tranception.config.TranceptionConfig(**config)\\n config.tokenizer = self.alphabet\\n config.inference_time_retrieval_type = None\\n config.retrieval_aggregation_mode = None\\n self.aa_embedding = utils.tranception.model_pytorch.TranceptionLMHeadModel.from_pretrained(pretrained_model_name_or_path=args.embedding_model_location,config=config)\\n elif self.args.aa_embeddings == \\\"Linear_embedding\\\":\\n self.aa_embedding = nn.Embedding(\\n self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx\\n )\\n self.aa_positions_embedding = LearnedPositionalEmbedding(\\n self.args.max_positions,\\n self.args.embed_dim,\\n self.padding_idx,\\n )\\n self.aa_embedding_dim = self.args.embed_dim\\n\\n if self.aa_embedding_dim != self.args.embed_dim: #Need to project internally\\n self.token_embedding_projection = nn.Linear(\\n self.aa_embedding_dim,\\n self.args.embed_dim\\n )\\n self.token_embedding_expansion = nn.Linear(\\n self.args.embed_dim,\\n self.aa_embedding_dim\\n )\\n\\n self.target_embedding = nn.ModuleDict(\\n { \\n target_name:\\n nn.Linear(\\n self.args.target_config[target_name][\\\"dim\\\"] + 1, #Need to add one as we append the mask flag to each input target \\n self.args.embed_dim\\n )\\n if self.args.target_config[target_name][\\\"type\\\"]==\\\"continuous\\\"\\n else \\n nn.Embedding(\\n self.args.target_config[target_name][\\\"dim\\\"],\\n self.args.embed_dim\\n )\\n for target_name in self.target_names_input\\n }\\n )\\n \\n self.dropout_module = nn.Dropout(self.args.dropout)\\n\\n self.layers = nn.ModuleList(\\n [\\n AxialTransformerLayer(\\n self.args.embed_dim,\\n self.args.ffn_embed_dim,\\n self.args.attention_heads,\\n self.args.dropout,\\n self.args.attention_dropout,\\n self.args.activation_dropout,\\n getattr(self.args, \\\"max_tokens_per_msa\\\", self.args.max_tokens_per_msa),\\n self.deactivate_col_attention,\\n self.tranception_attention,\\n self.num_targets_input,\\n )\\n for _ in range(self.args.num_protein_npt_layers)\\n ]\\n )\\n self.emb_layer_norm_before = ESM1bLayerNorm(self.args.embed_dim)\\n self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)\\n \\n if self.args.aa_embeddings in [\\\"MSA_Transformer\\\",\\\"ESM1v\\\"]:\\n weight = self.aa_embedding.embed_tokens.weight\\n elif self.args.aa_embeddings == \\\"Tranception\\\":\\n weight = self.aa_embedding.lm_head.weight\\n else:\\n weight = self.aa_embedding.weight\\n\\n self.lm_head = RobertaLMHead(\\n embed_dim=self.aa_embedding_dim,\\n output_dim=self.alphabet_size,\\n weight=weight\\n )\\n \\n target_pred_input_dim = self.args.embed_dim\\n\\n if args.target_prediction_model==\\\"MLP\\\": \\n self.layer_pre_head = nn.ModuleDict(\\n {\\n target_name:\\n nn.Sequential(\\n nn.Linear(target_pred_input_dim, target_pred_input_dim),\\n nn.Dropout(self.args.dropout),\\n nn.ReLU()\\n ) \\n for target_name in self.target_names\\n }\\n )\\n \\n if args.target_prediction_model==\\\"ConvBERT\\\":\\n configuration = ConvBertConfig(\\n hidden_size = self.args.embed_dim,\\n num_attention_heads = self.args.attention_heads,\\n conv_kernel_size = self.args.conv_kernel_size,\\n hidden_act = \\\"gelu\\\",\\n hidden_dropout_prob = self.args.dropout,\\n attention_probs_dropout_prob = self.args.dropout\\n )\\n self.layer_pre_head = ConvBertLayer(configuration)\\n \\n if args.target_prediction_model==\\\"CNN\\\":\\n self.layer_pre_head = nn.Sequential(\\n nn.Conv1d(in_channels=target_pred_input_dim, out_channels=target_pred_input_dim, kernel_size = self.args.conv_kernel_size, padding='same'),\\n nn.Dropout(self.args.dropout),\\n nn.ReLU()\\n )\\n \\n if self.args.target_prediction_head == \\\"Target_embeddings_only\\\":\\n target_pred_input_dim = target_pred_input_dim\\n elif self.args.target_prediction_head == \\\"Target_embeddings_and_AA_embeddings_mean_pooled\\\":\\n target_pred_input_dim = target_pred_input_dim * (1 + self.num_targets_input)\\n\\n if self.args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n self.zero_shot_fitness_prediction_weight = nn.ModuleDict(\\n { \\n target_name: nn.Linear(1, self.args.target_config[target_name][\\\"dim\\\"], bias=False)\\n for target_name in self.target_names\\n }\\n )\\n for target_name in self.target_names:\\n torch.nn.init.constant_(self.zero_shot_fitness_prediction_weight[target_name].weight,1e-4)\\n\\n self.target_pred_head = nn.ModuleDict(\\n { \\n target_name: nn.Linear(target_pred_input_dim, self.args.target_config[target_name][\\\"dim\\\"])\\n for target_name in self.target_names\\n }\\n )\\n \\n def set_device(self):\\n if self.device is None:\\n self.device = next(self.parameters()).device\\n print(\\\"Model device: {}\\\".format(self.device))\\n \\n def forward(self, tokens, targets=None, zero_shot_fitness_predictions=None, sequence_embeddings=None, repr_layers=[], need_head_weights=False):\\n padding_mask = tokens.eq(self.padding_idx) \\n if not padding_mask.any(): padding_mask = None\\n \\n if self.args.aa_embeddings == \\\"MSA_Transformer\\\" and self.args.sequence_embeddings_location is None:\\n assert tokens.ndim == 3, \\\"Finding dimension of tokens to be: {}\\\".format(tokens.ndim)\\n num_MSAs_in_batch, num_sequences_in_alignments, seqlen = tokens.size() # N, B, L (seqs with labels, seqs in MSA, seq length)\\n batch_size = num_MSAs_in_batch\\n else:\\n assert tokens.ndim == 2, \\\"Finding dimension of tokens to be: {}\\\".format(tokens.ndim)\\n batch_size, seqlen = tokens.size() # N, L (seqs with labels, seq length)\\n \\n if sequence_embeddings is not None:\\n x = sequence_embeddings.to(self.device)\\n else:\\n if self.args.aa_embeddings == \\\"MSA_Transformer\\\":\\n output = self.aa_embedding(tokens, repr_layers=[12])\\n x = output[\\\"representations\\\"][12][:] # N, B, L, D\\n x = x[:,0,:,:] # N, L, D. #In each MSA batch the first sequence is what we care about. The other MSA sequences were just to compute embeddings and logits\\n elif self.args.aa_embeddings == \\\"ESM1v\\\":\\n last_layer_index = 33\\n output = self.aa_embedding(tokens, repr_layers=[last_layer_index])\\n x = output[\\\"representations\\\"][last_layer_index][:] # N, L, D\\n elif self.args.aa_embeddings ==\\\"Linear_embedding\\\":\\n x = self.aa_embedding(tokens)\\n x = x + self.aa_positions_embedding(tokens.view(batch_size, seqlen)).view(x.size()) # Need position embedding in PNPT since we will apply axial attention\\n else:\\n print(\\\"AA embeddings not recognized\\\")\\n sys.exit(0)\\n \\n if self.aa_embedding_dim != self.args.embed_dim: x = self.token_embedding_projection(x)\\n \\n if self.args.target_prediction_head != \\\"Target_embeddings_and_AA_embeddings_mean_pooled\\\": #We mix AA embeddings pre NPT\\n if self.args.target_prediction_model == \\\"CNN\\\": \\n assert len(x.size())==3, \\\"Size error input\\\"\\n N, L, D = x.size()\\n x = x.permute(0,2,1) #N, D, L\\n x = self.layer_pre_head(x)\\n x = x.permute(0,2,1)\\n elif self.args.target_prediction_model == \\\"ConvBERT\\\":\\n x = self.layer_pre_head(x)[0]\\n\\n x = x.view(1, batch_size, seqlen, self.args.embed_dim) # 1, N, L, D\\n \\n #Dimensions for each target (there are self.num_targets of them):\\n y = []\\n for target_name in self.target_names_input:\\n num_sequences_with_target, dim_targets = targets[target_name].shape # N, D_t #In most cases dim_targets = D_t = 2 (original dimension of continuous input + 1 dim for mask)\\n y.append(self.target_embedding[target_name](targets[target_name]).view(num_sequences_with_target,1,self.args.embed_dim))\\n y = torch.cat(y, dim=-2) #concatenate across second to last dimension # N, num_targets, D\\n assert y.shape == (num_sequences_with_target, self.num_targets_input, self.args.embed_dim), \\\"Error in y shape: {}\\\".format(y.shape)\\n y = y.view(1, num_sequences_with_target, self.num_targets_input, self.args.embed_dim) # 1, N, num_targets, D\\n \\n #Concatenate AA tokens and targets\\n x = torch.cat((x,y),dim=-2) # 1, N, (L+num_targets), D\\n x = self.emb_layer_norm_before(x)\\n x = self.dropout_module(x)\\n\\n if padding_mask is not None:\\n padding_mask_with_targets = torch.zeros(num_MSAs_in_batch, num_sequences_in_alignments, seqlen + self.num_targets_input)\\n padding_mask_with_targets[...,:seqlen] = padding_mask\\n padding_mask = padding_mask_with_targets\\n x = x * (1 - padding_mask.unsqueeze(-1).type_as(x))\\n \\n repr_layers = set(repr_layers)\\n hidden_representations = {}\\n if 0 in repr_layers: hidden_representations[0] = x\\n if need_head_weights:\\n row_attn_weights = []\\n col_attn_weights = []\\n\\n # 1 x N x L x D -> N x L x 1 x D\\n x = x.permute(1, 2, 0, 3)\\n for layer_idx, layer in enumerate(self.layers):\\n x = layer(\\n x,\\n self_attn_padding_mask=padding_mask,\\n need_head_weights=need_head_weights,\\n )\\n if need_head_weights:\\n x, col_attn, row_attn = x\\n col_attn_weights.append(col_attn.permute(2, 0, 1, 3, 4).cpu())\\n row_attn_weights.append(row_attn.permute(1, 0, 2, 3).cpu())\\n if (layer_idx + 1) in repr_layers:\\n hidden_representations[layer_idx + 1] = x.permute(2, 0, 1, 3)\\n x = self.emb_layer_norm_after(x)\\n x = x.permute(2, 0, 1, 3) # N x L x 1 x D -> 1 x N x L x D\\n assert x.shape == (1, num_sequences_with_target, seqlen + self.num_targets_input, self.args.embed_dim), \\\"Error with axial transformer\\\"\\n # last hidden representation should have layer norm applied\\n if (layer_idx + 1) in repr_layers: hidden_representations[layer_idx + 1] = x\\n \\n # Loss over NPT MLM objective\\n if self.aa_embedding_dim != self.args.embed_dim:\\n logits_protein_sequence = self.lm_head(self.token_embedding_expansion(x[...,:seqlen,:]))\\n else:\\n logits_protein_sequence = self.lm_head(x[...,:seqlen,:]) #Remove dependency on targets for final AA predictions. logits size: (1, N, L, Vocab)\\n \\n x = x.view(num_sequences_with_target, seqlen + self.num_targets_input, self.args.embed_dim)\\n x, y = x[:,:seqlen,:], x[:,seqlen:,:] # (N,L,D) and (N,num_targets,D)\\n assert y.shape == (num_sequences_with_target, self.num_targets_input, self.args.embed_dim)\\n if self.args.target_prediction_head == \\\"Target_embeddings_and_AA_embeddings_mean_pooled\\\": \\n if self.args.target_prediction_model == \\\"CNN\\\": \\n assert len(x.size())==3, \\\"Size error input\\\"\\n N, L, D = x.size()\\n x = x.permute(0,2,1) #N, D, L\\n x = self.layer_pre_head(x)\\n x = x.permute(0,2,1)\\n elif self.args.target_prediction_model == \\\"ConvBERT\\\":\\n x = self.layer_pre_head(x)[0]\\n x = x.mean(dim=-2) # N, D\\n y = y.view(num_sequences_with_target,self.num_targets_input * self.args.embed_dim)\\n y = torch.cat((x,y),dim=-1) # N, (1+num_targets) * D\\n \\n target_predictions = {}\\n for target_index, target_name in enumerate(self.target_names):\\n if self.args.target_prediction_head == \\\"Target_embeddings_and_AA_embeddings_mean_pooled\\\": \\n target_predictions[target_name] = self.target_pred_head[target_name](y).view(-1) #We use the concatenated X and target embeddings (all of them) to predict each target\\n else:\\n if self.args.target_prediction_model == \\\"MLP\\\": y[:,target_index,:] = self.layer_pre_head[target_name](y[:,target_index,:])\\n target_predictions[target_name] = self.target_pred_head[target_name](y[:,target_index,:]).view(-1) #input the embedding with the relevant target_index\\n if self.args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n target_predictions[target_name] += self.zero_shot_fitness_prediction_weight[target_name](zero_shot_fitness_predictions).squeeze()\\n \\n result = {\\\"logits_protein_sequence\\\": logits_protein_sequence, \\\"target_predictions\\\": target_predictions, \\\"representations\\\": hidden_representations}\\n \\n if need_head_weights:\\n col_attentions = torch.stack(col_attn_weights, 1)\\n row_attentions = torch.stack(row_attn_weights, 1)\\n result[\\\"col_attentions\\\"] = col_attentions\\n result[\\\"row_attentions\\\"] = row_attentions\\n\\n return result\\n\\n def forward_with_uncertainty(self, tokens, targets, zero_shot_fitness_predictions=None, sequence_embeddings=None, num_MC_dropout_samples=10, number_of_mutated_seqs_to_score=None):\\n \\\"\\\"\\\"\\n Performs MC dropout to compute predictions and the corresponding uncertainties.\\n Assumes 1D predictions (eg., prediction of continuous output)\\n \\\"\\\"\\\"\\n self.eval() \\n for m in self.modules(): #Move all dropout layers in train mode to support MC dropout. Keep everything else in eval mode.\\n if m.__class__.__name__.startswith('Dropout'):\\n m.train()\\n with torch.no_grad():\\n predictions_dict = defaultdict(list)\\n for _ in range(num_MC_dropout_samples):\\n target_predictions_sample = self.forward(tokens, targets, zero_shot_fitness_predictions=zero_shot_fitness_predictions, sequence_embeddings=sequence_embeddings)[\\\"target_predictions\\\"]\\n for target_name in self.target_names:\\n predictions_dict[target_name].append(target_predictions_sample[target_name])\\n results_with_uncertainty={}\\n for target_name in self.target_names:\\n concatenated_target_pred = torch.cat([x.view(-1,1) for x in predictions_dict[target_name]],dim=-1)\\n results_with_uncertainty[target_name] = {}\\n results_with_uncertainty[target_name]['predictions_avg'] = concatenated_target_pred.mean(dim=-1)\\n results_with_uncertainty[target_name]['uncertainty'] = concatenated_target_pred.std(dim=-1)\\n return results_with_uncertainty\\n \\n @property\\n def num_layers(self):\\n return self.args.num_protein_npt_layers\\n \\n def max_tokens_per_msa_(self, value: int) -> None:\\n \\\"\\\"\\\"\\n Batching attention computations when gradients are disabled as per MSA_Transformer\\n Set this value to infinity to disable this behavior.\\n \\\"\\\"\\\"\\n for module in self.modules():\\n if isinstance(module, (RowSelfAttention, ColumnSelfAttention)):\\n module.max_tokens_per_msa = value\\n\\n def protein_npt_loss(self, token_predictions_logits, token_labels, target_predictions, target_labels, MLM_reconstruction_loss_weight, label_smoothing=0.0):\\n target_prediction_loss_weight = 1.0 - MLM_reconstruction_loss_weight\\n total_loss = 0.0\\n if (token_labels is not None) and (MLM_reconstruction_loss_weight > 0.0):\\n if self.args.aa_embeddings == \\\"MSA_Transformer\\\" and self.args.sequence_embeddings_location is None: token_labels = token_labels[:,0,:] #Only keep the token labels for seq to score. Drops the token labels for MSA sequences\\n masked_lm_loss = CrossEntropyLoss(reduction=\\\"mean\\\", label_smoothing=label_smoothing)(token_predictions_logits.reshape(-1, self.alphabet_size), token_labels.reshape(-1))\\n reconstruction_loss = masked_lm_loss\\n total_loss += MLM_reconstruction_loss_weight * reconstruction_loss\\n else:\\n reconstruction_loss = torch.tensor(0.0)\\n target_prediction_loss = {}\\n for target_name in self.target_names:\\n if self.args.target_config[target_name][\\\"in_NPT_loss\\\"]:\\n if self.args.target_config[target_name][\\\"type\\\"]==\\\"continuous\\\":\\n loss_masked_targets = ~target_labels[target_name].eq(-100) #Masked items are the ones for which the label was not set to -100\\n if loss_masked_targets.sum()==0 or torch.isnan(target_labels[target_name][loss_masked_targets]).sum() > 0: #First condition true if we dont mask anything (eg., all target missing at eval). Second condition true if we force-mask one value at train time (to satisfy min_num_labels_masked in mast_target()) and corresponding target value is missing\\n tgt_loss = torch.tensor(0.0)\\n else:\\n tgt_loss = MSELoss(reduction=\\\"mean\\\")(target_predictions[target_name][loss_masked_targets], target_labels[target_name][loss_masked_targets]) #we do not average the loss per batch, so that it's easier to do 1 full average across all batches\\n if torch.isnan(tgt_loss).sum() > 0:\\n print(\\\"Detected nan loss\\\")\\n print(target_predictions[target_name])\\n else:\\n tgt_loss = CrossEntropyLoss(reduction=\\\"mean\\\", label_smoothing=label_smoothing)(target_predictions[target_name].view(-1, self.args.target_config[target_name][\\\"dim\\\"]), target_labels[target_name].view(-1)) # Note: we dont add one to the # of categories in the CE loss here (we dont predict <mask>)\\n target_prediction_loss[target_name] = tgt_loss\\n \\n total_loss += target_prediction_loss_weight * target_prediction_loss[target_name]\\n return total_loss, reconstruction_loss, target_prediction_loss\\n\\n def create_optimizer(self):\\n \\\"\\\"\\\"\\n Setup the optimizer.\\n We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the\\n Trainer's init through `optimizers`, or subclass and override this method in a subclass.\\n Adapted from Huggingface Transformers library.\\n \\\"\\\"\\\"\\n if self.optimizer is None:\\n all_parameters = utils.model_utils.get_parameter_names(self, [nn.LayerNorm])\\n decay_parameters = [name for name in all_parameters if (\\\"bias\\\" not in name and \\\"pseudo_likelihood_weight\\\" not in name and 'zero_shot_fitness_prediction_weight' not in name)]\\n psl_decay_parameters = [name for name in all_parameters if (\\\"bias\\\" not in name and (\\\"pseudo_likelihood_weight\\\" in name or \\\"zero_shot_fitness_prediction_weight\\\" in name))]\\n optimizer_grouped_parameters = [\\n {\\n \\\"params\\\": [p for n, p in self.named_parameters() if n in decay_parameters],\\n \\\"weight_decay\\\": self.args.weight_decay,\\n },\\n {\\n \\\"params\\\": [p for n, p in self.named_parameters() if n in psl_decay_parameters],\\n \\\"weight_decay\\\": 1e-8, #Small decay on pseudo-likelihood as in Hsu et al.\\n },\\n {\\n \\\"params\\\": [p for n, p in self.named_parameters() if (n not in decay_parameters and n not in psl_decay_parameters)],\\n \\\"weight_decay\\\": 0.0,\\n },\\n ] \\n optimizer_kwargs = {\\n \\\"betas\\\": (self.args.adam_beta1, self.args.adam_beta2),\\n \\\"eps\\\": self.args.adam_epsilon,\\n \\\"lr\\\": self.args.max_learning_rate\\n }\\n optimizer = AdamW(optimizer_grouped_parameters, **optimizer_kwargs)\\n return optimizer\"\n },\n {\n \"identifier\": \"AugmentedPropertyPredictor\",\n \"path\": \"baselines/model.py\",\n \"snippet\": \"class AugmentedPropertyPredictor(nn.Module):\\n def __init__(self, args, alphabet):\\n super().__init__()\\n self.args = args\\n self.alphabet = alphabet\\n self.alphabet_size = len(alphabet)\\n print(\\\"Alphabet: {}\\\".format(alphabet))\\n print(\\\"Alphabet size: {}\\\".format(self.alphabet_size))\\n self.padding_idx = alphabet.padding_idx\\n self.mask_idx = alphabet.mask_idx\\n self.cls_idx = alphabet.cls_idx\\n self.eos_idx = alphabet.eos_idx\\n self.prepend_bos = alphabet.prepend_bos\\n self.append_eos = alphabet.append_eos\\n self.target_names = self.args.target_config.keys() \\n self.MSA_sample_sequences = None \\n self.device = None\\n self.model_type = args.model_type \\n if self.args.aa_embeddings in [\\\"MSA_Transformer\\\",\\\"ESM1v\\\"]:\\n model, _ = utils.esm.pretrained.load_model_and_alphabet(args.embedding_model_location)\\n self.aa_embedding = model\\n if self.args.aa_embeddings == \\\"MSA_Transformer\\\": self.args.seq_len = self.args.MSA_seq_len #If MSA does not cover full sequence length, we adjust seq_len param to be MSA_len (sequences truncated as needed in preprocessing)\\n elif self.args.aa_embeddings == \\\"Linear_embedding\\\":\\n self.aa_embedding = nn.Sequential(\\n nn.Embedding(\\n self.alphabet_size, self.args.embed_dim, padding_idx=self.padding_idx\\n ),\\n nn.ReLU()\\n )\\n elif self.args.aa_embeddings == \\\"One_hot_encoding\\\":\\n self.args.target_prediction_head == \\\"One_hot_encoding\\\"\\n elif self.args.aa_embeddings == \\\"Tranception\\\":\\n self.aa_embedding_dim = 1280\\n config = json.load(open(args.embedding_model_location+os.sep+'config.json'))\\n config = utils.tranception.config.TranceptionConfig(**config)\\n config.tokenizer = get_tranception_tokenizer()\\n config.inference_time_retrieval_type = None\\n config.retrieval_aggregation_mode = None\\n self.aa_embedding = utils.tranception.model_pytorch.TranceptionLMHeadModel.from_pretrained(pretrained_model_name_or_path=args.embedding_model_location,config=config)\\n self.config = config\\n else:\\n print(\\\"Error: Specified AA embedding invalid\\\")\\n sys.exit(0)\\n\\n if self.args.aa_embeddings != \\\"One_hot_encoding\\\": \\n self.emb_layer_norm_after = ESM1bLayerNorm(self.args.embed_dim)\\n self.dropout_module = nn.Dropout(self.args.dropout)\\n\\n if self.args.target_prediction_head == \\\"AA_embeddings_mean_pooled\\\":\\n target_pred_input_dim = self.args.embed_dim\\n elif self.args.target_prediction_head == \\\"One_hot_encoding\\\":\\n target_pred_input_dim = (self.args.seq_len + 1) * self.alphabet_size if args.target_prediction_model!=\\\"CNN\\\" else self.alphabet_size #Add one for the BOS token\\n else:\\n print(self.args.target_prediction_head)\\n print(\\\"Error: Specified embedding aggregation invalid\\\")\\n sys.exit(0)\\n \\n if args.target_prediction_model==\\\"MLP\\\":\\n self.layer_pre_head = nn.Sequential(\\n nn.Linear(target_pred_input_dim, target_pred_input_dim),\\n nn.Dropout(self.args.dropout),\\n nn.ReLU()\\n )\\n elif args.target_prediction_model==\\\"ConvBERT\\\":\\n configuration = ConvBertConfig(\\n hidden_size = self.args.embed_dim,\\n num_attention_heads = self.args.attention_heads if self.args.attention_heads is not None else 4,\\n conv_kernel_size = self.args.conv_kernel_size,\\n hidden_act = \\\"gelu\\\",\\n hidden_dropout_prob = self.args.dropout,\\n attention_probs_dropout_prob = self.args.dropout\\n )\\n self.layer_pre_head = ConvBertLayer(configuration)\\n elif args.target_prediction_model==\\\"CNN\\\":\\n self.layer_pre_head = nn.Sequential(\\n nn.Conv1d(in_channels=target_pred_input_dim, out_channels=target_pred_input_dim, kernel_size = self.args.conv_kernel_size, padding='same'),\\n nn.Dropout(self.args.dropout),\\n nn.ReLU()\\n )\\n target_pred_input_dim = target_pred_input_dim if self.args.target_prediction_head != \\\"One_hot_encoding\\\" else target_pred_input_dim * (self.args.seq_len + 1)\\n elif args.target_prediction_model==\\\"light_attention\\\":\\n # Adapted from Stark et al (https://github.com/HannesStark/protein-localization)\\n self.feature_convolution = nn.Conv1d(self.args.embed_dim, self.args.embed_dim, self.args.conv_kernel_size, stride=1, padding='same')\\n self.attention_convolution = nn.Conv1d(self.args.embed_dim, self.args.embed_dim, self.args.conv_kernel_size, stride=1, padding='same')\\n self.softmax = nn.Softmax(dim=-1)\\n self.dropout = nn.Dropout(self.args.dropout)\\n self.linear = nn.Sequential(\\n nn.Linear(2 * self.args.embed_dim, 32),\\n nn.Dropout(self.args.dropout),\\n nn.ReLU(),\\n nn.BatchNorm1d(32)\\n )\\n target_pred_input_dim = 32\\n elif args.target_prediction_model==\\\"linear\\\":\\n pass\\n else:\\n print(\\\"Error: Specified layer_pre_head invalid\\\")\\n sys.exit(0)\\n\\n if self.args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n self.zero_shot_fitness_prediction_weight = nn.ModuleDict(\\n { \\n target_name: nn.Linear(1, self.args.target_config[target_name][\\\"dim\\\"], bias=False)\\n for target_name in self.target_names\\n }\\n )\\n for target_name in self.target_names:\\n torch.nn.init.constant_(self.zero_shot_fitness_prediction_weight[target_name].weight,1.0)\\n\\n self.target_pred_head = nn.ModuleDict(\\n { \\n target_name: nn.Linear(target_pred_input_dim, self.args.target_config[target_name][\\\"dim\\\"])\\n for target_name in self.target_names #If multiple targets, we learn a separate linear head for each separately\\n }\\n )\\n \\n def set_device(self):\\n if self.device is None:\\n self.device = next(self.parameters()).device\\n print(\\\"Model device: {}\\\".format(self.device))\\n\\n def forward(self, tokens, zero_shot_fitness_predictions=None, sequence_embeddings=None, repr_layers=[]):\\n if self.args.aa_embeddings == \\\"MSA_Transformer\\\" and self.args.sequence_embeddings_location is None:\\n assert tokens.ndim == 3, \\\"Finding dimension of tokens to be: {}\\\".format(tokens.ndim)\\n num_MSAs_in_batch, num_sequences_in_alignments, seqlen = tokens.size()\\n batch_size = num_MSAs_in_batch\\n else:\\n assert tokens.ndim == 2, \\\"Finding dimension of tokens to be: {}\\\".format(tokens.ndim)\\n batch_size, seqlen = tokens.size()\\n \\n if sequence_embeddings is not None:\\n x = sequence_embeddings.to(self.device)\\n else:\\n if self.args.aa_embeddings == \\\"MSA_Transformer\\\":\\n output = self.aa_embedding(tokens, repr_layers=[12])\\n x = output[\\\"representations\\\"][12][:] # B, N, L, D\\n x = x[:,0,:,:] #In each MSA batch the first sequence is what we care about. The other MSA sequences were just to compute embeddings and logits\\n elif self.args.aa_embeddings == \\\"ESM1v\\\":\\n last_layer_index = 33\\n output = self.aa_embedding(tokens, repr_layers=[last_layer_index])\\n x = output[\\\"representations\\\"][last_layer_index][:] # N, L, D\\n elif self.args.aa_embeddings == \\\"Tranception\\\":\\n processed_batch = {'input_ids': tokens, 'labels': tokens}\\n output = self.aa_embedding(**processed_batch, return_dict=True, output_hidden_states=True)\\n x = output.hidden_states[0]\\n elif self.args.aa_embeddings ==\\\"Linear_embedding\\\":\\n x = self.aa_embedding(tokens)\\n elif self.args.aa_embeddings == \\\"One_hot_encoding\\\":\\n x = nn.functional.one_hot(tokens, num_classes=self.alphabet_size).view(batch_size,-1).float()\\n if self.args.target_prediction_model == \\\"CNN\\\": x = x.view(batch_size,seqlen,self.alphabet_size)\\n\\n if self.args.aa_embeddings != \\\"One_hot_encoding\\\":\\n x = self.emb_layer_norm_after(x)\\n x = self.dropout_module(x)\\n \\n repr_layers = set(repr_layers)\\n hidden_representations = {}\\n if 0 in repr_layers:\\n hidden_representations[0] = x\\n\\n if self.args.target_prediction_model == \\\"CNN\\\": \\n assert len(x.size())==3, \\\"Size error input\\\"\\n N, L, D = x.size()\\n x = x.permute(0,2,1) #N, D, L\\n x = self.layer_pre_head(x)\\n x = x.permute(0,2,1)\\n elif self.args.target_prediction_model == \\\"ConvBERT\\\":\\n x = self.layer_pre_head(x)[0]\\n elif self.args.target_prediction_model==\\\"light_attention\\\":\\n x = x.permute(0,2,1) #N, D, L\\n o = self.feature_convolution(x) \\n o = self.dropout(o)\\n attention = self.attention_convolution(x)\\n o1 = torch.sum(o * self.softmax(attention), dim=-1)\\n o2, _ = torch.max(o, dim=-1)\\n o = torch.cat([o1, o2], dim=-1)\\n x = self.linear(o)\\n \\n if self.args.target_prediction_head == \\\"AA_embeddings_mean_pooled\\\": x = x.mean(dim=-2)\\n \\n if self.args.target_prediction_model == \\\"MLP\\\": x = self.layer_pre_head(x)\\n \\n target_predictions = {}\\n for target_name in self.target_names:\\n target_predictions[target_name] = self.target_pred_head[target_name](x).view(-1)\\n if self.args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n target_predictions[target_name] += self.zero_shot_fitness_prediction_weight[target_name](zero_shot_fitness_predictions).squeeze()\\n\\n result = {\\\"target_predictions\\\": target_predictions, \\\"representations\\\": hidden_representations}\\n \\n return result\\n \\n def forward_with_uncertainty(self, tokens, zero_shot_fitness_predictions=None, sequence_embeddings=None, num_MC_dropout_samples=10):\\n \\\"\\\"\\\"\\n Performs MC dropout to compute predictions and the corresponding uncertainties.\\n Assumes 1D predictions (eg., prediction of continuous output).\\n \\\"\\\"\\\"\\n self.eval() \\n for m in self.modules(): #Move all dropout layers in train mode to support MC dropout. Keep everything else in eval mode.\\n if m.__class__.__name__.startswith('Dropout'):\\n m.train()\\n with torch.no_grad(): \\n predictions_dict = defaultdict(list)\\n for _ in range(num_MC_dropout_samples):\\n target_predictions_sample = self.forward(tokens, zero_shot_fitness_predictions=zero_shot_fitness_predictions, sequence_embeddings=sequence_embeddings)[\\\"target_predictions\\\"]\\n for target_name in self.target_names:\\n predictions_dict[target_name].append(target_predictions_sample[target_name])\\n results_with_uncertainty={}\\n for target_name in self.target_names:\\n concatenated_target_pred = torch.cat([x.view(-1,1) for x in predictions_dict[target_name]],dim=-1)\\n results_with_uncertainty[target_name] = {}\\n results_with_uncertainty[target_name]['predictions_avg'] = concatenated_target_pred.mean(dim=-1)\\n results_with_uncertainty[target_name]['uncertainty'] = concatenated_target_pred.std(dim=-1)\\n return results_with_uncertainty\\n\\n @property\\n def num_layers(self):\\n return self.args.num_protein_npt_layers\\n \\n def max_tokens_per_msa_(self, value: int) -> None:\\n \\\"\\\"\\\"\\n Batching attention computations when gradients are disabled as per MSA_Transformer\\n Set this value to infinity to disable this behavior.\\n \\\"\\\"\\\"\\n for module in self.modules():\\n if isinstance(module, (RowSelfAttention, ColumnSelfAttention)):\\n module.max_tokens_per_msa = value\\n\\n def prediction_loss(self, target_predictions, target_labels, label_smoothing=0.1):\\n total_target_prediction_loss = 0.0\\n target_prediction_loss_dict = {}\\n for target_name in self.target_names:\\n non_missing_target_indicator = ~torch.isnan(target_labels[target_name])\\n if self.args.target_config[target_name][\\\"type\\\"]==\\\"continuous\\\":\\n tgt_loss = MSELoss(reduction=\\\"sum\\\")(target_predictions[target_name][non_missing_target_indicator], target_labels[target_name][non_missing_target_indicator])\\n else:\\n tgt_loss = CrossEntropyLoss(reduction=\\\"none\\\",label_smoothing=label_smoothing)(target_predictions[target_name].view(-1, self.args.target_config[target_name][\\\"dim\\\"]), target_labels[target_name].view(-1))\\n target_prediction_loss_dict[target_name] = tgt_loss\\n total_target_prediction_loss += tgt_loss\\n return total_target_prediction_loss, target_prediction_loss_dict\\n\\n def create_optimizer(self):\\n \\\"\\\"\\\"\\n Setup the optimizer.\\n We provide a reasonable default that works well. If you want to use something else, you can pass a tuple in the\\n Trainer's init through `optimizers`, or subclass and override this method in a subclass.\\n Adapted from Huggingface Transformers library.\\n \\\"\\\"\\\"\\n all_parameters = utils.model_utils.get_parameter_names(self, [nn.LayerNorm])\\n decay_parameters = [name for name in all_parameters if (\\\"bias\\\" not in name and \\\"pseudo_likelihood_weight\\\" not in name and 'zero_shot_fitness_prediction_weight' not in name)]\\n psl_decay_parameters = [name for name in all_parameters if (\\\"bias\\\" not in name and (\\\"pseudo_likelihood_weight\\\" in name or \\\"zero_shot_fitness_prediction_weight\\\" in name))]\\n optimizer_grouped_parameters = [\\n {\\n \\\"params\\\": [p for n, p in self.named_parameters() if n in decay_parameters],\\n \\\"weight_decay\\\": self.args.weight_decay,\\n },\\n {\\n \\\"params\\\": [p for n, p in self.named_parameters() if n in psl_decay_parameters],\\n \\\"weight_decay\\\": 1e-8, #Small decay on pseudo-likelihood as in Hsu et al.\\n },\\n {\\n \\\"params\\\": [p for n, p in self.named_parameters() if (n not in decay_parameters and n not in psl_decay_parameters)],\\n \\\"weight_decay\\\": 0.0,\\n },\\n ] \\n optimizer_kwargs = {\\n \\\"betas\\\": (self.args.adam_beta1, self.args.adam_beta2),\\n \\\"eps\\\": self.args.adam_epsilon,\\n \\\"lr\\\": self.args.max_learning_rate\\n }\\n optimizer = AdamW(optimizer_grouped_parameters, **optimizer_kwargs)\\n return optimizer\"\n },\n {\n \"identifier\": \"Alphabet\",\n \"path\": \"utils/esm/data.py\",\n \"snippet\": \"class Alphabet(object):\\n def __init__(\\n self,\\n standard_toks: Sequence[str],\\n prepend_toks: Sequence[str] = (\\\"<null_0>\\\", \\\"<pad>\\\", \\\"<eos>\\\", \\\"<unk>\\\"),\\n append_toks: Sequence[str] = (\\\"<cls>\\\", \\\"<mask>\\\", \\\"<sep>\\\"),\\n prepend_bos: bool = True,\\n append_eos: bool = False,\\n use_msa: bool = False,\\n ):\\n #ESM Alphabet: {'<cls>': 0, '<pad>': 1, '<eos>': 2, '<unk>': 3, 'L': 4, 'A': 5, 'G': 6, 'V': 7, 'S': 8, 'E': 9, 'R': 10, 'T': 11, 'I': 12, 'D': 13, 'P': 14, 'K': 15, 'Q': 16, 'N': 17, 'F': 18, 'Y': 19, 'M': 20, 'H': 21, 'W': 22, 'C': 23, 'X': 24, 'B': 25, 'U': 26, 'Z': 27, 'O': 28, '.': 29, '-': 30, '<null_1>': 31, '<mask>': 32}\\n self.standard_toks = list(standard_toks)\\n self.prepend_toks = list(prepend_toks)\\n self.append_toks = list(append_toks)\\n self.prepend_bos = prepend_bos\\n self.append_eos = append_eos\\n self.use_msa = use_msa\\n\\n self.all_toks = list(self.prepend_toks)\\n self.all_toks.extend(self.standard_toks)\\n for i in range((8 - (len(self.all_toks) % 8)) % 8):\\n self.all_toks.append(f\\\"<null_{i + 1}>\\\")\\n self.all_toks.extend(self.append_toks)\\n\\n self.tok_to_idx = {tok: i for i, tok in enumerate(self.all_toks)}\\n\\n self.unk_idx = self.tok_to_idx[\\\"<unk>\\\"]\\n self.padding_idx = self.get_idx(\\\"<pad>\\\")\\n self.cls_idx = self.get_idx(\\\"<cls>\\\")\\n self.mask_idx = self.get_idx(\\\"<mask>\\\")\\n self.eos_idx = self.get_idx(\\\"<eos>\\\")\\n self.all_special_tokens = ['<eos>', '<unk>', '<pad>', '<cls>', '<mask>']\\n self.unique_no_split_tokens = self.all_toks\\n\\n def __len__(self):\\n return len(self.all_toks)\\n\\n def get_idx(self, tok):\\n return self.tok_to_idx.get(tok, self.unk_idx)\\n\\n def get_tok(self, ind):\\n return self.all_toks[ind]\\n\\n def to_dict(self):\\n return self.tok_to_idx.copy()\\n\\n def get_batch_converter(self, truncation_seq_length: int = None):\\n if self.use_msa:\\n return MSABatchConverter(self, truncation_seq_length)\\n else:\\n return BatchConverter(self, truncation_seq_length)\\n\\n @classmethod\\n def from_architecture(cls, name: str) -> \\\"Alphabet\\\":\\n if name in (\\\"ESM-1\\\", \\\"protein_bert_base\\\"):\\n standard_toks = proteinseq_toks[\\\"toks\\\"]\\n prepend_toks: Tuple[str, ...] = (\\\"<null_0>\\\", \\\"<pad>\\\", \\\"<eos>\\\", \\\"<unk>\\\")\\n append_toks: Tuple[str, ...] = (\\\"<cls>\\\", \\\"<mask>\\\", \\\"<sep>\\\")\\n prepend_bos = True\\n append_eos = False\\n use_msa = False\\n elif name in (\\\"ESM-1b\\\", \\\"roberta_large\\\"):\\n standard_toks = proteinseq_toks[\\\"toks\\\"]\\n prepend_toks = (\\\"<cls>\\\", \\\"<pad>\\\", \\\"<eos>\\\", \\\"<unk>\\\")\\n append_toks = (\\\"<mask>\\\",)\\n prepend_bos = True\\n append_eos = True\\n use_msa = False\\n elif name in (\\\"MSA Transformer\\\", \\\"msa_transformer\\\"):\\n standard_toks = proteinseq_toks[\\\"toks\\\"]\\n prepend_toks = (\\\"<cls>\\\", \\\"<pad>\\\", \\\"<eos>\\\", \\\"<unk>\\\")\\n append_toks = (\\\"<mask>\\\",)\\n prepend_bos = True\\n append_eos = False\\n use_msa = True\\n elif \\\"invariant_gvp\\\" in name.lower():\\n standard_toks = proteinseq_toks[\\\"toks\\\"]\\n prepend_toks = (\\\"<null_0>\\\", \\\"<pad>\\\", \\\"<eos>\\\", \\\"<unk>\\\")\\n append_toks = (\\\"<mask>\\\", \\\"<cath>\\\", \\\"<af2>\\\")\\n prepend_bos = True\\n append_eos = False\\n use_msa = False\\n else:\\n raise ValueError(\\\"Unknown architecture selected\\\")\\n return cls(standard_toks, prepend_toks, append_toks, prepend_bos, append_eos, use_msa)\\n\\n def _tokenize(self, text) -> str:\\n return text.split()\\n\\n def tokenize(self, text, **kwargs) -> List[str]:\\n \\\"\\\"\\\"\\n Inspired by https://github.com/huggingface/transformers/blob/master/src/transformers/tokenization_utils.py\\n Converts a string in a sequence of tokens, using the tokenizer.\\n\\n Args:\\n text (:obj:`str`):\\n The sequence to be encoded.\\n\\n Returns:\\n :obj:`List[str]`: The list of tokens.\\n \\\"\\\"\\\"\\n\\n def split_on_token(tok, text):\\n result = []\\n split_text = text.split(tok)\\n for i, sub_text in enumerate(split_text):\\n # AddedToken can control whitespace stripping around them.\\n # We use them for GPT2 and Roberta to have different behavior depending on the special token\\n # Cf. https://github.com/huggingface/transformers/pull/2778\\n # and https://github.com/huggingface/transformers/issues/3788\\n # We strip left and right by default\\n if i < len(split_text) - 1:\\n sub_text = sub_text.rstrip()\\n if i > 0:\\n sub_text = sub_text.lstrip()\\n\\n if i == 0 and not sub_text:\\n result.append(tok)\\n elif i == len(split_text) - 1:\\n if sub_text:\\n result.append(sub_text)\\n else:\\n pass\\n else:\\n if sub_text:\\n result.append(sub_text)\\n result.append(tok)\\n return result\\n\\n def split_on_tokens(tok_list, text):\\n if not text.strip():\\n return []\\n\\n tokenized_text = []\\n text_list = [text]\\n for tok in tok_list:\\n tokenized_text = []\\n for sub_text in text_list:\\n if sub_text not in self.unique_no_split_tokens:\\n tokenized_text.extend(split_on_token(tok, sub_text))\\n else:\\n tokenized_text.append(sub_text)\\n text_list = tokenized_text\\n\\n return list(\\n itertools.chain.from_iterable(\\n (\\n self._tokenize(token)\\n if token not in self.unique_no_split_tokens\\n else [token]\\n for token in tokenized_text\\n )\\n )\\n )\\n\\n no_split_token = self.unique_no_split_tokens\\n tokenized_text = split_on_tokens(no_split_token, text)\\n return tokenized_text\\n\\n def encode(self, text):\\n return [self.tok_to_idx[tok] for tok in self.tokenize(text)]\"\n },\n {\n \"identifier\": \"get_tranception_tokenizer\",\n \"path\": \"utils/tranception/model_pytorch.py\",\n \"snippet\": \"def get_tranception_tokenizer():\\n #Tranception Alphabet: \\\"vocab\\\":{\\\"[UNK]\\\":0,\\\"[CLS]\\\":1,\\\"[SEP]\\\":2,\\\"[PAD]\\\":3,\\\"[MASK]\\\":4,\\\"A\\\":5,\\\"C\\\":6,\\\"D\\\":7,\\\"E\\\":8,\\\"F\\\":9,\\\"G\\\":10,\\\"H\\\":11,\\\"I\\\":12,\\\"K\\\":13,\\\"L\\\":14,\\\"M\\\":15,\\\"N\\\":16,\\\"P\\\":17,\\\"Q\\\":18,\\\"R\\\":19,\\\"S\\\":20,\\\"T\\\":21,\\\"V\\\":22,\\\"W\\\":23,\\\"Y\\\":24}\\n dir_path = os.path.dirname(os.path.abspath(__file__))\\n tokenizer = PreTrainedTokenizerFast(tokenizer_file=dir_path + os.sep + \\\"utils/tokenizers/Basic_tokenizer\\\", unk_token=\\\"[UNK]\\\", sep_token=\\\"[SEP]\\\", pad_token=\\\"[PAD]\\\", cls_token=\\\"[CLS]\\\",mask_token=\\\"[MASK]\\\")\\n os.environ[\\\"TOKENIZERS_PARALLELISM\\\"] = \\\"false\\\"\\n tokenizer.tok_to_idx = tokenizer.vocab\\n tokenizer.padding_idx = tokenizer.tok_to_idx[\\\"[PAD]\\\"]\\n tokenizer.mask_idx = tokenizer.tok_to_idx[\\\"[MASK]\\\"]\\n tokenizer.cls_idx = tokenizer.tok_to_idx[\\\"[CLS]\\\"]\\n tokenizer.eos_idx = tokenizer.tok_to_idx[\\\"[SEP]\\\"]\\n tokenizer.prepend_bos = True\\n tokenizer.append_eos = True\\n return tokenizer\"\n },\n {\n \"identifier\": \"get_train_val_test_data\",\n \"path\": \"utils/data_utils.py\",\n \"snippet\": \"def get_train_val_test_data(args, assay_file_names):\\n target_names = args.target_config.keys() \\n assay_data={}\\n merge = None\\n main_target_name = None\\n main_target_name_count = 0\\n for target in target_names:\\n if args.target_config[target][\\\"main_target\\\"]: \\n main_target_name=target\\n main_target_name_count+=1\\n assert main_target_name is not None, \\\"No main target referenced. Please update config to select a unique main target.\\\"\\n assert main_target_name_count <= 1, \\\"Several main targets referenced. Please update config to select a unique main target.\\\"\\n \\n assay_data[main_target_name] = pd.read_csv(args.target_config[main_target_name][\\\"location\\\"] + os.sep + assay_file_names[main_target_name])[['mutant','mutated_sequence',args.target_config[main_target_name][\\\"var_name\\\"],args.fold_variable_name]] \\n assay_data[main_target_name].columns = ['mutant','mutated_sequence', main_target_name, args.fold_variable_name]\\n merge = assay_data[main_target_name]\\n \\n for target_name in target_names:\\n if target_name!=main_target_name:\\n print(target_name)\\n print(args.target_config)\\n print(assay_file_names)\\n assay_data[target_name] = pd.read_csv(args.target_config[target_name][\\\"location\\\"] + os.sep + assay_file_names[target_name])[['mutant',args.target_config[target_name][\\\"var_name\\\"]]] \\n assay_data[target_name].columns = ['mutant',target_name]\\n merge = pd.merge(merge, assay_data[target_name], how='left', on='mutant')\\n \\n if args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n zero_shot_fitness_predictions = pd.read_csv(args.zero_shot_fitness_predictions_location + os.sep + assay_file_names[main_target_name])[['mutant',args.zero_shot_fitness_predictions_var_name]]\\n zero_shot_fitness_predictions.columns = ['mutant','zero_shot_fitness_predictions']\\n zero_shot_fitness_predictions['zero_shot_fitness_predictions'] = standardize(zero_shot_fitness_predictions['zero_shot_fitness_predictions'])\\n merge = pd.merge(merge,zero_shot_fitness_predictions,how='inner',on='mutant')\\n\\n train_val_test_splits = split_data_based_on_test_fold_index(\\n dataframe = merge, \\n fold_variable_name = args.fold_variable_name,\\n test_fold_index = args.test_fold_index,\\n use_validation_set = args.use_validation_set\\n )\\n splits_dict = {}\\n for split_name, split in zip(['train','val','test'], train_val_test_splits):\\n if split_name=='val' and not args.use_validation_set: continue\\n splits_dict[split_name] = {}\\n splits_dict[split_name]['mutant_mutated_seq_pairs'] = list(zip(list(split['mutant']),list(split['mutated_sequence'])))\\n raw_targets = {target_name: split[target_name] for target_name in target_names}\\n if args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\": raw_targets['zero_shot_fitness_predictions'] = split['zero_shot_fitness_predictions']\\n if split_name==\\\"train\\\":\\n raw_targets, target_processing = preprocess_training_targets(raw_targets, args.target_config)\\n else:\\n raw_targets = preprocess_test_targets(raw_targets, args.target_config, target_processing)\\n for target_name in target_names: \\n splits_dict[split_name][target_name] = raw_targets[target_name]\\n if args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\": splits_dict[split_name]['zero_shot_fitness_predictions'] = raw_targets['zero_shot_fitness_predictions']\\n # load dict into dataset objects\\n train_data = Dataset.from_dict(splits_dict['train'])\\n val_data = Dataset.from_dict(splits_dict['val']) if args.use_validation_set else None\\n test_data = Dataset.from_dict(splits_dict['test'])\\n return train_data, val_data, test_data, target_processing\"\n },\n {\n \"identifier\": \"standardize\",\n \"path\": \"utils/data_utils.py\",\n \"snippet\": \"def standardize(x):\\n return (x - x.mean()) / x.std()\"\n },\n {\n \"identifier\": \"pnpt_count_non_nan\",\n \"path\": \"utils/data_utils.py\",\n \"snippet\": \"def pnpt_count_non_nan(x):\\n missing_mask = np.isnan(x) | np.equal(x,-100)\\n return np.count_nonzero(~missing_mask)\"\n },\n {\n \"identifier\": \"pnpt_spearmanr\",\n \"path\": \"utils/data_utils.py\",\n \"snippet\": \"def pnpt_spearmanr(prediction,target):\\n mask_missing_values = np.isnan(target) | np.equal(target, -100) #In PNPT missing values are never masked so corresponding labels are always set to -100\\n return spearmanr(prediction[~mask_missing_values], target[~mask_missing_values])[0] #first value is spearman rho, second is the corresponding p-value \"\n },\n {\n \"identifier\": \"process_MSA\",\n \"path\": \"utils/msa_utils.py\",\n \"snippet\": \"def process_MSA(args, MSA_filename, MSA_weights_filename):\\n filtered_MSA_filename = filter_msa(filename = args.MSA_data_folder + os.sep + MSA_filename, path_to_hhfilter = args.path_to_hhfilter)\\n MSA_all_sequences, MSA_non_ref_sequences_weights = compute_sequence_weights(MSA_filename = filtered_MSA_filename, MSA_weights_filename = args.MSA_weight_data_folder + os.sep + MSA_weights_filename)\\n return MSA_all_sequences, MSA_non_ref_sequences_weights\"\n },\n {\n \"identifier\": \"Trainer\",\n \"path\": \"utils/model_utils.py\",\n \"snippet\": \"class Trainer():\\n def __init__(self, \\n model,\\n args,\\n train_data, \\n val_data,\\n MSA_sequences, \\n MSA_weights,\\n MSA_start_position,\\n MSA_end_position,\\n target_processing,\\n distributed_training=False\\n ):\\n self.model = model\\n self.args = args\\n self.train_data = train_data\\n self.val_data = val_data\\n self.MSA_sequences = MSA_sequences\\n self.MSA_weights = MSA_weights\\n self.MSA_start_position = MSA_start_position\\n self.MSA_end_position = MSA_end_position\\n self.target_processing = target_processing\\n self.distributed_training = distributed_training\\n \\n def train(self):\\n \\\"\\\"\\\"\\n Returns the last value of training_step (useful in case of early stopping for isntance)\\n \\\"\\\"\\\"\\n \\n self.model.train()\\n self.model.cuda()\\n self.model.set_device()\\n\\n if self.distributed_training:\\n self.model = torch.nn.parallel.DistributedDataParallel(self.model)\\n train_sampler = torch.utils.data.distributed.DistributedSampler(self.train_data)\\n else:\\n train_sampler = None\\n \\n #To ensure reproducibility with seed setting\\n def seed_worker(worker_id):\\n worker_seed = torch.initial_seed() % 2**32\\n np.random.seed(worker_seed)\\n random.seed(worker_seed)\\n g = torch.Generator()\\n g.manual_seed(0)\\n train_loader = torch.utils.data.DataLoader(\\n dataset=self.train_data, \\n batch_size=self.args.training_num_assay_sequences_per_batch_per_gpu, \\n shuffle=(train_sampler is None),\\n num_workers=self.args.num_data_loaders_workers, \\n pin_memory=True, \\n sampler=train_sampler,\\n collate_fn=collate_fn_protein_npt,\\n worker_init_fn=seed_worker,\\n generator=g,\\n )\\n optimizer = self.model.create_optimizer()\\n scheduler = learning_rate_scheduler(\\n num_warmup_steps=self.args.num_warmup_steps, \\n num_total_training_steps=self.args.num_total_training_steps, \\n max_learning_rate=self.args.max_learning_rate, \\n min_learning_rate=self.args.min_learning_rate\\n )\\n \\n train_iterator = iter(train_loader)\\n num_epochs = 0\\n prior_log_time = time.time()\\n total_train_time = 0\\n log_train_total_loss = 0\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n log_train_reconstruction_loss = 0\\n log_train_num_masked_tokens = 0\\n log_train_num_target_masked_tokens_dict = defaultdict(int)\\n else:\\n log_num_sequences_predicted = 0\\n log_train_target_prediction_loss_dict = defaultdict(int)\\n all_spearmans_eval_during_training = []\\n max_average_spearman_across_targets = - math.inf\\n if self.args.training_fp16: scaler = torch.cuda.amp.GradScaler()\\n\\n for training_step in tqdm.tqdm(range(1, self.args.num_total_training_steps+1)):\\n optimizer.zero_grad(set_to_none=True)\\n lr = scheduler(training_step)\\n update_lr_optimizer(optimizer, lr)\\n reconstruction_loss_coeff = get_reconstruction_loss_coefficient(training_step, num_total_training_steps=self.args.num_total_training_steps) if (self.model.model_type==\\\"ProteinNPT\\\" and not self.model.PNPT_no_reconstruction_error) else 0\\n for gradient_accum_step in range(self.args.gradient_accumulation):\\n try:\\n batch = next(train_iterator)\\n except:\\n num_epochs +=1\\n train_iterator = iter(train_loader)\\n batch = next(train_iterator)\\n \\n if self.model.model_type==\\\"ProteinNPT\\\":\\n processed_batch = proteinnpt.data_processing.process_batch(\\n batch = batch,\\n model = self.model,\\n alphabet = self.model.alphabet, \\n args = self.args, \\n MSA_sequences = self.MSA_sequences, \\n MSA_weights = self.MSA_weights,\\n MSA_start_position = self.MSA_start_position, \\n MSA_end_position = self.MSA_end_position,\\n target_processing = self.target_processing,\\n training_sequences = None,\\n proba_target_mask = 0.15,\\n proba_aa_mask = 0.15,\\n eval_mode = False,\\n device=self.model.device,\\n indel_mode=self.args.indel_mode\\n )\\n else:\\n processed_batch = baselines.data_processing.process_batch(\\n batch = batch,\\n model = self.model,\\n alphabet = self.model.alphabet, \\n args = self.args, \\n MSA_sequences = self.MSA_sequences, \\n MSA_weights = self.MSA_weights,\\n MSA_start_position = self.MSA_start_position, \\n MSA_end_position = self.MSA_end_position,\\n device=self.model.device,\\n eval_mode=False,\\n indel_mode=self.args.indel_mode\\n )\\n\\n if self.args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n zero_shot_fitness_predictions = processed_batch['target_labels']['zero_shot_fitness_predictions'].view(-1,1)\\n del processed_batch['target_labels']['zero_shot_fitness_predictions']\\n else:\\n zero_shot_fitness_predictions = None\\n \\n if self.args.training_fp16:\\n with torch.cuda.amp.autocast():\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n output = self.model(\\n tokens=processed_batch['masked_tokens'],\\n targets=processed_batch['masked_targets'],\\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\\n sequence_embeddings=processed_batch['sequence_embeddings']\\n )\\n total_loss, reconstruction_loss, target_prediction_loss_dict = self.model.protein_npt_loss(\\n token_predictions_logits=output['logits_protein_sequence'], \\n token_labels=processed_batch['token_labels'], \\n target_predictions=output['target_predictions'], \\n target_labels=processed_batch['target_labels'], \\n MLM_reconstruction_loss_weight=reconstruction_loss_coeff, \\n label_smoothing=self.args.label_smoothing\\n )\\n else:\\n output = self.model(\\n tokens=processed_batch['input_tokens'],\\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\\n sequence_embeddings=processed_batch['sequence_embeddings']\\n )\\n total_loss, target_prediction_loss_dict = self.model.prediction_loss(\\n target_predictions=output[\\\"target_predictions\\\"], \\n target_labels=processed_batch['target_labels'],\\n label_smoothing=self.args.label_smoothing\\n )\\n scaler.scale(total_loss).backward()\\n else:\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n output = self.model(\\n tokens=processed_batch['masked_tokens'],\\n targets=processed_batch['masked_targets'],\\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\\n sequence_embeddings=processed_batch['sequence_embeddings']\\n )\\n total_loss, reconstruction_loss, target_prediction_loss_dict = self.model.protein_npt_loss(\\n token_predictions_logits=output['logits_protein_sequence'], \\n token_labels=processed_batch['token_labels'], \\n target_predictions=output['target_predictions'], \\n target_labels=processed_batch['target_labels'], \\n MLM_reconstruction_loss_weight=reconstruction_loss_coeff, \\n label_smoothing=self.args.label_smoothing\\n )\\n if total_loss.item() > 10.0 and training_step >= 100:\\n print(\\\"High training loss detected: {}\\\".format(total_loss.item()))\\n else:\\n output = self.model(\\n tokens=processed_batch['input_tokens'],\\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\\n sequence_embeddings=processed_batch['sequence_embeddings']\\n )\\n total_loss, target_prediction_loss_dict = self.model.prediction_loss(\\n target_predictions=output[\\\"target_predictions\\\"], \\n target_labels=processed_batch['target_labels'],\\n label_smoothing=self.args.label_smoothing\\n )\\n total_loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.args.grad_norm_clip)\\n # Taking optimizer update out of the inner loop to support gradient accumulation\\n if self.args.training_fp16:\\n with torch.cuda.amp.autocast():\\n scaler.step(optimizer)\\n scaler.update()\\n else:\\n optimizer.step()\\n\\n log_train_total_loss += total_loss\\n for target_name in self.model.target_names:\\n log_train_target_prediction_loss_dict[target_name] += target_prediction_loss_dict[target_name]\\n if self.model.model_type==\\\"ProteinNPT\\\": \\n log_train_reconstruction_loss += reconstruction_loss\\n log_train_num_masked_tokens += processed_batch['masked_tokens'].eq(self.model.alphabet.mask_idx).sum()\\n for target_name in self.model.target_names:\\n log_train_num_target_masked_tokens_dict[target_name] += processed_batch['masked_targets'][target_name][:,-1].eq(1.0).sum().item() # Masked targets are encoded by 1.0. Mask column is the very last one\\n else:\\n log_num_sequences_predicted += len(batch['mutant_mutated_seq_pairs'])\\n \\n if training_step % self.args.num_logging_training_steps == 0 and self.args.use_wandb:\\n time_end_step = time.time()\\n delta_time_since_last_log = time_end_step - prior_log_time\\n total_train_time += delta_time_since_last_log\\n prior_log_time = time_end_step\\n train_logs = {\\n \\\"training_step\\\": training_step, \\n \\\"step_time\\\": delta_time_since_last_log / (self.args.num_logging_training_steps)\\n }\\n if self.model.model_type==\\\"ProteinNPT\\\": \\n train_logs[\\\"train_total_loss_per_step\\\"]: log_train_total_loss / self.args.num_logging_training_steps\\n train_logs[\\\"train_reconstruction_loss_per_masked_token\\\"] = log_train_reconstruction_loss / log_train_num_masked_tokens\\n for target_name in self.model.target_names:\\n train_logs[\\\"train_prediction_\\\"+str(target_name)+\\\"_loss_per_masked_token\\\"] = log_train_target_prediction_loss_dict[target_name] / log_train_num_target_masked_tokens_dict[target_name]\\n else:\\n train_logs[\\\"train_total_loss_per_seq\\\"]: log_train_total_loss / log_num_sequences_predicted\\n for target_name in self.model.target_names:\\n train_logs[\\\"train_prediction_\\\"+str(target_name)+\\\"_loss_per_seq\\\"] = log_train_target_prediction_loss_dict[target_name] / log_num_sequences_predicted\\n wandb.log(train_logs)\\n log_train_total_loss = 0\\n log_train_target_prediction_loss_dict = defaultdict(int)\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n log_train_reconstruction_loss = 0\\n log_train_num_masked_tokens = 0\\n log_train_num_target_masked_tokens_dict = defaultdict(int)\\n else:\\n log_num_sequences_predicted = 0 \\n \\n if self.args.save_model_checkpoint and (training_step % self.args.num_saving_training_steps) == 0:\\n if not os.path.exists(self.args.model_location): os.mkdir(self.args.model_location)\\n if not os.path.exists(self.args.model_location + os.sep + 'checkpoint-'+str(training_step)): os.mkdir(self.args.model_location + os.sep + 'checkpoint-'+str(training_step))\\n torch.save({\\n 'training_step': training_step,\\n 'args': self.args,\\n 'state_dict': self.model.state_dict(),\\n 'optimizer' : optimizer.state_dict()\\n }, \\n self.args.model_location + os.sep + 'checkpoint-'+str(training_step) + os.sep + 'checkpoint.t7'\\n )\\n \\n if training_step % self.args.num_eval_steps == 0 and self.args.use_validation_set:\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n eval_results = self.eval(\\n test_data=self.val_data,\\n train_data=self.train_data,\\n reconstruction_loss_weight=0.0,\\n output_all_predictions=True\\n )\\n else:\\n eval_results = self.eval(\\n test_data=self.val_data, \\n output_all_predictions=True\\n )\\n eval_logs = {\\\"Training step\\\": training_step} \\n if self.model.model_type==\\\"ProteinNPT\\\":\\n normalization = 0\\n for target_name in self.model.target_names: normalization += eval_results['eval_num_masked_targets'][target_name]\\n else:\\n normalization = eval_results['eval_num_predicted_targets']\\n eval_logs['Eval total loss per seq.']: eval_results['eval_total_loss'] / normalization\\n average_spearman_across_targets = 0 #If early stopping based on validation spearman and multiple targets, we check that avg spearman is not decreasing for a certain # of times in a row\\n for target_name in self.model.target_names:\\n if self.model.model_type==\\\"ProteinNPT\\\": normalization = eval_results['eval_num_masked_targets'][target_name] #Update for PNPT (keeep the same normalization constant otherwise)\\n eval_logs['Eval loss '+str(target_name)+' per seq.'] = eval_results['eval_target_prediction_loss_dict'][target_name] / normalization\\n eval_logs['Eval spearman '+target_name] = spearmanr(eval_results['output_scores']['predictions_'+target_name], eval_results['output_scores']['labels_'+target_name])[0]\\n average_spearman_across_targets += eval_logs['Eval spearman '+target_name]\\n average_spearman_across_targets /= len(self.model.target_names)\\n print(\\\" | \\\".join([key + \\\": \\\"+str(round(eval_logs[key],5)) for key in eval_logs.keys()]))\\n if self.args.use_wandb: wandb.log(eval_logs)\\n # Early stopping\\n all_spearmans_eval_during_training.append(average_spearman_across_targets)\\n if average_spearman_across_targets > max_average_spearman_across_targets: max_average_spearman_across_targets = average_spearman_across_targets\\n if (training_step >= 1000) and (self.args.early_stopping_patience is not None) and (np.array(all_spearmans_eval_during_training)[-self.args.early_stopping_patience:].max() < max_average_spearman_across_targets):\\n print(\\\"Early stopping. Training step: {}. Total eval loss: {}. Avg spearman: {}\\\".format(training_step, eval_results['eval_total_loss'], average_spearman_across_targets))\\n break\\n self.model.train() #Move back the model to train mode after eval loop\\n trainer_final_status = {\\n 'total_training_steps': training_step,\\n 'total_train_time': total_train_time,\\n 'total_training_epochs': num_epochs\\n }\\n return trainer_final_status\\n\\n def eval(self, test_data, output_all_predictions=False, need_head_weights=False, train_data = None, reconstruction_loss_weight=0.5, selected_indices_seed=0):\\n \\\"\\\"\\\"\\n total_eval_target_prediction_loss is the sum of all target prediction losses across all targets\\n total_eval_target_prediction_loss contains the breakdown by target\\n num_predicted_targets has the number of predicted items\\n output_scores is a dict with sequences, predictions and labels\\n \\\"\\\"\\\"\\n self.model.eval()\\n self.model.cuda()\\n self.model.set_device()\\n with torch.no_grad():\\n eval_loader = torch.utils.data.DataLoader(\\n dataset=test_data, \\n batch_size=self.args.eval_num_sequences_to_score_per_batch_per_gpu, \\n shuffle=False,\\n num_workers=self.args.num_data_loaders_workers, \\n pin_memory=True,\\n collate_fn=collate_fn_protein_npt\\n )\\n eval_iterator = iter(eval_loader)\\n \\n eval_total_loss = 0\\n if self.model.model_type==\\\"ProteinNPT\\\": \\n eval_reconstruction_loss = 0\\n eval_num_masked_tokens = 0\\n eval_num_masked_targets = defaultdict(int)\\n else:\\n num_predicted_targets = 0\\n eval_target_prediction_loss_dict = defaultdict(int)\\n output_scores = defaultdict(list) if output_all_predictions else None\\n\\n if need_head_weights:\\n col_attentions=[]\\n row_attentions=[]\\n\\n for batch in tqdm.tqdm(eval_iterator):\\n if output_all_predictions: \\n output_scores['mutated_sequence'] += list(zip(*batch['mutant_mutated_seq_pairs']))[1]\\n output_scores['mutant'] += list(zip(*batch['mutant_mutated_seq_pairs']))[0]\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n processed_batch = proteinnpt.data_processing.process_batch(\\n batch = batch,\\n model = self.model,\\n alphabet = self.model.alphabet, \\n args = self.args, \\n MSA_sequences = self.MSA_sequences, \\n MSA_weights = self.MSA_weights,\\n MSA_start_position = self.MSA_start_position, \\n MSA_end_position = self.MSA_end_position,\\n target_processing = self.target_processing,\\n training_sequences = train_data,\\n proba_target_mask = 1.0, \\n proba_aa_mask = 0.0,\\n eval_mode = True,\\n device=self.model.device,\\n selected_indices_seed=selected_indices_seed,\\n indel_mode=self.args.indel_mode\\n )\\n else:\\n processed_batch = baselines.data_processing.process_batch(\\n batch = batch,\\n model = self.model,\\n alphabet = self.model.alphabet, \\n args = self.args, \\n MSA_sequences = self.MSA_sequences, \\n MSA_weights = self.MSA_weights,\\n MSA_start_position = self.MSA_start_position, \\n MSA_end_position = self.MSA_end_position,\\n device=self.model.device,\\n eval_mode=True,\\n indel_mode=self.args.indel_mode\\n )\\n if self.args.augmentation==\\\"zero_shot_fitness_predictions_covariate\\\":\\n zero_shot_fitness_predictions = processed_batch['target_labels']['zero_shot_fitness_predictions'].view(-1,1)\\n del processed_batch['target_labels']['zero_shot_fitness_predictions']\\n else:\\n zero_shot_fitness_predictions = None\\n \\n if self.model.model_type==\\\"ProteinNPT\\\":\\n output = self.model(\\n tokens=processed_batch['masked_tokens'],\\n targets=processed_batch['masked_targets'],\\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\\n sequence_embeddings=processed_batch['sequence_embeddings'],\\n need_head_weights=need_head_weights\\n )\\n batch_loss, batch_reconstruction_loss, batch_target_prediction_loss_dict = self.model.protein_npt_loss(\\n token_predictions_logits=output['logits_protein_sequence'], \\n token_labels=processed_batch['token_labels'], \\n target_predictions=output['target_predictions'], \\n target_labels=processed_batch['target_labels'], \\n MLM_reconstruction_loss_weight=reconstruction_loss_weight, \\n label_smoothing=self.args.label_smoothing\\n )\\n if batch_loss.item() > 10.0:\\n print(\\\"High eval loss detected: {}\\\".format(batch_loss.item()))\\n else:\\n output = self.model(\\n tokens=processed_batch['input_tokens'],\\n zero_shot_fitness_predictions=zero_shot_fitness_predictions,\\n sequence_embeddings=processed_batch['sequence_embeddings']\\n )\\n batch_loss, batch_target_prediction_loss_dict = self.model.prediction_loss(\\n target_predictions=output[\\\"target_predictions\\\"], \\n target_labels=processed_batch['target_labels'],\\n label_smoothing=self.args.label_smoothing\\n )\\n \\n eval_total_loss += batch_loss.item()\\n for target_name in self.model.target_names:\\n eval_target_prediction_loss_dict[target_name] += batch_target_prediction_loss_dict[target_name].item()\\n if self.model.model_type==\\\"ProteinNPT\\\":\\n eval_reconstruction_loss += batch_reconstruction_loss.item()\\n eval_num_masked_tokens += processed_batch['masked_tokens'].eq(self.model.alphabet.mask_idx).sum().item()\\n for target_name in self.model.target_names:\\n eval_num_masked_targets[target_name] += processed_batch['masked_targets'][target_name][:,-1].eq(1.0).sum().item()\\n else:\\n num_predicted_targets += len(batch['mutant_mutated_seq_pairs'])\\n if output_all_predictions:\\n num_of_mutated_seqs_to_score = processed_batch['num_of_mutated_seqs_to_score'] if self.model.model_type==\\\"ProteinNPT\\\" else len(processed_batch['mutant_mutated_seq_pairs'])\\n for target_name in self.model.target_names:\\n output_scores['predictions_'+target_name] += list(output[\\\"target_predictions\\\"][target_name][:num_of_mutated_seqs_to_score].cpu().numpy())\\n output_scores['labels_'+target_name] += list(processed_batch['target_labels'][target_name][:num_of_mutated_seqs_to_score].cpu().numpy())\\n if need_head_weights:\\n col_attentions.append(output[\\\"col_attentions\\\"])\\n row_attentions.append(output[\\\"row_attentions\\\"])\\n\\n output_scores = pd.DataFrame.from_dict(output_scores)\\n output_scores_numeric_cols = [col_name for col_name in output_scores.columns if col_name not in ['mutant','mutated_sequence']]\\n output_scores = output_scores.groupby(['mutant'])[output_scores_numeric_cols].mean().reset_index() \\n mutated_seqs_dict = {}\\n mutant_mutated_seqs = list(zip(*test_data['mutant_mutated_seq_pairs']))\\n mutated_seqs_dict['mutant'] = mutant_mutated_seqs[0]\\n mutated_seqs_dict['mutated_sequence'] = mutant_mutated_seqs[1]\\n mutated_seqs_df = pd.DataFrame.from_dict(mutated_seqs_dict)\\n output_scores = pd.merge(output_scores, mutated_seqs_df, on='mutant', how='left')\\n \\n\\n eval_results = {\\n 'eval_total_loss':eval_total_loss,\\n 'eval_target_prediction_loss_dict':eval_target_prediction_loss_dict,\\n 'output_scores': output_scores\\n }\\n if need_head_weights:\\n print(\\\"dimension of first attention column {}\\\".format(col_attentions[0].shape))\\n eval_results['col_attentions'] = torch.stack(col_attentions, dim=0).cpu().numpy()\\n eval_results['row_attentions'] = torch.stack(row_attentions, dim=0).cpu().numpy()\\n \\n if self.model.model_type==\\\"ProteinNPT\\\":\\n eval_results['eval_reconstruction_loss']=eval_reconstruction_loss\\n eval_results['eval_num_masked_tokens']=eval_num_masked_tokens\\n eval_results['eval_num_masked_targets']=eval_num_masked_targets\\n else:\\n eval_results['eval_num_predicted_targets']=num_predicted_targets\\n return eval_results\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import os,gc\nimport json\nimport argparse\nimport random\nimport numpy as np\nimport pandas as pd\nimport wandb\nimport torch\nimport proteinnpt,baselines,utils\nfrom collections import defaultdict\nfrom proteinnpt.model import ProteinNPTModel\nfrom baselines.model import AugmentedPropertyPredictor\nfrom utils.esm.data import Alphabet\nfrom utils.tranception.model_pytorch import get_tranception_tokenizer\nfrom utils.data_utils import get_train_val_test_data, standardize, pnpt_count_non_nan, pnpt_spearmanr\nfrom utils.msa_utils import process_MSA\nfrom utils.model_utils import Trainer"},"token_num":{"kind":"number","value":21137,"string":"21,137"},"cropped_code":{"kind":"string","value":" if args.model_type==\"ProteinNPT\": normalization = test_eval_results['eval_num_masked_targets'][target_name]\n test_logs['Test loss '+str(target_name)+' per seq.'] = test_eval_results['eval_target_prediction_loss_dict'][target_name] / normalization\n with open(logs_folder+os.sep+\"test_performance_by_fold_\"+args.model_name_suffix+\".csv\", \"a\") as perf_tracker:\n if os.path.getsize(logs_folder+os.sep+\"test_performance_by_fold_\"+args.model_name_suffix+\".csv\") == 0: \n header=\"fold_index,model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss\"\n for target_name in target_names: header += (\",loss_\" + target_name + \",Spearman_\" + target_name + \",num_obs_Spearman_\" + target_name)\n perf_tracker.write(header+\"\\n\")\n perf = \",\".join([str(x) for x in perf_list]) + \",\" + str(round(test_logs['Test total loss per seq.'],5)) \n for target_name in target_names: perf += (\",\" + str(round(test_logs['Test loss '+str(target_name)+' per seq.'],5)) +\",\"+str(spearmans[target_name])+\",\"+str(num_obs_spearmans[target_name]))\n perf_tracker.write(perf+\"\\n\")\n return test_logs, spearmans\n\ndef log_performance_all_folds(args,target_names,all_test_predictions_across_folds,spearmans_across_folds,perf_list,logs_folder=None):\n if not os.path.exists(args.output_scores_location + os.sep + 'all_aggregated_predictions'): os.mkdir(args.output_scores_location + os.sep + 'all_aggregated_predictions')\n all_test_predictions_across_folds = pd.DataFrame.from_dict(all_test_predictions_across_folds)\n all_test_predictions_across_folds.to_csv(args.output_scores_location + os.sep + 'all_aggregated_predictions' + os.sep + model_name_prefix + \".csv\", index=False)\n if logs_folder is None:\n dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n logs_folder = dir_path+os.sep+'output'\n if not os.path.exists(logs_folder): os.mkdir(logs_folder)\n with open(logs_folder+os.sep+\"test_performance_overall_\"+perf_list[2]+\".csv\", \"a\") as overall_perf:\n if os.path.getsize(logs_folder+os.sep+\"test_performance_overall_\"+perf_list[2]+\".csv\") == 0: \n header = \"model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss\"\n for target_name in target_names: header += (\",loss_\" + target_name + \",Spearman_\" + target_name + \",Std_dev_Spearman_\" + target_name + \",num_obs_Spearman_\" + target_name + \",standardized_loss_\" + target_name + \",standardized_Spearman_\" + target_name)\n overall_perf.write(header+\"\\n\")\n perf = \",\".join([str(x) for x in perf_list[1:]]) #Remove fold_index from perf_list\n for target_name in target_names:\n missing_mask = np.isnan(all_test_predictions_across_folds['labels_'+target_name]) | np.equal(all_test_predictions_across_folds['labels_'+target_name],-100)\n MSE = ((all_test_predictions_across_folds['predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()\n spearman = pnpt_spearmanr(all_test_predictions_across_folds['predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])\n num_obs_spearman = pnpt_count_non_nan(all_test_predictions_across_folds['labels_'+target_name])\n MSE_standardized = ((all_test_predictions_across_folds['fold_standardized_predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()\n spearman_standardized = pnpt_spearmanr(all_test_predictions_across_folds['fold_standardized_predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])\n spearman_std_dev = np.array(spearmans_across_folds[target_name]).std()\n perf += (\",\" + str(MSE) +\",\"+str(spearman) + \",\"+ str(spearman_std_dev) + \",\" + str(num_obs_spearman) + \",\" + str(MSE_standardized) +\",\"+str(spearman_standardized))\n overall_perf.write(perf+\"\\n\")\n\ndef main(args):\n # Set random seeds\n torch.manual_seed(args.seed)\n np.random.seed(args.seed)\n random.seed(args.seed)\n \n # target_names are the true targets we want to predict. target_names_input also includes auxiliary labels (as used in ProteinNPT)\n target_names = [x for x in args.target_config.keys() if args.target_config[x][\"in_NPT_loss\"]]\n target_names_input = args.target_config.keys()\n num_targets = len(target_names)\n num_targets_input = len(target_names_input)\n print(\"We want to predict {} target(s): {}\".format(num_targets, ' and '.join(target_names)))\n if num_targets_input > num_targets: print(\"We leverage {} target(s) and auxiliary labels: {}\".format(num_targets_input, ' and '.join(target_names_input)))\n\n assay_reference_file = pd.read_csv(args.assay_reference_file_location)\n assay_id=assay_reference_file[\"DMS_id\"][args.assay_index]\n args.seq_len = int(assay_reference_file[\"seq_len\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n args.MSA_seq_len = int(assay_reference_file[\"MSA_len\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n print(\"Training model for assay: {}, where the test_fold index is: {}\".format(assay_id, args.test_fold_index))\n args.save_model_checkpoint = not args.do_not_save_model_checkpoint\n args.frozen_embedding_parameters = not args.fine_tune_model_embedding_parameters\n if args.model_type==\"MSA_Transformer_pred\": assert args.num_MSA_sequences_per_training_instance==args.num_MSA_sequences_per_eval_instance, \"MSA_Transformer_pred only supports same size of MSA for train and eval\"\n \n effective_batch_size = args.gradient_accumulation * args.training_num_assay_sequences_per_batch_per_gpu\n print(\"Effective batch size is {}\".format(effective_batch_size))\n\n model_hypers = [args.aa_embeddings,args.target_prediction_model,args.target_prediction_head,args.augmentation,args.frozen_embedding_parameters,args.dropout,args.weight_decay, \\\n args.early_stopping_patience, args.use_validation_set, args.training_num_assay_sequences_per_batch_per_gpu, args.eval_num_sequences_to_score_per_batch_per_gpu, args.eval_num_training_sequences_per_batch_per_gpu, \\\n args.eval_training_sequences_sampling_method, args.num_MSA_sequences_per_training_instance, args.embed_dim, args.ffn_embed_dim, args.attention_heads, args.conv_kernel_size, args.num_protein_npt_layers]\n model_hypers_str = ','.join([str(x) for x in model_hypers])\n model_name_prefix = '_'.join([str(x) for x in [args.model_type,assay_id,\"_\".join(target_names_input),args.fold_variable_name,'embed_'+args.aa_embeddings,'head_'+str(args.target_prediction_model),'aug_'+str(args.augmentation_short), \\\n 'froz_'+str(args.frozen_embedding_parameters),'drop_'+str(args.dropout),'val_'+str(args.use_validation_set),args.model_name_suffix]])\n model_name = model_name_prefix + \"_fold-\" + str(args.test_fold_index)\n if not os.path.exists(args.model_location+os.sep+model_name): os.mkdir(args.model_location+os.sep+model_name)\n with open(args.model_location+os.sep+model_name+os.sep+'training_arguments', 'w') as f:\n json.dump(args.__dict__, f, indent=2)\n print(\"Model name: \"+model_name)\n assay_file_name = assay_reference_file[\"DMS_filename\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0] # File name of main assay used during training (if single property, this is also the only assay). Retrieved embeddings are always for this assay.\n args.sequence_embeddings_location = args.sequence_embeddings_folder + os.sep + assay_file_name.split(\".csv\")[0] + '.h5' if args.sequence_embeddings_folder else None\n print(\"Sequence embeddings: {}\".format(args.sequence_embeddings_location))\n \n if args.use_wandb: wandb.login() \n \n # Create & initiate model \n alphabet = get_tranception_tokenizer() if args.aa_embeddings==\"Tranception\" else Alphabet.from_architecture(\"msa_transformer\")\n if args.model_type==\"ProteinNPT\":\n model = ProteinNPTModel(args, alphabet)\n elif args.model_type in [\"MSA_Transformer_pred\", \"ESM1v_pred\", \"Tranception_pred\", \"TranceptEVE_pred\", \"Linear_Embedding_pred\", \"DeepSequence_pred\"]:\n model = AugmentedPropertyPredictor(args, alphabet)\n if args.frozen_embedding_parameters and args.aa_embeddings in [\"MSA_Transformer\", \"ESM1v\", \"Tranception\"]:\n for para in model.aa_embedding.parameters():\n para.requires_grad = False\n\n # List of assays involved in training\n if num_targets==1:\n # Single property prediction\n assay_file_names={\n target_names[0]: assay_file_name\n }\n if \"zero_shot_fitness_predictions\" in target_names_input: assay_file_names[\"zero_shot_fitness_predictions\"] = assay_file_name\n else:\n # Multiple properties prediction\n assay_file_names={}\n for target in target_names_input:\n if target==\"zero_shot_fitness_predictions\":\n assay_file_names[target] = assay_file_name # The name of the zero-shot prediction file matches that of the main assay\n else:\n assay_file_names[target] = assay_reference_file[target][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n \n # Load training, val and test data\n UniProt_id = assay_reference_file[\"UniProt_ID\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n MSA_filename = assay_reference_file[\"MSA_filename\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n MSA_weights_filename = assay_reference_file[\"weight_file_name\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n MSA_start_position = int(assay_reference_file[\"MSA_start\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n MSA_end_position = int(assay_reference_file[\"MSA_end\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n train_data, val_data, test_data, target_processing = get_train_val_test_data(args = args, assay_file_names = assay_file_names)\n MSA_sequences, MSA_weights = process_MSA(args, MSA_filename, MSA_weights_filename) if args.aa_embeddings==\"MSA_Transformer\" else (None, None)\n \n if args.use_wandb: \n combined_dict = {**vars(args), \"parameter_count\": sum(p.numel() for p in model.parameters()), \"world_size\": world_size, \"assay_id\": assay_id, \"UniProt_id\": UniProt_id}\n wandb.init(project=os.getenv(\"WANDB_PROJECT\"), config=combined_dict, name=model_name, dir=args.wandb_location, save_code=True)\n \n # Define trainer\n"},"all_code":{"kind":"string","value":"\n\ndef setup_config_and_paths(args):\n # All parameters that are not defined by end user are fetched from the config file\n if args.model_config_location is not None:\n args.main_config=json.load(open(args.model_config_location))\n for key in args.main_config:\n if args.__dict__[key] is None:\n args.__dict__[key] = args.main_config[key]\n \n # File paths config\n for local_path in ['embedding_model_location','MSA_data_folder','MSA_weight_data_folder','path_to_hhfilter']:\n if getattr(args, local_path): setattr(args, local_path, args.data_location + os.sep + getattr(args, local_path))\n if not os.path.exists(args.data_location + os.sep + 'model_predictions'): os.mkdir(args.data_location + os.sep + 'model_predictions')\n if not os.path.exists(args.data_location + os.sep + 'checkpoint'): os.mkdir(args.data_location + os.sep + 'checkpoint')\n args.output_scores_location = args.data_location + os.sep + 'model_predictions' + os.sep + args.model_name_suffix\n if not os.path.exists(args.output_scores_location): os.mkdir(args.output_scores_location)\n args.model_location = args.data_location + os.sep + 'checkpoint' + os.sep + args.model_name_suffix\n if not os.path.exists(args.model_location): os.mkdir(args.model_location)\n \n # Target config\n args.target_config=json.load(open(args.target_config_location))\n zero_shot_predictions_mapping={\n \"MSA_Transformer_pred\": \"MSA_Transformer_ensemble\",\n \"ESM1v_pred\": \"ESM1v_ensemble\",\n \"TranceptEVE_pred\": \"TranceptEVE_L\",\n \"Tranception_pred\": \"Tranception_L\",\n \"DeepSequence_pred\": \"DeepSequence_ensemble\"\n }\n if args.model_type==\"ProteinNPT\": zero_shot_predictions_mapping[\"ProteinNPT\"]=zero_shot_predictions_mapping[args.aa_embeddings+\"_pred\"]\n if args.augmentation==\"zero_shot_fitness_predictions_auxiliary_labels\": # Add auxiliary label to target_config\n assert args.zero_shot_fitness_predictions_location is not None, \"Location of zero-shot fitness predictions to use as auxiliary labels not properly referenced\"\n print(\"Using zero-shot fitness predictions as auxiliary labels\")\n args.target_config[\"zero_shot_fitness_predictions\"] = {\n \"type\": \"continuous\",\n \"dim\": 1,\n \"var_name\": zero_shot_predictions_mapping[args.model_type], #Select the relevant model for zero-shot fitness predictions\n \"location\": args.zero_shot_fitness_predictions_location,\n \"in_NPT_loss\": False,\n \"main_target\": False\n }\n args.augmentation_short=\"auxiliary\"\n elif args.augmentation==\"zero_shot_fitness_predictions_covariate\": # Will use zero-shot fitness predictions as an additional model covariate\n assert args.zero_shot_fitness_predictions_location is not None, \"Location of zero-shot fitness predictions to use as model covariate not properly referenced\"\n print(\"Using zero-shot fitness predictions as covariate\")\n args.augmentation_short=\"covariate\"\n args.zero_shot_fitness_predictions_var_name = zero_shot_predictions_mapping[args.model_type]\n else:\n args.augmentation_short=\"none\"\n \n for target_index,target in enumerate(args.target_config):\n if \"location\" not in args.target_config[target].keys(): # Note: the case of zero-shot fitness predictions is already handled above if present\n if args.assay_location is not None: # We passed at least one path for the assay location\n num_targets = [x for x in args.target_config.keys() if args.target_config[x][\"in_NPT_loss\"]]\n if len(args.assay_location) > 1:\n assert len(args.assay_location)==num_targets, \"Trying to predict {} targets, but only referencing {} distinct paths for them.\".format(num_targets,len(args.assay_location))\n args.target_config[target][\"location\"] = args.assay_location[target_index]\n print(\"Location used for target {} if {}\".format(target,args.assay_location[target_index]))\n else:\n args.target_config[target][\"location\"] = args.assay_location[0]\n print(\"Location used for target {} if {}\".format(target,args.assay_location[0]))\n else:\n print(\"Assay location not provided. Defaulting to location for single substitutions fitness assays: {}\".format(args.data_location + os.sep + 'data/fitness/substitutions_singles'))\n args.target_config[target][\"location\"] = args.data_location + os.sep + 'data/fitness/substitutions_singles'\n \n return args\n\ndef log_performance_fold(args,target_names,test_eval_results,trainer_final_status,perf_list,logs_folder=None):\n test_logs = {'total_training_steps': trainer_final_status['total_training_steps'], 'total_training_epochs': trainer_final_status['total_training_epochs'], 'total_train_time': trainer_final_status['total_train_time']}\n if logs_folder is None:\n dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n logs_folder = dir_path+os.sep+'output'\n if not os.path.exists(logs_folder): os.mkdir(logs_folder)\n if args.model_type==\"ProteinNPT\":\n normalization = 0\n for target_name in target_names: normalization += test_eval_results['eval_num_masked_targets'][target_name]\n else:\n normalization = test_eval_results['eval_num_predicted_targets']\n test_logs['Test total loss per seq.'] = test_eval_results['eval_total_loss'] / normalization\n spearmans = {target_name: pnpt_spearmanr(test_eval_results['output_scores']['predictions_'+target_name], test_eval_results['output_scores']['labels_'+target_name]) for target_name in target_names}\n num_obs_spearmans = {target_name: pnpt_count_non_nan(test_eval_results['output_scores']['labels_'+target_name]) for target_name in target_names}\n for target_name in target_names:\n print(\"Spearman {} target: {}\".format(target_name,spearmans[target_name]))\n test_logs['Test Spearman '+target_name] = spearmans[target_name]\n if args.model_type==\"ProteinNPT\": normalization = test_eval_results['eval_num_masked_targets'][target_name]\n test_logs['Test loss '+str(target_name)+' per seq.'] = test_eval_results['eval_target_prediction_loss_dict'][target_name] / normalization\n with open(logs_folder+os.sep+\"test_performance_by_fold_\"+args.model_name_suffix+\".csv\", \"a\") as perf_tracker:\n if os.path.getsize(logs_folder+os.sep+\"test_performance_by_fold_\"+args.model_name_suffix+\".csv\") == 0: \n header=\"fold_index,model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss\"\n for target_name in target_names: header += (\",loss_\" + target_name + \",Spearman_\" + target_name + \",num_obs_Spearman_\" + target_name)\n perf_tracker.write(header+\"\\n\")\n perf = \",\".join([str(x) for x in perf_list]) + \",\" + str(round(test_logs['Test total loss per seq.'],5)) \n for target_name in target_names: perf += (\",\" + str(round(test_logs['Test loss '+str(target_name)+' per seq.'],5)) +\",\"+str(spearmans[target_name])+\",\"+str(num_obs_spearmans[target_name]))\n perf_tracker.write(perf+\"\\n\")\n return test_logs, spearmans\n\ndef log_performance_all_folds(args,target_names,all_test_predictions_across_folds,spearmans_across_folds,perf_list,logs_folder=None):\n if not os.path.exists(args.output_scores_location + os.sep + 'all_aggregated_predictions'): os.mkdir(args.output_scores_location + os.sep + 'all_aggregated_predictions')\n all_test_predictions_across_folds = pd.DataFrame.from_dict(all_test_predictions_across_folds)\n all_test_predictions_across_folds.to_csv(args.output_scores_location + os.sep + 'all_aggregated_predictions' + os.sep + model_name_prefix + \".csv\", index=False)\n if logs_folder is None:\n dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n logs_folder = dir_path+os.sep+'output'\n if not os.path.exists(logs_folder): os.mkdir(logs_folder)\n with open(logs_folder+os.sep+\"test_performance_overall_\"+perf_list[2]+\".csv\", \"a\") as overall_perf:\n if os.path.getsize(logs_folder+os.sep+\"test_performance_overall_\"+perf_list[2]+\".csv\") == 0: \n header = \"model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss\"\n for target_name in target_names: header += (\",loss_\" + target_name + \",Spearman_\" + target_name + \",Std_dev_Spearman_\" + target_name + \",num_obs_Spearman_\" + target_name + \",standardized_loss_\" + target_name + \",standardized_Spearman_\" + target_name)\n overall_perf.write(header+\"\\n\")\n perf = \",\".join([str(x) for x in perf_list[1:]]) #Remove fold_index from perf_list\n for target_name in target_names:\n missing_mask = np.isnan(all_test_predictions_across_folds['labels_'+target_name]) | np.equal(all_test_predictions_across_folds['labels_'+target_name],-100)\n MSE = ((all_test_predictions_across_folds['predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()\n spearman = pnpt_spearmanr(all_test_predictions_across_folds['predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])\n num_obs_spearman = pnpt_count_non_nan(all_test_predictions_across_folds['labels_'+target_name])\n MSE_standardized = ((all_test_predictions_across_folds['fold_standardized_predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()\n spearman_standardized = pnpt_spearmanr(all_test_predictions_across_folds['fold_standardized_predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])\n spearman_std_dev = np.array(spearmans_across_folds[target_name]).std()\n perf += (\",\" + str(MSE) +\",\"+str(spearman) + \",\"+ str(spearman_std_dev) + \",\" + str(num_obs_spearman) + \",\" + str(MSE_standardized) +\",\"+str(spearman_standardized))\n overall_perf.write(perf+\"\\n\")\n\ndef main(args):\n # Set random seeds\n torch.manual_seed(args.seed)\n np.random.seed(args.seed)\n random.seed(args.seed)\n \n # target_names are the true targets we want to predict. target_names_input also includes auxiliary labels (as used in ProteinNPT)\n target_names = [x for x in args.target_config.keys() if args.target_config[x][\"in_NPT_loss\"]]\n target_names_input = args.target_config.keys()\n num_targets = len(target_names)\n num_targets_input = len(target_names_input)\n print(\"We want to predict {} target(s): {}\".format(num_targets, ' and '.join(target_names)))\n if num_targets_input > num_targets: print(\"We leverage {} target(s) and auxiliary labels: {}\".format(num_targets_input, ' and '.join(target_names_input)))\n\n assay_reference_file = pd.read_csv(args.assay_reference_file_location)\n assay_id=assay_reference_file[\"DMS_id\"][args.assay_index]\n args.seq_len = int(assay_reference_file[\"seq_len\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n args.MSA_seq_len = int(assay_reference_file[\"MSA_len\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n print(\"Training model for assay: {}, where the test_fold index is: {}\".format(assay_id, args.test_fold_index))\n args.save_model_checkpoint = not args.do_not_save_model_checkpoint\n args.frozen_embedding_parameters = not args.fine_tune_model_embedding_parameters\n if args.model_type==\"MSA_Transformer_pred\": assert args.num_MSA_sequences_per_training_instance==args.num_MSA_sequences_per_eval_instance, \"MSA_Transformer_pred only supports same size of MSA for train and eval\"\n \n effective_batch_size = args.gradient_accumulation * args.training_num_assay_sequences_per_batch_per_gpu\n print(\"Effective batch size is {}\".format(effective_batch_size))\n\n model_hypers = [args.aa_embeddings,args.target_prediction_model,args.target_prediction_head,args.augmentation,args.frozen_embedding_parameters,args.dropout,args.weight_decay, \\\n args.early_stopping_patience, args.use_validation_set, args.training_num_assay_sequences_per_batch_per_gpu, args.eval_num_sequences_to_score_per_batch_per_gpu, args.eval_num_training_sequences_per_batch_per_gpu, \\\n args.eval_training_sequences_sampling_method, args.num_MSA_sequences_per_training_instance, args.embed_dim, args.ffn_embed_dim, args.attention_heads, args.conv_kernel_size, args.num_protein_npt_layers]\n model_hypers_str = ','.join([str(x) for x in model_hypers])\n model_name_prefix = '_'.join([str(x) for x in [args.model_type,assay_id,\"_\".join(target_names_input),args.fold_variable_name,'embed_'+args.aa_embeddings,'head_'+str(args.target_prediction_model),'aug_'+str(args.augmentation_short), \\\n 'froz_'+str(args.frozen_embedding_parameters),'drop_'+str(args.dropout),'val_'+str(args.use_validation_set),args.model_name_suffix]])\n model_name = model_name_prefix + \"_fold-\" + str(args.test_fold_index)\n if not os.path.exists(args.model_location+os.sep+model_name): os.mkdir(args.model_location+os.sep+model_name)\n with open(args.model_location+os.sep+model_name+os.sep+'training_arguments', 'w') as f:\n json.dump(args.__dict__, f, indent=2)\n print(\"Model name: \"+model_name)\n assay_file_name = assay_reference_file[\"DMS_filename\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0] # File name of main assay used during training (if single property, this is also the only assay). Retrieved embeddings are always for this assay.\n args.sequence_embeddings_location = args.sequence_embeddings_folder + os.sep + assay_file_name.split(\".csv\")[0] + '.h5' if args.sequence_embeddings_folder else None\n print(\"Sequence embeddings: {}\".format(args.sequence_embeddings_location))\n \n if args.use_wandb: wandb.login() \n \n # Create & initiate model \n alphabet = get_tranception_tokenizer() if args.aa_embeddings==\"Tranception\" else Alphabet.from_architecture(\"msa_transformer\")\n if args.model_type==\"ProteinNPT\":\n model = ProteinNPTModel(args, alphabet)\n elif args.model_type in [\"MSA_Transformer_pred\", \"ESM1v_pred\", \"Tranception_pred\", \"TranceptEVE_pred\", \"Linear_Embedding_pred\", \"DeepSequence_pred\"]:\n model = AugmentedPropertyPredictor(args, alphabet)\n if args.frozen_embedding_parameters and args.aa_embeddings in [\"MSA_Transformer\", \"ESM1v\", \"Tranception\"]:\n for para in model.aa_embedding.parameters():\n para.requires_grad = False\n\n # List of assays involved in training\n if num_targets==1:\n # Single property prediction\n assay_file_names={\n target_names[0]: assay_file_name\n }\n if \"zero_shot_fitness_predictions\" in target_names_input: assay_file_names[\"zero_shot_fitness_predictions\"] = assay_file_name\n else:\n # Multiple properties prediction\n assay_file_names={}\n for target in target_names_input:\n if target==\"zero_shot_fitness_predictions\":\n assay_file_names[target] = assay_file_name # The name of the zero-shot prediction file matches that of the main assay\n else:\n assay_file_names[target] = assay_reference_file[target][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n \n # Load training, val and test data\n UniProt_id = assay_reference_file[\"UniProt_ID\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n MSA_filename = assay_reference_file[\"MSA_filename\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n MSA_weights_filename = assay_reference_file[\"weight_file_name\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0]\n MSA_start_position = int(assay_reference_file[\"MSA_start\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n MSA_end_position = int(assay_reference_file[\"MSA_end\"][assay_reference_file[\"DMS_id\"]==assay_id].values[0])\n train_data, val_data, test_data, target_processing = get_train_val_test_data(args = args, assay_file_names = assay_file_names)\n MSA_sequences, MSA_weights = process_MSA(args, MSA_filename, MSA_weights_filename) if args.aa_embeddings==\"MSA_Transformer\" else (None, None)\n \n if args.use_wandb: \n combined_dict = {**vars(args), \"parameter_count\": sum(p.numel() for p in model.parameters()), \"world_size\": world_size, \"assay_id\": assay_id, \"UniProt_id\": UniProt_id}\n wandb.init(project=os.getenv(\"WANDB_PROJECT\"), config=combined_dict, name=model_name, dir=args.wandb_location, save_code=True)\n \n # Define trainer"},"next_line":{"kind":"string","value":" trainer = Trainer("},"gold_snippet_index":{"kind":"number","value":9,"string":"9"},"created_at":{"kind":"string","value":"2023-10-28 11:41:05+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5690,"cells":{"repo_name":{"kind":"string","value":"CVHub520/yolov5_obb"},"file_path":{"kind":"string","value":"detect.py"},"context":{"kind":"list like","value":[{"identifier":"DetectMultiBackend","path":"models/common.py","snippet":"class DetectMultiBackend(nn.Module):\n # YOLOv5 MultiBackend class for python inference on various backends\n def __init__(self, weights='yolov5s.pt', device=None, dnn=False):\n # Usage:\n # PyTorch: weights = *.pt\n # TorchScript: *.torchscript\n # CoreML: *.mlmodel\n # TensorFlow: *_saved_model\n # TensorFlow: *.pb\n # TensorFlow Lite: *.tflite\n # ONNX Runtime: *.onnx\n # OpenCV DNN: *.onnx with dnn=True\n # TensorRT: *.engine\n from models.experimental import attempt_download, attempt_load # scoped to avoid circular import\n\n super().__init__()\n w = str(weights[0] if isinstance(weights, list) else weights)\n suffix = Path(w).suffix.lower()\n suffixes = ['.pt', '.torchscript', '.onnx', '.engine', '.tflite', '.pb', '', '.mlmodel']\n check_suffix(w, suffixes) # check weights have acceptable suffix\n pt, jit, onnx, engine, tflite, pb, saved_model, coreml = (suffix == x for x in suffixes) # backend booleans\n stride, names = 64, [f'class{i}' for i in range(1000)] # assign defaults\n w = attempt_download(w) # download if not local\n\n if jit: # TorchScript\n LOGGER.info(f'Loading {w} for TorchScript inference...')\n extra_files = {'config.txt': ''} # model metadata\n model = torch.jit.load(w, _extra_files=extra_files)\n if extra_files['config.txt']:\n d = json.loads(extra_files['config.txt']) # extra_files dict\n stride, names = int(d['stride']), d['names']\n elif pt: # PyTorch\n model = attempt_load(weights if isinstance(weights, list) else w, map_location=device)\n stride = int(model.stride.max()) # model stride\n names = model.module.names if hasattr(model, 'module') else model.names # get class names\n self.model = model # explicitly assign for to(), cpu(), cuda(), half()\n elif coreml: # CoreML\n LOGGER.info(f'Loading {w} for CoreML inference...')\n import coremltools as ct\n model = ct.models.MLModel(w)\n elif dnn: # ONNX OpenCV DNN\n LOGGER.info(f'Loading {w} for ONNX OpenCV DNN inference...')\n check_requirements(('opencv-python>=4.5.4',))\n net = cv2.dnn.readNetFromONNX(w)\n elif onnx: # ONNX Runtime\n LOGGER.info(f'Loading {w} for ONNX Runtime inference...')\n cuda = torch.cuda.is_available()\n check_requirements(('onnx', 'onnxruntime-gpu' if cuda else 'onnxruntime'))\n import onnxruntime\n providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if cuda else ['CPUExecutionProvider']\n session = onnxruntime.InferenceSession(w, providers=providers)\n elif engine: # TensorRT\n LOGGER.info(f'Loading {w} for TensorRT inference...')\n import tensorrt as trt # https://developer.nvidia.com/nvidia-tensorrt-download\n check_version(trt.__version__, '8.0.0', verbose=True) # version requirement\n Binding = namedtuple('Binding', ('name', 'dtype', 'shape', 'data', 'ptr'))\n logger = trt.Logger(trt.Logger.INFO)\n with open(w, 'rb') as f, trt.Runtime(logger) as runtime:\n model = runtime.deserialize_cuda_engine(f.read())\n bindings = OrderedDict()\n for index in range(model.num_bindings):\n name = model.get_binding_name(index)\n dtype = trt.nptype(model.get_binding_dtype(index))\n shape = tuple(model.get_binding_shape(index))\n data = torch.from_numpy(np.empty(shape, dtype=np.dtype(dtype))).to(device)\n bindings[name] = Binding(name, dtype, shape, data, int(data.data_ptr()))\n binding_addrs = OrderedDict((n, d.ptr) for n, d in bindings.items())\n context = model.create_execution_context()\n batch_size = bindings['images'].shape[0]\n else: # TensorFlow model (TFLite, pb, saved_model)\n if pb: # https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt\n LOGGER.info(f'Loading {w} for TensorFlow *.pb inference...')\n import tensorflow as tf\n\n def wrap_frozen_graph(gd, inputs, outputs):\n x = tf.compat.v1.wrap_function(lambda: tf.compat.v1.import_graph_def(gd, name=\"\"), []) # wrapped\n return x.prune(tf.nest.map_structure(x.graph.as_graph_element, inputs),\n tf.nest.map_structure(x.graph.as_graph_element, outputs))\n\n graph_def = tf.Graph().as_graph_def()\n graph_def.ParseFromString(open(w, 'rb').read())\n frozen_func = wrap_frozen_graph(gd=graph_def, inputs=\"x:0\", outputs=\"Identity:0\")\n elif saved_model:\n LOGGER.info(f'Loading {w} for TensorFlow saved_model inference...')\n import tensorflow as tf\n model = tf.keras.models.load_model(w)\n elif tflite: # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python\n if 'edgetpu' in w.lower():\n LOGGER.info(f'Loading {w} for TensorFlow Lite Edge TPU inference...')\n import tflite_runtime.interpreter as tfli\n delegate = {'Linux': 'libedgetpu.so.1', # install https://coral.ai/software/#edgetpu-runtime\n 'Darwin': 'libedgetpu.1.dylib',\n 'Windows': 'edgetpu.dll'}[platform.system()]\n interpreter = tfli.Interpreter(model_path=w, experimental_delegates=[tfli.load_delegate(delegate)])\n else:\n LOGGER.info(f'Loading {w} for TensorFlow Lite inference...')\n import tensorflow as tf\n interpreter = tf.lite.Interpreter(model_path=w) # load TFLite model\n interpreter.allocate_tensors() # allocate\n input_details = interpreter.get_input_details() # inputs\n output_details = interpreter.get_output_details() # outputs\n self.__dict__.update(locals()) # assign all variables to self\n\n def forward(self, im, augment=False, visualize=False, val=False):\n # YOLOv5 MultiBackend inference\n b, ch, h, w = im.shape # batch, channel, height, width\n if self.pt or self.jit: # PyTorch\n y = self.model(im) if self.jit else self.model(im, augment=augment, visualize=visualize)\n return y if val else y[0]\n elif self.coreml: # CoreML\n im = im.permute(0, 2, 3, 1).cpu().numpy() # torch BCHW to numpy BHWC shape(1,320,192,3)\n im = Image.fromarray((im[0] * 255).astype('uint8'))\n # im = im.resize((192, 320), Image.ANTIALIAS)\n y = self.model.predict({'image': im}) # coordinates are xywh normalized\n box = xywh2xyxy(y['coordinates'] * [[w, h, w, h]]) # xyxy pixels\n conf, cls = y['confidence'].max(1), y['confidence'].argmax(1).astype(np.float)\n y = np.concatenate((box, conf.reshape(-1, 1), cls.reshape(-1, 1)), 1)\n elif self.onnx: # ONNX\n im = im.cpu().numpy() # torch to numpy\n if self.dnn: # ONNX OpenCV DNN\n self.net.setInput(im)\n y = self.net.forward()\n else: # ONNX Runtime\n y = self.session.run([self.session.get_outputs()[0].name], {self.session.get_inputs()[0].name: im})[0]\n elif self.engine: # TensorRT\n assert im.shape == self.bindings['images'].shape, (im.shape, self.bindings['images'].shape)\n self.binding_addrs['images'] = int(im.data_ptr())\n self.context.execute_v2(list(self.binding_addrs.values()))\n y = self.bindings['output'].data\n else: # TensorFlow model (TFLite, pb, saved_model)\n im = im.permute(0, 2, 3, 1).cpu().numpy() # torch BCHW to numpy BHWC shape(1,320,192,3)\n if self.pb:\n y = self.frozen_func(x=self.tf.constant(im)).numpy()\n elif self.saved_model:\n y = self.model(im, training=False).numpy()\n elif self.tflite:\n input, output = self.input_details[0], self.output_details[0]\n int8 = input['dtype'] == np.uint8 # is TFLite quantized uint8 model\n if int8:\n scale, zero_point = input['quantization']\n im = (im / scale + zero_point).astype(np.uint8) # de-scale\n self.interpreter.set_tensor(input['index'], im)\n self.interpreter.invoke()\n y = self.interpreter.get_tensor(output['index'])\n if int8:\n scale, zero_point = output['quantization']\n y = (y.astype(np.float32) - zero_point) * scale # re-scale\n y[..., 0] *= w # x\n y[..., 1] *= h # y\n y[..., 2] *= w # w\n y[..., 3] *= h # h\n y = torch.tensor(y) if isinstance(y, np.ndarray) else y\n return (y, []) if val else y\n\n def warmup(self, imgsz=(1, 3, 640, 640), half=False):\n # Warmup model by running inference once\n if self.pt or self.engine or self.onnx: # warmup types\n if isinstance(self.device, torch.device) and self.device.type != 'cpu': # only warmup GPU models\n im = torch.zeros(*imgsz).to(self.device).type(torch.half if half else torch.float) # input image\n self.forward(im) # warmup"},{"identifier":"IMG_FORMATS","path":"utils/datasets.py","snippet":"IMG_FORMATS = ['bmp', 'jpg', 'jpeg', 'png', 'tif', 'tiff', 'dng', 'webp', 'mpo'] # acceptable image suffixes"},{"identifier":"VID_FORMATS","path":"utils/datasets.py","snippet":"VID_FORMATS = ['mov', 'avi', 'mp4', 'mpg', 'mpeg', 'm4v', 'wmv', 'mkv'] # acceptable video suffixes"},{"identifier":"LoadImages","path":"utils/datasets.py","snippet":"class LoadImages:\n # YOLOv5 image/video dataloader, i.e. `python detect.py --source image.jpg/vid.mp4`\n def __init__(self, path, img_size=640, stride=32, auto=True):\n p = str(Path(path).resolve()) # os-agnostic absolute path\n if '*' in p:\n files = sorted(glob.glob(p, recursive=True)) # glob\n elif os.path.isdir(p):\n files = sorted(glob.glob(os.path.join(p, '*.*'))) # dir\n elif os.path.isfile(p):\n files = [p] # files\n else:\n raise Exception(f'ERROR: {p} does not exist')\n\n images = [x for x in files if x.split('.')[-1].lower() in IMG_FORMATS]\n videos = [x for x in files if x.split('.')[-1].lower() in VID_FORMATS]\n ni, nv = len(images), len(videos)\n\n self.img_size = img_size\n self.stride = stride\n self.files = images + videos\n self.nf = ni + nv # number of files\n self.video_flag = [False] * ni + [True] * nv\n self.mode = 'image'\n self.auto = auto\n if any(videos):\n self.new_video(videos[0]) # new video\n else:\n self.cap = None\n assert self.nf > 0, f'No images or videos found in {p}. ' \\\n f'Supported formats are:\\nimages: {IMG_FORMATS}\\nvideos: {VID_FORMATS}'\n\n def __iter__(self):\n self.count = 0\n return self\n\n def __next__(self):\n if self.count == self.nf:\n raise StopIteration\n path = self.files[self.count]\n\n if self.video_flag[self.count]:\n # Read video\n self.mode = 'video'\n ret_val, img0 = self.cap.read()\n while not ret_val:\n self.count += 1\n self.cap.release()\n if self.count == self.nf: # last video\n raise StopIteration\n else:\n path = self.files[self.count]\n self.new_video(path)\n ret_val, img0 = self.cap.read()\n\n self.frame += 1\n s = f'video {self.count + 1}/{self.nf} ({self.frame}/{self.frames}) {path}: '\n\n else:\n # Read image\n self.count += 1\n img0 = cv2.imread(path) # BGR\n assert img0 is not None, f'Image Not Found {path}'\n s = f'image {self.count}/{self.nf} {path}: '\n\n # Padded resize\n img = letterbox(img0, self.img_size, stride=self.stride, auto=self.auto)[0]\n\n # Convert\n img = img.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB\n img = np.ascontiguousarray(img)\n\n return path, img, img0, self.cap, s\n\n def new_video(self, path):\n self.frame = 0\n self.cap = cv2.VideoCapture(path)\n self.frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\n\n def __len__(self):\n return self.nf # number of files"},{"identifier":"LoadStreams","path":"utils/datasets.py","snippet":"class LoadStreams:\n # YOLOv5 streamloader, i.e. `python detect.py --source 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP streams`\n def __init__(self, sources='streams.txt', img_size=640, stride=32, auto=True):\n self.mode = 'stream'\n self.img_size = img_size\n self.stride = stride\n\n if os.path.isfile(sources):\n with open(sources) as f:\n sources = [x.strip() for x in f.read().strip().splitlines() if len(x.strip())]\n else:\n sources = [sources]\n\n n = len(sources)\n self.imgs, self.fps, self.frames, self.threads = [None] * n, [0] * n, [0] * n, [None] * n\n self.sources = [clean_str(x) for x in sources] # clean source names for later\n self.auto = auto\n for i, s in enumerate(sources): # index, source\n # Start thread to read frames from video stream\n st = f'{i + 1}/{n}: {s}... '\n if 'youtube.com/' in s or 'youtu.be/' in s: # if source is YouTube video\n check_requirements(('pafy', 'youtube_dl'))\n import pafy\n s = pafy.new(s).getbest(preftype=\"mp4\").url # YouTube URL\n s = eval(s) if s.isnumeric() else s # i.e. s = '0' local webcam\n cap = cv2.VideoCapture(s)\n assert cap.isOpened(), f'{st}Failed to open {s}'\n w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n self.fps[i] = max(cap.get(cv2.CAP_PROP_FPS) % 100, 0) or 30.0 # 30 FPS fallback\n self.frames[i] = max(int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), 0) or float('inf') # infinite stream fallback\n\n _, self.imgs[i] = cap.read() # guarantee first frame\n self.threads[i] = Thread(target=self.update, args=([i, cap, s]), daemon=True)\n LOGGER.info(f\"{st} Success ({self.frames[i]} frames {w}x{h} at {self.fps[i]:.2f} FPS)\")\n self.threads[i].start()\n LOGGER.info('') # newline\n\n # check for common shapes\n s = np.stack([letterbox(x, self.img_size, stride=self.stride, auto=self.auto)[0].shape for x in self.imgs])\n self.rect = np.unique(s, axis=0).shape[0] == 1 # rect inference if all shapes equal\n if not self.rect:\n LOGGER.warning('WARNING: Stream shapes differ. For optimal performance supply similarly-shaped streams.')\n\n def update(self, i, cap, stream):\n # Read stream `i` frames in daemon thread\n n, f, read = 0, self.frames[i], 1 # frame number, frame array, inference every 'read' frame\n while cap.isOpened() and n < f:\n n += 1\n # _, self.imgs[index] = cap.read()\n cap.grab()\n if n % read == 0:\n success, im = cap.retrieve()\n if success:\n self.imgs[i] = im\n else:\n LOGGER.warning('WARNING: Video stream unresponsive, please check your IP camera connection.')\n self.imgs[i] = np.zeros_like(self.imgs[i])\n cap.open(stream) # re-open stream if signal was lost\n time.sleep(1 / self.fps[i]) # wait time\n\n def __iter__(self):\n self.count = -1\n return self\n\n def __next__(self):\n self.count += 1\n if not all(x.is_alive() for x in self.threads) or cv2.waitKey(1) == ord('q'): # q to quit\n cv2.destroyAllWindows()\n raise StopIteration\n\n # Letterbox\n img0 = self.imgs.copy()\n img = [letterbox(x, self.img_size, stride=self.stride, auto=self.rect and self.auto)[0] for x in img0]\n\n # Stack\n img = np.stack(img, 0)\n\n # Convert\n img = img[..., ::-1].transpose((0, 3, 1, 2)) # BGR to RGB, BHWC to BCHW\n img = np.ascontiguousarray(img)\n\n return self.sources, img, img0, None, ''\n\n def __len__(self):\n return len(self.sources) # 1E12 frames = 32 streams at 30 FPS for 30 years"},{"identifier":"LOGGER","path":"utils/general.py","snippet":"LOGGER = set_logging(__name__) # define globally (used in train.py, val.py, detect.py, etc.)"},{"identifier":"check_file","path":"utils/general.py","snippet":"def check_file(file, suffix=''):\n # Search/download file (if necessary) and return path\n check_suffix(file, suffix) # optional\n file = str(file) # convert to str()\n if Path(file).is_file() or file == '': # exists\n return file\n elif file.startswith(('http:/', 'https:/')): # download\n url = str(Path(file)).replace(':/', '://') # Pathlib turns :// -> :/\n file = Path(urllib.parse.unquote(file).split('?')[0]).name # '%2F' to '/', split https://url.com/file.txt?auth\n if Path(file).is_file():\n print(f'Found {url} locally at {file}') # file already exists\n else:\n print(f'Downloading {url} to {file}...')\n torch.hub.download_url_to_file(url, file)\n assert Path(file).exists() and Path(file).stat().st_size > 0, f'File download failed: {url}' # check\n return file\n else: # search\n files = []\n for d in 'data', 'models', 'utils': # search directories\n files.extend(glob.glob(str(ROOT / d / '**' / file), recursive=True)) # find file\n assert len(files), f'File not found: {file}' # assert file was found\n assert len(files) == 1, f\"Multiple files match '{file}', specify exact path: {files}\" # assert unique\n return files[0] # return file"},{"identifier":"check_img_size","path":"utils/general.py","snippet":"def check_img_size(imgsz, s=32, floor=0):\n print(f\"#305 in utils/general.py - s={s}\")\n # Verify image size is a multiple of stride s in each dimension\n if isinstance(imgsz, int): # integer i.e. img_size=640\n new_size = max(make_divisible(imgsz, int(s)), floor)\n else: # list i.e. img_size=[640, 480]\n new_size = [max(make_divisible(x, int(s)), floor) for x in imgsz]\n if new_size != imgsz:\n print(f'WARNING: --img-size {imgsz} must be multiple of max stride {s}, updating to {new_size}')\n return new_size"},{"identifier":"check_imshow","path":"utils/general.py","snippet":"def check_imshow():\n # Check if environment supports image displays\n try:\n assert not is_docker(), 'cv2.imshow() is disabled in Docker environments'\n assert not is_colab(), 'cv2.imshow() is disabled in Google Colab environments'\n cv2.imshow('test', np.zeros((1, 1, 3)))\n cv2.waitKey(1)\n cv2.destroyAllWindows()\n cv2.waitKey(1)\n return True\n except Exception as e:\n print(f'WARNING: Environment does not support cv2.imshow() or PIL Image.show() image displays\\n{e}')\n return False"},{"identifier":"check_requirements","path":"utils/general.py","snippet":"@try_except\ndef check_requirements(requirements=ROOT / 'requirements.txt', exclude=(), install=True):\n # Check installed dependencies meet requirements (pass *.txt file or list of packages)\n prefix = colorstr('red', 'bold', 'requirements:')\n check_python() # check python version\n if isinstance(requirements, (str, Path)): # requirements.txt file\n file = Path(requirements)\n assert file.exists(), f\"{prefix} {file.resolve()} not found, check failed.\"\n with file.open() as f:\n requirements = [f'{x.name}{x.specifier}' for x in pkg.parse_requirements(f) if x.name not in exclude]\n else: # list or tuple of packages\n requirements = [x for x in requirements if x not in exclude]\n\n n = 0 # number of packages updates\n for r in requirements:\n try:\n pkg.require(r)\n except Exception as e: # DistributionNotFound or VersionConflict if requirements not met\n s = f\"{prefix} {r} not found and is required by YOLOv5\"\n if install:\n print(f\"{s}, attempting auto-update...\")\n try:\n assert check_online(), f\"'pip install {r}' skipped (offline)\"\n print(check_output(f\"pip install '{r}'\", shell=True).decode())\n n += 1\n except Exception as e:\n print(f'{prefix} {e}')\n else:\n print(f'{s}. Please install and rerun your command.')\n\n if n: # if packages updated\n source = file.resolve() if 'file' in locals() else requirements\n s = f\"{prefix} {n} package{'s' * (n > 1)} updated per {source}\\n\" \\\n f\"{prefix} ⚠️ {colorstr('bold', 'Restart runtime or rerun command for updates to take effect')}\\n\"\n print(emojis(s))"},{"identifier":"colorstr","path":"utils/general.py","snippet":"def colorstr(*input):\n # Colors a string https://en.wikipedia.org/wiki/ANSI_escape_code, i.e. colorstr('blue', 'hello world')\n *args, string = input if len(input) > 1 else ('blue', 'bold', input[0]) # color arguments, string\n colors = {'black': '\\033[30m', # basic colors\n 'red': '\\033[31m',\n 'green': '\\033[32m',\n 'yellow': '\\033[33m',\n 'blue': '\\033[34m',\n 'magenta': '\\033[35m',\n 'cyan': '\\033[36m',\n 'white': '\\033[37m',\n 'bright_black': '\\033[90m', # bright colors\n 'bright_red': '\\033[91m',\n 'bright_green': '\\033[92m',\n 'bright_yellow': '\\033[93m',\n 'bright_blue': '\\033[94m',\n 'bright_magenta': '\\033[95m',\n 'bright_cyan': '\\033[96m',\n 'bright_white': '\\033[97m',\n 'end': '\\033[0m', # misc\n 'bold': '\\033[1m',\n 'underline': '\\033[4m'}\n return ''.join(colors[x] for x in args) + f'{string}' + colors['end']"},{"identifier":"increment_path","path":"utils/general.py","snippet":"def increment_path(path, exist_ok=False, sep='', mkdir=False):\n # Increment file or directory path, i.e. runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.\n path = Path(path) # os-agnostic\n if path.exists() and not exist_ok:\n path, suffix = (path.with_suffix(''), path.suffix) if path.is_file() else (path, '')\n dirs = glob.glob(f\"{path}{sep}*\") # similar paths\n matches = [re.search(rf\"%s{sep}(\\d+)\" % path.stem, d) for d in dirs]\n i = [int(m.groups()[0]) for m in matches if m] # indices\n n = max(i) + 1 if i else 2 # increment number\n path = Path(f\"{path}{sep}{n}{suffix}\") # increment path\n if mkdir:\n path.mkdir(parents=True, exist_ok=True) # make directory\n return path"},{"identifier":"non_max_suppression","path":"utils/general.py","snippet":"def non_max_suppression(prediction, conf_thres=0.25, iou_thres=0.45, classes=None, agnostic=False, multi_label=False,\n labels=(), max_det=300):\n \"\"\"Runs Non-Maximum Suppression (NMS) on inference results\n\n Returns:\n list of detections, on (n,6) tensor per image [xyxy, conf, cls]\n \"\"\"\n\n nc = prediction.shape[2] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Checks\n assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0'\n assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0'\n\n # Settings\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\n time_limit = 10.0 # seconds to quit after\n redundant = True # require redundant detections\n multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img)\n merge = False # use merge-NMS\n\n t = time.time()\n output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # Cat apriori labels if autolabelling\n if labels and len(labels[xi]):\n l = labels[xi]\n v = torch.zeros((len(l), nc + 5), device=x.device)\n v[:, :4] = l[:, 1:5] # box\n v[:, 4] = 1.0 # conf\n v[range(len(l)), l[:, 0].long() + 5] = 1.0 # cls\n x = torch.cat((x, v), 0)\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n # Filter by class\n if classes is not None:\n x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\n\n # Apply finite constraint\n # if not torch.isfinite(x).all():\n # x = x[torch.isfinite(x).all(1)]\n\n # Check shape\n n = x.shape[0] # number of boxes\n if not n: # no boxes\n continue\n elif n > max_nms: # excess boxes\n x = x[x[:, 4].argsort(descending=True)[:max_nms]] # sort by confidence\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)\n # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\n iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\n weights = iou * scores[None] # box weights\n x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes\n if redundant:\n i = i[iou.sum(1) > 1] # require redundancy\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n print(f'WARNING: NMS time limit {time_limit}s exceeded')\n break # time limit exceeded\n\n return output"},{"identifier":"non_max_suppression_obb","path":"utils/general.py","snippet":"def non_max_suppression_obb(prediction, conf_thres=0.25, iou_thres=0.45, classes=None, agnostic=False, multi_label=False,\n labels=(), max_det=1500):\n \"\"\"Runs Non-Maximum Suppression (NMS) on inference results_obb\n Args:\n prediction (tensor): (b, n_all_anchors, [cx cy l s obj num_cls theta_cls])\n agnostic (bool): True = NMS will be applied between elements of different categories\n labels : () or\n\n Returns:\n list of detections, len=batch_size, on (n,7) tensor per image [xylsθ, conf, cls] θ ∈ [-pi/2, pi/2)\n \"\"\"\n\n nc = prediction.shape[2] - 5 - 180 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n class_index = nc + 5\n\n # Checks\n assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0'\n assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0'\n\n # Settings\n max_wh = 4096 # min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\n time_limit = 30.0 # seconds to quit after\n # redundant = True # require redundant detections\n multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img)\n\n t = time.time()\n output = [torch.zeros((0, 7), device=prediction.device)] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence, (tensor): (n_conf_thres, [cx cy l s obj num_cls theta_cls])\n\n # Cat apriori labels if autolabelling\n if labels and len(labels[xi]):\n l = labels[xi]\n v = torch.zeros((len(l), nc + 5), device=x.device)\n v[:, :4] = l[:, 1:5] # box\n v[:, 4] = 1.0 # conf\n v[range(len(l)), l[:, 0].long() + 5] = 1.0 # cls\n x = torch.cat((x, v), 0)\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:class_index] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n thete_index, theta_pred = torch.max(x[:, class_index:], 1, keepdim=True) # [n_conf_thres, 1] θ ∈ int[0, 179]\n theta_pred = (theta_pred - 90) / 180 * pi # [n_conf_thres, 1] θ ∈ [-pi/2, pi/2)\n\n # Detections matrix nx7 (xyls, θ, conf, cls) θ ∈ [-pi/2, pi/2)\n if multi_label:\n i, j = (x[:, 5:class_index] > conf_thres).nonzero(as_tuple=False).T # ()\n x = torch.cat((x[i, :4], theta_pred[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:class_index].max(1, keepdim=True)\n x = torch.cat((x[:, :4], theta_pred, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n # Filter by class\n if classes is not None:\n x = x[(x[:, 6:7] == torch.tensor(classes, device=x.device)).any(1)]\n\n # Apply finite constraint\n # if not torch.isfinite(x).all():\n # x = x[torch.isfinite(x).all(1)]\n\n # Check shape\n n = x.shape[0] # number of boxes\n if not n: # no boxes\n continue\n elif n > max_nms: # excess boxes\n x = x[x[:, 5].argsort(descending=True)[:max_nms]] # sort by confidence\n\n # Batched NMS\n c = x[:, 6:7] * (0 if agnostic else max_wh) # classes\n rboxes = x[:, :5].clone() \n rboxes[:, :2] = rboxes[:, :2] + c # rboxes (offset by class)\n scores = x[:, 5] # scores\n _, i = obb_nms(rboxes, scores, iou_thres)\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n print(f'WARNING: NMS time limit {time_limit}s exceeded')\n break # time limit exceeded\n\n return output"},{"identifier":"print_args","path":"utils/general.py","snippet":"def print_args(name, opt):\n # Print argparser arguments\n LOGGER.info(colorstr(f'{name}: ') + ', '.join(f'{k}={v}' for k, v in vars(opt).items()))"},{"identifier":"scale_coords","path":"utils/general.py","snippet":"def scale_coords(img1_shape, coords, img0_shape, ratio_pad=None):\n # Rescale coords (xyxy) from img1_shape to img0_shape\n if ratio_pad is None: # calculate from img0_shape\n gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1]) # gain = old / new\n pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2 # wh padding\n else:\n gain = ratio_pad[0][0]\n pad = ratio_pad[1]\n\n coords[:, [0, 2]] -= pad[0] # x padding\n coords[:, [1, 3]] -= pad[1] # y padding\n coords[:, :4] /= gain\n clip_coords(coords, img0_shape)\n return coords"},{"identifier":"scale_polys","path":"utils/general.py","snippet":"def scale_polys(img1_shape, polys, img0_shape, ratio_pad=None):\n # ratio_pad: [(h_raw, w_raw), (hw_ratios, wh_paddings)]\n # Rescale coords (xyxyxyxy) from img1_shape to img0_shape\n if ratio_pad is None: # calculate from img0_shape\n gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1]) # gain = resized / raw\n pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2 # wh padding\n else:\n gain = ratio_pad[0][0] # h_ratios\n pad = ratio_pad[1] # wh_paddings\n\n polys[:, [0, 2, 4, 6]] -= pad[0] # x padding\n polys[:, [1, 3, 5, 7]] -= pad[1] # y padding\n polys[:, :8] /= gain # Rescale poly shape to img0_shape\n #clip_polys(polys, img0_shape)\n return polys"},{"identifier":"strip_optimizer","path":"utils/general.py","snippet":"def strip_optimizer(f='best.pt', s=''): # from utils.general import *; strip_optimizer()\n # Strip optimizer from 'f' to finalize training, optionally save as 's'\n x = torch.load(f, map_location=torch.device('cpu'))\n if x.get('ema'):\n x['model'] = x['ema'] # replace model with ema\n for k in 'optimizer', 'best_fitness', 'wandb_id', 'ema', 'updates': # keys\n x[k] = None\n x['epoch'] = -1\n x['model'].half() # to FP16\n for p in x['model'].parameters():\n p.requires_grad = False\n torch.save(x, s or f)\n mb = os.path.getsize(s or f) / 1E6 # filesize\n print(f\"Optimizer stripped from {f},{(' saved as %s,' % s) if s else ''} {mb:.1f}MB\")"},{"identifier":"xyxy2xywh","path":"utils/general.py","snippet":"def xyxy2xywh(x):\n # Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] where xy1=top-left, xy2=bottom-right\n y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)\n y[:, 0] = (x[:, 0] + x[:, 2]) / 2 # x center\n y[:, 1] = (x[:, 1] + x[:, 3]) / 2 # y center\n y[:, 2] = x[:, 2] - x[:, 0] # width\n y[:, 3] = x[:, 3] - x[:, 1] # height\n return y"},{"identifier":"Annotator","path":"utils/plots.py","snippet":"CONFIG_DIR = user_config_dir() # Ultralytics settings dir\nRANK = int(os.getenv('RANK', -1))\nclass Colors:\nclass Annotator:\n def __init__(self):\n def __call__(self, i, bgr=False):\n def hex2rgb(h): # rgb order (PIL)\ndef check_font(font='Arial.ttf', size=10):\n def __init__(self, im, line_width=None, font_size=None, font='Arial.ttf', pil=False, example='abc'):\n def box_label(self, box, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):\n def poly_label(self, poly, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):\n def rectangle(self, xy, fill=None, outline=None, width=1):\n def text(self, xy, text, txt_color=(255, 255, 255)):\n def result(self):\ndef feature_visualization(x, module_type, stage, n=32, save_dir=Path('runs/detect/exp')):\ndef hist2d(x, y, n=100):\ndef butter_lowpass_filtfilt(data, cutoff=1500, fs=50000, order=5):\n def butter_lowpass(cutoff, fs, order):\ndef output_to_target(output): #list*(n, [xylsθ, conf, cls]) θ ∈ [-pi/2, pi/2)\ndef plot_images(images, targets, paths=None, fname='images.jpg', names=None, max_size=2048, max_subplots=4):\ndef plot_lr_scheduler(optimizer, scheduler, epochs=300, save_dir=''):\ndef plot_val_txt(): # from utils.plots import *; plot_val()\ndef plot_targets_txt(): # from utils.plots import *; plot_targets_txt()\ndef plot_val_study(file='', dir='', x=None): # from utils.plots import *; plot_val_study()\ndef plot_labels(labels, names=(), save_dir=Path(''), img_size=1024):\ndef plot_evolve(evolve_csv='path/to/evolve.csv'): # from utils.plots import *; plot_evolve()\ndef plot_results(file='path/to/results.csv', dir=''):\ndef profile_idetection(start=0, stop=0, labels=(), save_dir=''):\ndef save_one_box(xyxy, im, file='image.jpg', gain=1.02, pad=10, square=False, BGR=False, save=True):"},{"identifier":"select_device","path":"utils/torch_utils.py","snippet":"def select_device(device='', batch_size=0, newline=True):\n # device = 'cpu' or '0' or '0,1,2,3'\n s = f'YOLOv5 🚀 {git_describe() or date_modified()} torch {torch.__version__} ' # string\n device = str(device).strip().lower().replace('cuda:', '') # to string, 'cuda:0' to '0'\n cpu = device == 'cpu'\n if cpu:\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False\n elif device: # non-cpu device requested\n os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable\n assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested' # check availability\n\n cuda = not cpu and torch.cuda.is_available()\n if cuda:\n devices = device.split(',') if device else '0' # range(torch.cuda.device_count()) # i.e. 0,1,6,7\n n = len(devices) # device count\n if n > 1 and batch_size > 0: # check batch_size is divisible by device_count\n assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'\n space = ' ' * (len(s) + 1)\n for i, d in enumerate(devices):\n p = torch.cuda.get_device_properties(i)\n s += f\"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2:.0f}MiB)\\n\" # bytes to MB\n else:\n s += 'CPU\\n'\n\n if not newline:\n s = s.rstrip()\n LOGGER.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s) # emoji-safe\n return torch.device('cuda:0' if cuda else 'cpu')"},{"identifier":"time_sync","path":"utils/torch_utils.py","snippet":"def time_sync():\n # pytorch-accurate time\n if torch.cuda.is_available():\n torch.cuda.synchronize()\n return time.time()"},{"identifier":"poly2rbox","path":"utils/rboxs_utils.py","snippet":"def poly2rbox(polys, num_cls_thata=180, radius=6.0, use_pi=False, use_gaussian=False):\n \"\"\"\n Trans poly format to rbox format.\n Args:\n polys (array): (num_gts, [x1 y1 x2 y2 x3 y3 x4 y4]) \n num_cls_thata (int): [1], theta class num\n radius (float32): [1], window radius for Circular Smooth Label\n use_pi (bool): True θ∈[-pi/2, pi/2) ， False θ∈[0, 180)\n\n Returns:\n use_gaussian True:\n rboxes (array): \n csl_labels (array): (num_gts, num_cls_thata)\n elif \n rboxes (array): (num_gts, [cx cy l s θ]) \n \"\"\"\n assert polys.shape[-1] == 8\n if use_gaussian:\n csl_labels = []\n rboxes = []\n for poly in polys:\n poly = np.float32(poly.reshape(4, 2))\n (x, y), (w, h), angle = cv2.minAreaRect(poly) # θ ∈ [0， 90]\n angle = -angle # θ ∈ [-90， 0]\n theta = angle / 180 * pi # 转为pi制\n\n # trans opencv format to longedge format θ ∈ [-pi/2， pi/2]\n if w != max(w, h): \n w, h = h, w\n theta += pi/2\n theta = regular_theta(theta) # limit theta ∈ [-pi/2, pi/2)\n angle = (theta * 180 / pi) + 90 # θ ∈ [0， 180)\n\n if not use_pi: # 采用angle弧度制 θ ∈ [0， 180)\n rboxes.append([x, y, w, h, angle])\n else: # 采用pi制\n rboxes.append([x, y, w, h, theta])\n if use_gaussian:\n csl_label = gaussian_label_cpu(label=angle, num_class=num_cls_thata, u=0, sig=radius)\n csl_labels.append(csl_label)\n if use_gaussian:\n return np.array(rboxes), np.array(csl_labels)\n return np.array(rboxes)"},{"identifier":"rbox2poly","path":"utils/rboxs_utils.py","snippet":"def rbox2poly(obboxes):\n \"\"\"\n Trans rbox format to poly format.\n Args:\n rboxes (array/tensor): (num_gts, [cx cy l s θ]) θ∈[-pi/2, pi/2)\n\n Returns:\n polys (array/tensor): (num_gts, [x1 y1 x2 y2 x3 y3 x4 y4]) \n \"\"\"\n if isinstance(obboxes, torch.Tensor):\n center, w, h, theta = obboxes[:, :2], obboxes[:, 2:3], obboxes[:, 3:4], obboxes[:, 4:5]\n Cos, Sin = torch.cos(theta), torch.sin(theta)\n\n vector1 = torch.cat(\n (w/2 * Cos, -w/2 * Sin), dim=-1)\n vector2 = torch.cat(\n (-h/2 * Sin, -h/2 * Cos), dim=-1)\n point1 = center + vector1 + vector2\n point2 = center + vector1 - vector2\n point3 = center - vector1 - vector2\n point4 = center - vector1 + vector2\n order = obboxes.shape[:-1]\n return torch.cat(\n (point1, point2, point3, point4), dim=-1).reshape(*order, 8)\n else:\n center, w, h, theta = np.split(obboxes, (2, 3, 4), axis=-1)\n Cos, Sin = np.cos(theta), np.sin(theta)\n\n vector1 = np.concatenate(\n [w/2 * Cos, -w/2 * Sin], axis=-1)\n vector2 = np.concatenate(\n [-h/2 * Sin, -h/2 * Cos], axis=-1)\n\n point1 = center + vector1 + vector2\n point2 = center + vector1 - vector2\n point3 = center - vector1 - vector2\n point4 = center - vector1 + vector2\n order = obboxes.shape[:-1]\n return np.concatenate(\n [point1, point2, point3, point4], axis=-1).reshape(*order, 8)"}],"string":"[\n {\n \"identifier\": \"DetectMultiBackend\",\n \"path\": \"models/common.py\",\n \"snippet\": \"class DetectMultiBackend(nn.Module):\\n # YOLOv5 MultiBackend class for python inference on various backends\\n def __init__(self, weights='yolov5s.pt', device=None, dnn=False):\\n # Usage:\\n # PyTorch: weights = *.pt\\n # TorchScript: *.torchscript\\n # CoreML: *.mlmodel\\n # TensorFlow: *_saved_model\\n # TensorFlow: *.pb\\n # TensorFlow Lite: *.tflite\\n # ONNX Runtime: *.onnx\\n # OpenCV DNN: *.onnx with dnn=True\\n # TensorRT: *.engine\\n from models.experimental import attempt_download, attempt_load # scoped to avoid circular import\\n\\n super().__init__()\\n w = str(weights[0] if isinstance(weights, list) else weights)\\n suffix = Path(w).suffix.lower()\\n suffixes = ['.pt', '.torchscript', '.onnx', '.engine', '.tflite', '.pb', '', '.mlmodel']\\n check_suffix(w, suffixes) # check weights have acceptable suffix\\n pt, jit, onnx, engine, tflite, pb, saved_model, coreml = (suffix == x for x in suffixes) # backend booleans\\n stride, names = 64, [f'class{i}' for i in range(1000)] # assign defaults\\n w = attempt_download(w) # download if not local\\n\\n if jit: # TorchScript\\n LOGGER.info(f'Loading {w} for TorchScript inference...')\\n extra_files = {'config.txt': ''} # model metadata\\n model = torch.jit.load(w, _extra_files=extra_files)\\n if extra_files['config.txt']:\\n d = json.loads(extra_files['config.txt']) # extra_files dict\\n stride, names = int(d['stride']), d['names']\\n elif pt: # PyTorch\\n model = attempt_load(weights if isinstance(weights, list) else w, map_location=device)\\n stride = int(model.stride.max()) # model stride\\n names = model.module.names if hasattr(model, 'module') else model.names # get class names\\n self.model = model # explicitly assign for to(), cpu(), cuda(), half()\\n elif coreml: # CoreML\\n LOGGER.info(f'Loading {w} for CoreML inference...')\\n import coremltools as ct\\n model = ct.models.MLModel(w)\\n elif dnn: # ONNX OpenCV DNN\\n LOGGER.info(f'Loading {w} for ONNX OpenCV DNN inference...')\\n check_requirements(('opencv-python>=4.5.4',))\\n net = cv2.dnn.readNetFromONNX(w)\\n elif onnx: # ONNX Runtime\\n LOGGER.info(f'Loading {w} for ONNX Runtime inference...')\\n cuda = torch.cuda.is_available()\\n check_requirements(('onnx', 'onnxruntime-gpu' if cuda else 'onnxruntime'))\\n import onnxruntime\\n providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if cuda else ['CPUExecutionProvider']\\n session = onnxruntime.InferenceSession(w, providers=providers)\\n elif engine: # TensorRT\\n LOGGER.info(f'Loading {w} for TensorRT inference...')\\n import tensorrt as trt # https://developer.nvidia.com/nvidia-tensorrt-download\\n check_version(trt.__version__, '8.0.0', verbose=True) # version requirement\\n Binding = namedtuple('Binding', ('name', 'dtype', 'shape', 'data', 'ptr'))\\n logger = trt.Logger(trt.Logger.INFO)\\n with open(w, 'rb') as f, trt.Runtime(logger) as runtime:\\n model = runtime.deserialize_cuda_engine(f.read())\\n bindings = OrderedDict()\\n for index in range(model.num_bindings):\\n name = model.get_binding_name(index)\\n dtype = trt.nptype(model.get_binding_dtype(index))\\n shape = tuple(model.get_binding_shape(index))\\n data = torch.from_numpy(np.empty(shape, dtype=np.dtype(dtype))).to(device)\\n bindings[name] = Binding(name, dtype, shape, data, int(data.data_ptr()))\\n binding_addrs = OrderedDict((n, d.ptr) for n, d in bindings.items())\\n context = model.create_execution_context()\\n batch_size = bindings['images'].shape[0]\\n else: # TensorFlow model (TFLite, pb, saved_model)\\n if pb: # https://www.tensorflow.org/guide/migrate#a_graphpb_or_graphpbtxt\\n LOGGER.info(f'Loading {w} for TensorFlow *.pb inference...')\\n import tensorflow as tf\\n\\n def wrap_frozen_graph(gd, inputs, outputs):\\n x = tf.compat.v1.wrap_function(lambda: tf.compat.v1.import_graph_def(gd, name=\\\"\\\"), []) # wrapped\\n return x.prune(tf.nest.map_structure(x.graph.as_graph_element, inputs),\\n tf.nest.map_structure(x.graph.as_graph_element, outputs))\\n\\n graph_def = tf.Graph().as_graph_def()\\n graph_def.ParseFromString(open(w, 'rb').read())\\n frozen_func = wrap_frozen_graph(gd=graph_def, inputs=\\\"x:0\\\", outputs=\\\"Identity:0\\\")\\n elif saved_model:\\n LOGGER.info(f'Loading {w} for TensorFlow saved_model inference...')\\n import tensorflow as tf\\n model = tf.keras.models.load_model(w)\\n elif tflite: # https://www.tensorflow.org/lite/guide/python#install_tensorflow_lite_for_python\\n if 'edgetpu' in w.lower():\\n LOGGER.info(f'Loading {w} for TensorFlow Lite Edge TPU inference...')\\n import tflite_runtime.interpreter as tfli\\n delegate = {'Linux': 'libedgetpu.so.1', # install https://coral.ai/software/#edgetpu-runtime\\n 'Darwin': 'libedgetpu.1.dylib',\\n 'Windows': 'edgetpu.dll'}[platform.system()]\\n interpreter = tfli.Interpreter(model_path=w, experimental_delegates=[tfli.load_delegate(delegate)])\\n else:\\n LOGGER.info(f'Loading {w} for TensorFlow Lite inference...')\\n import tensorflow as tf\\n interpreter = tf.lite.Interpreter(model_path=w) # load TFLite model\\n interpreter.allocate_tensors() # allocate\\n input_details = interpreter.get_input_details() # inputs\\n output_details = interpreter.get_output_details() # outputs\\n self.__dict__.update(locals()) # assign all variables to self\\n\\n def forward(self, im, augment=False, visualize=False, val=False):\\n # YOLOv5 MultiBackend inference\\n b, ch, h, w = im.shape # batch, channel, height, width\\n if self.pt or self.jit: # PyTorch\\n y = self.model(im) if self.jit else self.model(im, augment=augment, visualize=visualize)\\n return y if val else y[0]\\n elif self.coreml: # CoreML\\n im = im.permute(0, 2, 3, 1).cpu().numpy() # torch BCHW to numpy BHWC shape(1,320,192,3)\\n im = Image.fromarray((im[0] * 255).astype('uint8'))\\n # im = im.resize((192, 320), Image.ANTIALIAS)\\n y = self.model.predict({'image': im}) # coordinates are xywh normalized\\n box = xywh2xyxy(y['coordinates'] * [[w, h, w, h]]) # xyxy pixels\\n conf, cls = y['confidence'].max(1), y['confidence'].argmax(1).astype(np.float)\\n y = np.concatenate((box, conf.reshape(-1, 1), cls.reshape(-1, 1)), 1)\\n elif self.onnx: # ONNX\\n im = im.cpu().numpy() # torch to numpy\\n if self.dnn: # ONNX OpenCV DNN\\n self.net.setInput(im)\\n y = self.net.forward()\\n else: # ONNX Runtime\\n y = self.session.run([self.session.get_outputs()[0].name], {self.session.get_inputs()[0].name: im})[0]\\n elif self.engine: # TensorRT\\n assert im.shape == self.bindings['images'].shape, (im.shape, self.bindings['images'].shape)\\n self.binding_addrs['images'] = int(im.data_ptr())\\n self.context.execute_v2(list(self.binding_addrs.values()))\\n y = self.bindings['output'].data\\n else: # TensorFlow model (TFLite, pb, saved_model)\\n im = im.permute(0, 2, 3, 1).cpu().numpy() # torch BCHW to numpy BHWC shape(1,320,192,3)\\n if self.pb:\\n y = self.frozen_func(x=self.tf.constant(im)).numpy()\\n elif self.saved_model:\\n y = self.model(im, training=False).numpy()\\n elif self.tflite:\\n input, output = self.input_details[0], self.output_details[0]\\n int8 = input['dtype'] == np.uint8 # is TFLite quantized uint8 model\\n if int8:\\n scale, zero_point = input['quantization']\\n im = (im / scale + zero_point).astype(np.uint8) # de-scale\\n self.interpreter.set_tensor(input['index'], im)\\n self.interpreter.invoke()\\n y = self.interpreter.get_tensor(output['index'])\\n if int8:\\n scale, zero_point = output['quantization']\\n y = (y.astype(np.float32) - zero_point) * scale # re-scale\\n y[..., 0] *= w # x\\n y[..., 1] *= h # y\\n y[..., 2] *= w # w\\n y[..., 3] *= h # h\\n y = torch.tensor(y) if isinstance(y, np.ndarray) else y\\n return (y, []) if val else y\\n\\n def warmup(self, imgsz=(1, 3, 640, 640), half=False):\\n # Warmup model by running inference once\\n if self.pt or self.engine or self.onnx: # warmup types\\n if isinstance(self.device, torch.device) and self.device.type != 'cpu': # only warmup GPU models\\n im = torch.zeros(*imgsz).to(self.device).type(torch.half if half else torch.float) # input image\\n self.forward(im) # warmup\"\n },\n {\n \"identifier\": \"IMG_FORMATS\",\n \"path\": \"utils/datasets.py\",\n \"snippet\": \"IMG_FORMATS = ['bmp', 'jpg', 'jpeg', 'png', 'tif', 'tiff', 'dng', 'webp', 'mpo'] # acceptable image suffixes\"\n },\n {\n \"identifier\": \"VID_FORMATS\",\n \"path\": \"utils/datasets.py\",\n \"snippet\": \"VID_FORMATS = ['mov', 'avi', 'mp4', 'mpg', 'mpeg', 'm4v', 'wmv', 'mkv'] # acceptable video suffixes\"\n },\n {\n \"identifier\": \"LoadImages\",\n \"path\": \"utils/datasets.py\",\n \"snippet\": \"class LoadImages:\\n # YOLOv5 image/video dataloader, i.e. `python detect.py --source image.jpg/vid.mp4`\\n def __init__(self, path, img_size=640, stride=32, auto=True):\\n p = str(Path(path).resolve()) # os-agnostic absolute path\\n if '*' in p:\\n files = sorted(glob.glob(p, recursive=True)) # glob\\n elif os.path.isdir(p):\\n files = sorted(glob.glob(os.path.join(p, '*.*'))) # dir\\n elif os.path.isfile(p):\\n files = [p] # files\\n else:\\n raise Exception(f'ERROR: {p} does not exist')\\n\\n images = [x for x in files if x.split('.')[-1].lower() in IMG_FORMATS]\\n videos = [x for x in files if x.split('.')[-1].lower() in VID_FORMATS]\\n ni, nv = len(images), len(videos)\\n\\n self.img_size = img_size\\n self.stride = stride\\n self.files = images + videos\\n self.nf = ni + nv # number of files\\n self.video_flag = [False] * ni + [True] * nv\\n self.mode = 'image'\\n self.auto = auto\\n if any(videos):\\n self.new_video(videos[0]) # new video\\n else:\\n self.cap = None\\n assert self.nf > 0, f'No images or videos found in {p}. ' \\\\\\n f'Supported formats are:\\\\nimages: {IMG_FORMATS}\\\\nvideos: {VID_FORMATS}'\\n\\n def __iter__(self):\\n self.count = 0\\n return self\\n\\n def __next__(self):\\n if self.count == self.nf:\\n raise StopIteration\\n path = self.files[self.count]\\n\\n if self.video_flag[self.count]:\\n # Read video\\n self.mode = 'video'\\n ret_val, img0 = self.cap.read()\\n while not ret_val:\\n self.count += 1\\n self.cap.release()\\n if self.count == self.nf: # last video\\n raise StopIteration\\n else:\\n path = self.files[self.count]\\n self.new_video(path)\\n ret_val, img0 = self.cap.read()\\n\\n self.frame += 1\\n s = f'video {self.count + 1}/{self.nf} ({self.frame}/{self.frames}) {path}: '\\n\\n else:\\n # Read image\\n self.count += 1\\n img0 = cv2.imread(path) # BGR\\n assert img0 is not None, f'Image Not Found {path}'\\n s = f'image {self.count}/{self.nf} {path}: '\\n\\n # Padded resize\\n img = letterbox(img0, self.img_size, stride=self.stride, auto=self.auto)[0]\\n\\n # Convert\\n img = img.transpose((2, 0, 1))[::-1] # HWC to CHW, BGR to RGB\\n img = np.ascontiguousarray(img)\\n\\n return path, img, img0, self.cap, s\\n\\n def new_video(self, path):\\n self.frame = 0\\n self.cap = cv2.VideoCapture(path)\\n self.frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))\\n\\n def __len__(self):\\n return self.nf # number of files\"\n },\n {\n \"identifier\": \"LoadStreams\",\n \"path\": \"utils/datasets.py\",\n \"snippet\": \"class LoadStreams:\\n # YOLOv5 streamloader, i.e. `python detect.py --source 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP streams`\\n def __init__(self, sources='streams.txt', img_size=640, stride=32, auto=True):\\n self.mode = 'stream'\\n self.img_size = img_size\\n self.stride = stride\\n\\n if os.path.isfile(sources):\\n with open(sources) as f:\\n sources = [x.strip() for x in f.read().strip().splitlines() if len(x.strip())]\\n else:\\n sources = [sources]\\n\\n n = len(sources)\\n self.imgs, self.fps, self.frames, self.threads = [None] * n, [0] * n, [0] * n, [None] * n\\n self.sources = [clean_str(x) for x in sources] # clean source names for later\\n self.auto = auto\\n for i, s in enumerate(sources): # index, source\\n # Start thread to read frames from video stream\\n st = f'{i + 1}/{n}: {s}... '\\n if 'youtube.com/' in s or 'youtu.be/' in s: # if source is YouTube video\\n check_requirements(('pafy', 'youtube_dl'))\\n import pafy\\n s = pafy.new(s).getbest(preftype=\\\"mp4\\\").url # YouTube URL\\n s = eval(s) if s.isnumeric() else s # i.e. s = '0' local webcam\\n cap = cv2.VideoCapture(s)\\n assert cap.isOpened(), f'{st}Failed to open {s}'\\n w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))\\n h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\\n self.fps[i] = max(cap.get(cv2.CAP_PROP_FPS) % 100, 0) or 30.0 # 30 FPS fallback\\n self.frames[i] = max(int(cap.get(cv2.CAP_PROP_FRAME_COUNT)), 0) or float('inf') # infinite stream fallback\\n\\n _, self.imgs[i] = cap.read() # guarantee first frame\\n self.threads[i] = Thread(target=self.update, args=([i, cap, s]), daemon=True)\\n LOGGER.info(f\\\"{st} Success ({self.frames[i]} frames {w}x{h} at {self.fps[i]:.2f} FPS)\\\")\\n self.threads[i].start()\\n LOGGER.info('') # newline\\n\\n # check for common shapes\\n s = np.stack([letterbox(x, self.img_size, stride=self.stride, auto=self.auto)[0].shape for x in self.imgs])\\n self.rect = np.unique(s, axis=0).shape[0] == 1 # rect inference if all shapes equal\\n if not self.rect:\\n LOGGER.warning('WARNING: Stream shapes differ. For optimal performance supply similarly-shaped streams.')\\n\\n def update(self, i, cap, stream):\\n # Read stream `i` frames in daemon thread\\n n, f, read = 0, self.frames[i], 1 # frame number, frame array, inference every 'read' frame\\n while cap.isOpened() and n < f:\\n n += 1\\n # _, self.imgs[index] = cap.read()\\n cap.grab()\\n if n % read == 0:\\n success, im = cap.retrieve()\\n if success:\\n self.imgs[i] = im\\n else:\\n LOGGER.warning('WARNING: Video stream unresponsive, please check your IP camera connection.')\\n self.imgs[i] = np.zeros_like(self.imgs[i])\\n cap.open(stream) # re-open stream if signal was lost\\n time.sleep(1 / self.fps[i]) # wait time\\n\\n def __iter__(self):\\n self.count = -1\\n return self\\n\\n def __next__(self):\\n self.count += 1\\n if not all(x.is_alive() for x in self.threads) or cv2.waitKey(1) == ord('q'): # q to quit\\n cv2.destroyAllWindows()\\n raise StopIteration\\n\\n # Letterbox\\n img0 = self.imgs.copy()\\n img = [letterbox(x, self.img_size, stride=self.stride, auto=self.rect and self.auto)[0] for x in img0]\\n\\n # Stack\\n img = np.stack(img, 0)\\n\\n # Convert\\n img = img[..., ::-1].transpose((0, 3, 1, 2)) # BGR to RGB, BHWC to BCHW\\n img = np.ascontiguousarray(img)\\n\\n return self.sources, img, img0, None, ''\\n\\n def __len__(self):\\n return len(self.sources) # 1E12 frames = 32 streams at 30 FPS for 30 years\"\n },\n {\n \"identifier\": \"LOGGER\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"LOGGER = set_logging(__name__) # define globally (used in train.py, val.py, detect.py, etc.)\"\n },\n {\n \"identifier\": \"check_file\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def check_file(file, suffix=''):\\n # Search/download file (if necessary) and return path\\n check_suffix(file, suffix) # optional\\n file = str(file) # convert to str()\\n if Path(file).is_file() or file == '': # exists\\n return file\\n elif file.startswith(('http:/', 'https:/')): # download\\n url = str(Path(file)).replace(':/', '://') # Pathlib turns :// -> :/\\n file = Path(urllib.parse.unquote(file).split('?')[0]).name # '%2F' to '/', split https://url.com/file.txt?auth\\n if Path(file).is_file():\\n print(f'Found {url} locally at {file}') # file already exists\\n else:\\n print(f'Downloading {url} to {file}...')\\n torch.hub.download_url_to_file(url, file)\\n assert Path(file).exists() and Path(file).stat().st_size > 0, f'File download failed: {url}' # check\\n return file\\n else: # search\\n files = []\\n for d in 'data', 'models', 'utils': # search directories\\n files.extend(glob.glob(str(ROOT / d / '**' / file), recursive=True)) # find file\\n assert len(files), f'File not found: {file}' # assert file was found\\n assert len(files) == 1, f\\\"Multiple files match '{file}', specify exact path: {files}\\\" # assert unique\\n return files[0] # return file\"\n },\n {\n \"identifier\": \"check_img_size\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def check_img_size(imgsz, s=32, floor=0):\\n print(f\\\"#305 in utils/general.py - s={s}\\\")\\n # Verify image size is a multiple of stride s in each dimension\\n if isinstance(imgsz, int): # integer i.e. img_size=640\\n new_size = max(make_divisible(imgsz, int(s)), floor)\\n else: # list i.e. img_size=[640, 480]\\n new_size = [max(make_divisible(x, int(s)), floor) for x in imgsz]\\n if new_size != imgsz:\\n print(f'WARNING: --img-size {imgsz} must be multiple of max stride {s}, updating to {new_size}')\\n return new_size\"\n },\n {\n \"identifier\": \"check_imshow\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def check_imshow():\\n # Check if environment supports image displays\\n try:\\n assert not is_docker(), 'cv2.imshow() is disabled in Docker environments'\\n assert not is_colab(), 'cv2.imshow() is disabled in Google Colab environments'\\n cv2.imshow('test', np.zeros((1, 1, 3)))\\n cv2.waitKey(1)\\n cv2.destroyAllWindows()\\n cv2.waitKey(1)\\n return True\\n except Exception as e:\\n print(f'WARNING: Environment does not support cv2.imshow() or PIL Image.show() image displays\\\\n{e}')\\n return False\"\n },\n {\n \"identifier\": \"check_requirements\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"@try_except\\ndef check_requirements(requirements=ROOT / 'requirements.txt', exclude=(), install=True):\\n # Check installed dependencies meet requirements (pass *.txt file or list of packages)\\n prefix = colorstr('red', 'bold', 'requirements:')\\n check_python() # check python version\\n if isinstance(requirements, (str, Path)): # requirements.txt file\\n file = Path(requirements)\\n assert file.exists(), f\\\"{prefix} {file.resolve()} not found, check failed.\\\"\\n with file.open() as f:\\n requirements = [f'{x.name}{x.specifier}' for x in pkg.parse_requirements(f) if x.name not in exclude]\\n else: # list or tuple of packages\\n requirements = [x for x in requirements if x not in exclude]\\n\\n n = 0 # number of packages updates\\n for r in requirements:\\n try:\\n pkg.require(r)\\n except Exception as e: # DistributionNotFound or VersionConflict if requirements not met\\n s = f\\\"{prefix} {r} not found and is required by YOLOv5\\\"\\n if install:\\n print(f\\\"{s}, attempting auto-update...\\\")\\n try:\\n assert check_online(), f\\\"'pip install {r}' skipped (offline)\\\"\\n print(check_output(f\\\"pip install '{r}'\\\", shell=True).decode())\\n n += 1\\n except Exception as e:\\n print(f'{prefix} {e}')\\n else:\\n print(f'{s}. Please install and rerun your command.')\\n\\n if n: # if packages updated\\n source = file.resolve() if 'file' in locals() else requirements\\n s = f\\\"{prefix} {n} package{'s' * (n > 1)} updated per {source}\\\\n\\\" \\\\\\n f\\\"{prefix} ⚠️ {colorstr('bold', 'Restart runtime or rerun command for updates to take effect')}\\\\n\\\"\\n print(emojis(s))\"\n },\n {\n \"identifier\": \"colorstr\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def colorstr(*input):\\n # Colors a string https://en.wikipedia.org/wiki/ANSI_escape_code, i.e. colorstr('blue', 'hello world')\\n *args, string = input if len(input) > 1 else ('blue', 'bold', input[0]) # color arguments, string\\n colors = {'black': '\\\\033[30m', # basic colors\\n 'red': '\\\\033[31m',\\n 'green': '\\\\033[32m',\\n 'yellow': '\\\\033[33m',\\n 'blue': '\\\\033[34m',\\n 'magenta': '\\\\033[35m',\\n 'cyan': '\\\\033[36m',\\n 'white': '\\\\033[37m',\\n 'bright_black': '\\\\033[90m', # bright colors\\n 'bright_red': '\\\\033[91m',\\n 'bright_green': '\\\\033[92m',\\n 'bright_yellow': '\\\\033[93m',\\n 'bright_blue': '\\\\033[94m',\\n 'bright_magenta': '\\\\033[95m',\\n 'bright_cyan': '\\\\033[96m',\\n 'bright_white': '\\\\033[97m',\\n 'end': '\\\\033[0m', # misc\\n 'bold': '\\\\033[1m',\\n 'underline': '\\\\033[4m'}\\n return ''.join(colors[x] for x in args) + f'{string}' + colors['end']\"\n },\n {\n \"identifier\": \"increment_path\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def increment_path(path, exist_ok=False, sep='', mkdir=False):\\n # Increment file or directory path, i.e. runs/exp --> runs/exp{sep}2, runs/exp{sep}3, ... etc.\\n path = Path(path) # os-agnostic\\n if path.exists() and not exist_ok:\\n path, suffix = (path.with_suffix(''), path.suffix) if path.is_file() else (path, '')\\n dirs = glob.glob(f\\\"{path}{sep}*\\\") # similar paths\\n matches = [re.search(rf\\\"%s{sep}(\\\\d+)\\\" % path.stem, d) for d in dirs]\\n i = [int(m.groups()[0]) for m in matches if m] # indices\\n n = max(i) + 1 if i else 2 # increment number\\n path = Path(f\\\"{path}{sep}{n}{suffix}\\\") # increment path\\n if mkdir:\\n path.mkdir(parents=True, exist_ok=True) # make directory\\n return path\"\n },\n {\n \"identifier\": \"non_max_suppression\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def non_max_suppression(prediction, conf_thres=0.25, iou_thres=0.45, classes=None, agnostic=False, multi_label=False,\\n labels=(), max_det=300):\\n \\\"\\\"\\\"Runs Non-Maximum Suppression (NMS) on inference results\\n\\n Returns:\\n list of detections, on (n,6) tensor per image [xyxy, conf, cls]\\n \\\"\\\"\\\"\\n\\n nc = prediction.shape[2] - 5 # number of classes\\n xc = prediction[..., 4] > conf_thres # candidates\\n\\n # Checks\\n assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0'\\n assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0'\\n\\n # Settings\\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\\n time_limit = 10.0 # seconds to quit after\\n redundant = True # require redundant detections\\n multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img)\\n merge = False # use merge-NMS\\n\\n t = time.time()\\n output = [torch.zeros((0, 6), device=prediction.device)] * prediction.shape[0]\\n for xi, x in enumerate(prediction): # image index, image inference\\n # Apply constraints\\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\\n x = x[xc[xi]] # confidence\\n\\n # Cat apriori labels if autolabelling\\n if labels and len(labels[xi]):\\n l = labels[xi]\\n v = torch.zeros((len(l), nc + 5), device=x.device)\\n v[:, :4] = l[:, 1:5] # box\\n v[:, 4] = 1.0 # conf\\n v[range(len(l)), l[:, 0].long() + 5] = 1.0 # cls\\n x = torch.cat((x, v), 0)\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\\n box = xywh2xyxy(x[:, :4])\\n\\n # Detections matrix nx6 (xyxy, conf, cls)\\n if multi_label:\\n i, j = (x[:, 5:] > conf_thres).nonzero(as_tuple=False).T\\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\\n else: # best class only\\n conf, j = x[:, 5:].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\\n\\n # Filter by class\\n if classes is not None:\\n x = x[(x[:, 5:6] == torch.tensor(classes, device=x.device)).any(1)]\\n\\n # Apply finite constraint\\n # if not torch.isfinite(x).all():\\n # x = x[torch.isfinite(x).all(1)]\\n\\n # Check shape\\n n = x.shape[0] # number of boxes\\n if not n: # no boxes\\n continue\\n elif n > max_nms: # excess boxes\\n x = x[x[:, 4].argsort(descending=True)[:max_nms]] # sort by confidence\\n\\n # Batched NMS\\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\\n i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)\\n # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\\n iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\\n weights = iou * scores[None] # box weights\\n x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes\\n if redundant:\\n i = i[iou.sum(1) > 1] # require redundancy\\n\\n output[xi] = x[i]\\n if (time.time() - t) > time_limit:\\n print(f'WARNING: NMS time limit {time_limit}s exceeded')\\n break # time limit exceeded\\n\\n return output\"\n },\n {\n \"identifier\": \"non_max_suppression_obb\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def non_max_suppression_obb(prediction, conf_thres=0.25, iou_thres=0.45, classes=None, agnostic=False, multi_label=False,\\n labels=(), max_det=1500):\\n \\\"\\\"\\\"Runs Non-Maximum Suppression (NMS) on inference results_obb\\n Args:\\n prediction (tensor): (b, n_all_anchors, [cx cy l s obj num_cls theta_cls])\\n agnostic (bool): True = NMS will be applied between elements of different categories\\n labels : () or\\n\\n Returns:\\n list of detections, len=batch_size, on (n,7) tensor per image [xylsθ, conf, cls] θ ∈ [-pi/2, pi/2)\\n \\\"\\\"\\\"\\n\\n nc = prediction.shape[2] - 5 - 180 # number of classes\\n xc = prediction[..., 4] > conf_thres # candidates\\n class_index = nc + 5\\n\\n # Checks\\n assert 0 <= conf_thres <= 1, f'Invalid Confidence threshold {conf_thres}, valid values are between 0.0 and 1.0'\\n assert 0 <= iou_thres <= 1, f'Invalid IoU {iou_thres}, valid values are between 0.0 and 1.0'\\n\\n # Settings\\n max_wh = 4096 # min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\\n max_nms = 30000 # maximum number of boxes into torchvision.ops.nms()\\n time_limit = 30.0 # seconds to quit after\\n # redundant = True # require redundant detections\\n multi_label &= nc > 1 # multiple labels per box (adds 0.5ms/img)\\n\\n t = time.time()\\n output = [torch.zeros((0, 7), device=prediction.device)] * prediction.shape[0]\\n for xi, x in enumerate(prediction): # image index, image inference\\n # Apply constraints\\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\\n x = x[xc[xi]] # confidence, (tensor): (n_conf_thres, [cx cy l s obj num_cls theta_cls])\\n\\n # Cat apriori labels if autolabelling\\n if labels and len(labels[xi]):\\n l = labels[xi]\\n v = torch.zeros((len(l), nc + 5), device=x.device)\\n v[:, :4] = l[:, 1:5] # box\\n v[:, 4] = 1.0 # conf\\n v[range(len(l)), l[:, 0].long() + 5] = 1.0 # cls\\n x = torch.cat((x, v), 0)\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:class_index] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n thete_index, theta_pred = torch.max(x[:, class_index:], 1, keepdim=True) # [n_conf_thres, 1] θ ∈ int[0, 179]\\n theta_pred = (theta_pred - 90) / 180 * pi # [n_conf_thres, 1] θ ∈ [-pi/2, pi/2)\\n\\n # Detections matrix nx7 (xyls, θ, conf, cls) θ ∈ [-pi/2, pi/2)\\n if multi_label:\\n i, j = (x[:, 5:class_index] > conf_thres).nonzero(as_tuple=False).T # ()\\n x = torch.cat((x[i, :4], theta_pred[i], x[i, j + 5, None], j[:, None].float()), 1)\\n else: # best class only\\n conf, j = x[:, 5:class_index].max(1, keepdim=True)\\n x = torch.cat((x[:, :4], theta_pred, conf, j.float()), 1)[conf.view(-1) > conf_thres]\\n\\n # Filter by class\\n if classes is not None:\\n x = x[(x[:, 6:7] == torch.tensor(classes, device=x.device)).any(1)]\\n\\n # Apply finite constraint\\n # if not torch.isfinite(x).all():\\n # x = x[torch.isfinite(x).all(1)]\\n\\n # Check shape\\n n = x.shape[0] # number of boxes\\n if not n: # no boxes\\n continue\\n elif n > max_nms: # excess boxes\\n x = x[x[:, 5].argsort(descending=True)[:max_nms]] # sort by confidence\\n\\n # Batched NMS\\n c = x[:, 6:7] * (0 if agnostic else max_wh) # classes\\n rboxes = x[:, :5].clone() \\n rboxes[:, :2] = rboxes[:, :2] + c # rboxes (offset by class)\\n scores = x[:, 5] # scores\\n _, i = obb_nms(rboxes, scores, iou_thres)\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n\\n output[xi] = x[i]\\n if (time.time() - t) > time_limit:\\n print(f'WARNING: NMS time limit {time_limit}s exceeded')\\n break # time limit exceeded\\n\\n return output\"\n },\n {\n \"identifier\": \"print_args\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def print_args(name, opt):\\n # Print argparser arguments\\n LOGGER.info(colorstr(f'{name}: ') + ', '.join(f'{k}={v}' for k, v in vars(opt).items()))\"\n },\n {\n \"identifier\": \"scale_coords\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def scale_coords(img1_shape, coords, img0_shape, ratio_pad=None):\\n # Rescale coords (xyxy) from img1_shape to img0_shape\\n if ratio_pad is None: # calculate from img0_shape\\n gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1]) # gain = old / new\\n pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2 # wh padding\\n else:\\n gain = ratio_pad[0][0]\\n pad = ratio_pad[1]\\n\\n coords[:, [0, 2]] -= pad[0] # x padding\\n coords[:, [1, 3]] -= pad[1] # y padding\\n coords[:, :4] /= gain\\n clip_coords(coords, img0_shape)\\n return coords\"\n },\n {\n \"identifier\": \"scale_polys\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def scale_polys(img1_shape, polys, img0_shape, ratio_pad=None):\\n # ratio_pad: [(h_raw, w_raw), (hw_ratios, wh_paddings)]\\n # Rescale coords (xyxyxyxy) from img1_shape to img0_shape\\n if ratio_pad is None: # calculate from img0_shape\\n gain = min(img1_shape[0] / img0_shape[0], img1_shape[1] / img0_shape[1]) # gain = resized / raw\\n pad = (img1_shape[1] - img0_shape[1] * gain) / 2, (img1_shape[0] - img0_shape[0] * gain) / 2 # wh padding\\n else:\\n gain = ratio_pad[0][0] # h_ratios\\n pad = ratio_pad[1] # wh_paddings\\n\\n polys[:, [0, 2, 4, 6]] -= pad[0] # x padding\\n polys[:, [1, 3, 5, 7]] -= pad[1] # y padding\\n polys[:, :8] /= gain # Rescale poly shape to img0_shape\\n #clip_polys(polys, img0_shape)\\n return polys\"\n },\n {\n \"identifier\": \"strip_optimizer\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def strip_optimizer(f='best.pt', s=''): # from utils.general import *; strip_optimizer()\\n # Strip optimizer from 'f' to finalize training, optionally save as 's'\\n x = torch.load(f, map_location=torch.device('cpu'))\\n if x.get('ema'):\\n x['model'] = x['ema'] # replace model with ema\\n for k in 'optimizer', 'best_fitness', 'wandb_id', 'ema', 'updates': # keys\\n x[k] = None\\n x['epoch'] = -1\\n x['model'].half() # to FP16\\n for p in x['model'].parameters():\\n p.requires_grad = False\\n torch.save(x, s or f)\\n mb = os.path.getsize(s or f) / 1E6 # filesize\\n print(f\\\"Optimizer stripped from {f},{(' saved as %s,' % s) if s else ''} {mb:.1f}MB\\\")\"\n },\n {\n \"identifier\": \"xyxy2xywh\",\n \"path\": \"utils/general.py\",\n \"snippet\": \"def xyxy2xywh(x):\\n # Convert nx4 boxes from [x1, y1, x2, y2] to [x, y, w, h] where xy1=top-left, xy2=bottom-right\\n y = x.clone() if isinstance(x, torch.Tensor) else np.copy(x)\\n y[:, 0] = (x[:, 0] + x[:, 2]) / 2 # x center\\n y[:, 1] = (x[:, 1] + x[:, 3]) / 2 # y center\\n y[:, 2] = x[:, 2] - x[:, 0] # width\\n y[:, 3] = x[:, 3] - x[:, 1] # height\\n return y\"\n },\n {\n \"identifier\": \"Annotator\",\n \"path\": \"utils/plots.py\",\n \"snippet\": \"CONFIG_DIR = user_config_dir() # Ultralytics settings dir\\nRANK = int(os.getenv('RANK', -1))\\nclass Colors:\\nclass Annotator:\\n def __init__(self):\\n def __call__(self, i, bgr=False):\\n def hex2rgb(h): # rgb order (PIL)\\ndef check_font(font='Arial.ttf', size=10):\\n def __init__(self, im, line_width=None, font_size=None, font='Arial.ttf', pil=False, example='abc'):\\n def box_label(self, box, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):\\n def poly_label(self, poly, label='', color=(128, 128, 128), txt_color=(255, 255, 255)):\\n def rectangle(self, xy, fill=None, outline=None, width=1):\\n def text(self, xy, text, txt_color=(255, 255, 255)):\\n def result(self):\\ndef feature_visualization(x, module_type, stage, n=32, save_dir=Path('runs/detect/exp')):\\ndef hist2d(x, y, n=100):\\ndef butter_lowpass_filtfilt(data, cutoff=1500, fs=50000, order=5):\\n def butter_lowpass(cutoff, fs, order):\\ndef output_to_target(output): #list*(n, [xylsθ, conf, cls]) θ ∈ [-pi/2, pi/2)\\ndef plot_images(images, targets, paths=None, fname='images.jpg', names=None, max_size=2048, max_subplots=4):\\ndef plot_lr_scheduler(optimizer, scheduler, epochs=300, save_dir=''):\\ndef plot_val_txt(): # from utils.plots import *; plot_val()\\ndef plot_targets_txt(): # from utils.plots import *; plot_targets_txt()\\ndef plot_val_study(file='', dir='', x=None): # from utils.plots import *; plot_val_study()\\ndef plot_labels(labels, names=(), save_dir=Path(''), img_size=1024):\\ndef plot_evolve(evolve_csv='path/to/evolve.csv'): # from utils.plots import *; plot_evolve()\\ndef plot_results(file='path/to/results.csv', dir=''):\\ndef profile_idetection(start=0, stop=0, labels=(), save_dir=''):\\ndef save_one_box(xyxy, im, file='image.jpg', gain=1.02, pad=10, square=False, BGR=False, save=True):\"\n },\n {\n \"identifier\": \"select_device\",\n \"path\": \"utils/torch_utils.py\",\n \"snippet\": \"def select_device(device='', batch_size=0, newline=True):\\n # device = 'cpu' or '0' or '0,1,2,3'\\n s = f'YOLOv5 🚀 {git_describe() or date_modified()} torch {torch.__version__} ' # string\\n device = str(device).strip().lower().replace('cuda:', '') # to string, 'cuda:0' to '0'\\n cpu = device == 'cpu'\\n if cpu:\\n os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False\\n elif device: # non-cpu device requested\\n os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable\\n assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested' # check availability\\n\\n cuda = not cpu and torch.cuda.is_available()\\n if cuda:\\n devices = device.split(',') if device else '0' # range(torch.cuda.device_count()) # i.e. 0,1,6,7\\n n = len(devices) # device count\\n if n > 1 and batch_size > 0: # check batch_size is divisible by device_count\\n assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'\\n space = ' ' * (len(s) + 1)\\n for i, d in enumerate(devices):\\n p = torch.cuda.get_device_properties(i)\\n s += f\\\"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2:.0f}MiB)\\\\n\\\" # bytes to MB\\n else:\\n s += 'CPU\\\\n'\\n\\n if not newline:\\n s = s.rstrip()\\n LOGGER.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s) # emoji-safe\\n return torch.device('cuda:0' if cuda else 'cpu')\"\n },\n {\n \"identifier\": \"time_sync\",\n \"path\": \"utils/torch_utils.py\",\n \"snippet\": \"def time_sync():\\n # pytorch-accurate time\\n if torch.cuda.is_available():\\n torch.cuda.synchronize()\\n return time.time()\"\n },\n {\n \"identifier\": \"poly2rbox\",\n \"path\": \"utils/rboxs_utils.py\",\n \"snippet\": \"def poly2rbox(polys, num_cls_thata=180, radius=6.0, use_pi=False, use_gaussian=False):\\n \\\"\\\"\\\"\\n Trans poly format to rbox format.\\n Args:\\n polys (array): (num_gts, [x1 y1 x2 y2 x3 y3 x4 y4]) \\n num_cls_thata (int): [1], theta class num\\n radius (float32): [1], window radius for Circular Smooth Label\\n use_pi (bool): True θ∈[-pi/2, pi/2) ， False θ∈[0, 180)\\n\\n Returns:\\n use_gaussian True:\\n rboxes (array): \\n csl_labels (array): (num_gts, num_cls_thata)\\n elif \\n rboxes (array): (num_gts, [cx cy l s θ]) \\n \\\"\\\"\\\"\\n assert polys.shape[-1] == 8\\n if use_gaussian:\\n csl_labels = []\\n rboxes = []\\n for poly in polys:\\n poly = np.float32(poly.reshape(4, 2))\\n (x, y), (w, h), angle = cv2.minAreaRect(poly) # θ ∈ [0， 90]\\n angle = -angle # θ ∈ [-90， 0]\\n theta = angle / 180 * pi # 转为pi制\\n\\n # trans opencv format to longedge format θ ∈ [-pi/2， pi/2]\\n if w != max(w, h): \\n w, h = h, w\\n theta += pi/2\\n theta = regular_theta(theta) # limit theta ∈ [-pi/2, pi/2)\\n angle = (theta * 180 / pi) + 90 # θ ∈ [0， 180)\\n\\n if not use_pi: # 采用angle弧度制 θ ∈ [0， 180)\\n rboxes.append([x, y, w, h, angle])\\n else: # 采用pi制\\n rboxes.append([x, y, w, h, theta])\\n if use_gaussian:\\n csl_label = gaussian_label_cpu(label=angle, num_class=num_cls_thata, u=0, sig=radius)\\n csl_labels.append(csl_label)\\n if use_gaussian:\\n return np.array(rboxes), np.array(csl_labels)\\n return np.array(rboxes)\"\n },\n {\n \"identifier\": \"rbox2poly\",\n \"path\": \"utils/rboxs_utils.py\",\n \"snippet\": \"def rbox2poly(obboxes):\\n \\\"\\\"\\\"\\n Trans rbox format to poly format.\\n Args:\\n rboxes (array/tensor): (num_gts, [cx cy l s θ]) θ∈[-pi/2, pi/2)\\n\\n Returns:\\n polys (array/tensor): (num_gts, [x1 y1 x2 y2 x3 y3 x4 y4]) \\n \\\"\\\"\\\"\\n if isinstance(obboxes, torch.Tensor):\\n center, w, h, theta = obboxes[:, :2], obboxes[:, 2:3], obboxes[:, 3:4], obboxes[:, 4:5]\\n Cos, Sin = torch.cos(theta), torch.sin(theta)\\n\\n vector1 = torch.cat(\\n (w/2 * Cos, -w/2 * Sin), dim=-1)\\n vector2 = torch.cat(\\n (-h/2 * Sin, -h/2 * Cos), dim=-1)\\n point1 = center + vector1 + vector2\\n point2 = center + vector1 - vector2\\n point3 = center - vector1 - vector2\\n point4 = center - vector1 + vector2\\n order = obboxes.shape[:-1]\\n return torch.cat(\\n (point1, point2, point3, point4), dim=-1).reshape(*order, 8)\\n else:\\n center, w, h, theta = np.split(obboxes, (2, 3, 4), axis=-1)\\n Cos, Sin = np.cos(theta), np.sin(theta)\\n\\n vector1 = np.concatenate(\\n [w/2 * Cos, -w/2 * Sin], axis=-1)\\n vector2 = np.concatenate(\\n [-h/2 * Sin, -h/2 * Cos], axis=-1)\\n\\n point1 = center + vector1 + vector2\\n point2 = center + vector1 - vector2\\n point3 = center - vector1 - vector2\\n point4 = center - vector1 + vector2\\n order = obboxes.shape[:-1]\\n return np.concatenate(\\n [point1, point2, point3, point4], axis=-1).reshape(*order, 8)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import argparse\nimport os\nimport sys\nimport cv2\nimport torch\nimport torch.backends.cudnn as cudnn\nfrom pathlib import Path\nfrom models.common import DetectMultiBackend\nfrom utils.datasets import IMG_FORMATS, VID_FORMATS, LoadImages, LoadStreams\nfrom utils.general import (LOGGER, check_file, check_img_size, check_imshow, check_requirements, colorstr,\n increment_path, non_max_suppression, non_max_suppression_obb, print_args, scale_coords, scale_polys, strip_optimizer, xyxy2xywh)\nfrom utils.plots import Annotator, colors, save_one_box\nfrom utils.torch_utils import select_device, time_sync\nfrom utils.rboxs_utils import poly2rbox, rbox2poly"},"token_num":{"kind":"number","value":15619,"string":"15,619"},"cropped_code":{"kind":"string","value":" # pred: list*(n, [xylsθ, conf, cls]) θ ∈ [-pi/2, pi/2)\n pred = non_max_suppression_obb(pred, conf_thres, iou_thres, classes, agnostic_nms, multi_label=True, max_det=max_det)\n dt[2] += time_sync() - t3\n\n # Second-stage classifier (optional)\n # pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)\n\n # Process predictions\n for i, det in enumerate(pred): # per image\n pred_poly = rbox2poly(det[:, :5]) # (n, [x1 y1 x2 y2 x3 y3 x4 y4])\n seen += 1\n if webcam: # batch_size >= 1\n p, im0, frame = path[i], im0s[i].copy(), dataset.count\n s += f'{i}: '\n else:\n p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)\n\n p = Path(p) # to Path\n save_path = str(save_dir / p.name) # im.jpg\n txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # im.txt\n s += '%gx%g ' % im.shape[2:] # print string\n gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh\n imc = im0.copy() if save_crop else im0 # for save_crop\n annotator = Annotator(im0, line_width=line_thickness, example=str(names))\n if len(det):\n # Rescale polys from img_size to im0 size\n # det[:, :4] = scale_coords(im.shape[2:], det[:, :4], im0.shape).round()\n pred_poly = scale_polys(im.shape[2:], pred_poly, im0.shape)\n det = torch.cat((pred_poly, det[:, -2:]), dim=1) # (n, [poly conf cls])\n\n # Print results\n for c in det[:, -1].unique():\n n = (det[:, -1] == c).sum() # detections per class\n s += f\"{n} {names[int(c)]}{'s' * (n > 1)}, \" # add to string\n\n # Write results\n for *poly, conf, cls in reversed(det):\n if save_txt: # Write to file\n # xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh\n poly = poly.tolist()\n line = (cls, *poly, conf) if save_conf else (cls, *poly) # label format\n with open(txt_path + '.txt', 'a') as f:\n f.write(('%g ' * len(line)).rstrip() % line + '\\n')\n\n if save_img or save_crop or view_img: # Add poly to image\n c = int(cls) # integer class\n label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')\n # annotator.box_label(xyxy, label, color=colors(c, True))\n annotator.poly_label(poly, label, color=colors(c, True))\n if save_crop: # Yolov5-obb doesn't support it yet\n # save_one_box(xyxy, imc, file=save_dir / 'crops' / names[c] / f'{p.stem}.jpg', BGR=True)\n pass\n\n # Print time (inference-only)\n LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)')\n\n # Stream results\n im0 = annotator.result()\n if view_img:\n cv2.imshow(str(p), im0)\n cv2.waitKey(1) # 1 millisecond\n\n # Save results (image with detections)\n if save_img:\n if dataset.mode == 'image':\n cv2.imwrite(save_path, im0)\n else: # 'video' or 'stream'\n if vid_path[i] != save_path: # new video\n vid_path[i] = save_path\n if isinstance(vid_writer[i], cv2.VideoWriter):\n vid_writer[i].release() # release previous video writer\n if vid_cap: # video\n fps = vid_cap.get(cv2.CAP_PROP_FPS)\n w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n else: # stream\n fps, w, h = 30, im0.shape[1], im0.shape[0]\n save_path += '.mp4'\n vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))\n vid_writer[i].write(im0)\n\n # Print results\n t = tuple(x / seen * 1E3 for x in dt) # speeds per image\n LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t)\n if save_txt or save_img:\n s = f\"\\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}\" if save_txt else ''\n LOGGER.info(f\"Results saved to {colorstr('bold', save_dir)}{s}\")\n if update:\n strip_optimizer(weights) # update model (to fix SourceChangeWarning)\n\n\ndef parse_opt():\n parser = argparse.ArgumentParser()\n parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs/train/yolov5n_DroneVehicle/weights/best.pt', help='model path(s)')\n parser.add_argument('--source', type=str, default='/media/test/4d846cae-2315-4928-8d1b-ca6d3a61a3c6/DroneVehicle/val/raw/images/', help='file/dir/URL/glob, 0 for webcam')\n parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[840], help='inference size h,w')\n parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')\n parser.add_argument('--iou-thres', type=float, default=0.2, help='NMS IoU threshold')\n parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')\n parser.add_argument('--device', default='3', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')\n parser.add_argument('--view-img', action='store_true', help='show results')\n parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')\n parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')\n parser.add_argument('--save-crop', action='store_true', help='save cropped prediction boxes')\n parser.add_argument('--nosave', action='store_true', help='do not save images/videos')\n parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')\n parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')\n parser.add_argument('--augment', action='store_true', help='augmented inference')\n parser.add_argument('--visualize', action='store_true', help='visualize features')\n parser.add_argument('--update', action='store_true', help='update all models')\n parser.add_argument('--project', default='runs/detect', help='save results to project/name')\n parser.add_argument('--name', default='exp', help='save results to project/name')\n parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')\n parser.add_argument('--line-thickness', default=2, type=int, help='bounding box thickness (pixels)')\n parser.add_argument('--hide-labels', default=False, action='store_true', help='hide labels')\n parser.add_argument('--hide-conf', default=False, action='store_true', help='hide confidences')\n parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')\n parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')\n opt = parser.parse_args()\n opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand\n"},"all_code":{"kind":"string","value":"# YOLOv5 🚀 by Ultralytics, GPL-3.0 license\n\"\"\"\nRun inference on images, videos, directories, streams, etc.\n\nUsage:\n $ python path/to/detect.py --weights yolov5s.pt --source 0 # webcam\n img.jpg # image\n vid.mp4 # video\n path/ # directory\n path/*.jpg # glob\n 'https://youtu.be/Zgi9g1ksQHc' # YouTube\n 'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream\n\"\"\"\n\n\n\nFILE = Path(__file__).resolve()\nROOT = FILE.parents[0] # YOLOv5 root directory\nif str(ROOT) not in sys.path:\n sys.path.append(str(ROOT)) # add ROOT to PATH\nROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative\n\n\n\n@torch.no_grad()\ndef run(weights=ROOT / 'yolov5s.pt', # model.pt path(s)\n source=ROOT / 'data/images', # file/dir/URL/glob, 0 for webcam\n imgsz=(640, 640), # inference size (height, width)\n conf_thres=0.25, # confidence threshold\n iou_thres=0.45, # NMS IOU threshold\n max_det=1000, # maximum detections per image\n device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu\n view_img=False, # show results\n save_txt=False, # save results to *.txt\n save_conf=False, # save confidences in --save-txt labels\n save_crop=False, # save cropped prediction boxes\n nosave=False, # do not save images/videos\n classes=None, # filter by class: --class 0, or --class 0 2 3\n agnostic_nms=False, # class-agnostic NMS\n augment=False, # augmented inference\n visualize=False, # visualize features\n update=False, # update all models\n project=ROOT / 'runs/detect', # save results to project/name\n name='exp', # save results to project/name\n exist_ok=False, # existing project/name ok, do not increment\n line_thickness=3, # bounding box thickness (pixels)\n hide_labels=False, # hide labels\n hide_conf=False, # hide confidences\n half=False, # use FP16 half-precision inference\n dnn=False, # use OpenCV DNN for ONNX inference\n ):\n source = str(source)\n save_img = not nosave and not source.endswith('.txt') # save inference images\n is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)\n is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://'))\n webcam = source.isnumeric() or source.endswith('.txt') or (is_url and not is_file)\n if is_url and is_file:\n source = check_file(source) # download\n\n # Directories\n save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run\n (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir\n\n # Load model\n device = select_device(device)\n model = DetectMultiBackend(weights, device=device, dnn=dnn)\n stride, names, pt, jit, onnx, engine = model.stride, model.names, model.pt, model.jit, model.onnx, model.engine\n imgsz = check_img_size(imgsz, s=stride) # check image size\n\n # Half\n half &= (pt or jit or engine) and device.type != 'cpu' # half precision only supported by PyTorch on CUDA\n if pt or jit:\n model.model.half() if half else model.model.float()\n\n # Dataloader\n if webcam:\n view_img = check_imshow()\n cudnn.benchmark = True # set True to speed up constant image size inference\n dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt)\n bs = len(dataset) # batch_size\n else:\n dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt)\n bs = 1 # batch_size\n vid_path, vid_writer = [None] * bs, [None] * bs\n\n # Run inference\n model.warmup(imgsz=(1, 3, *imgsz), half=half) # warmup\n dt, seen = [0.0, 0.0, 0.0], 0\n for path, im, im0s, vid_cap, s in dataset:\n t1 = time_sync()\n im = torch.from_numpy(im).to(device)\n im = im.half() if half else im.float() # uint8 to fp16/32\n im /= 255 # 0 - 255 to 0.0 - 1.0\n if len(im.shape) == 3:\n im = im[None] # expand for batch dim\n t2 = time_sync()\n dt[0] += t2 - t1\n\n # Inference\n visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False\n pred = model(im, augment=augment, visualize=visualize)\n t3 = time_sync()\n dt[1] += t3 - t2\n\n # NMS\n # pred: list*(n, [xylsθ, conf, cls]) θ ∈ [-pi/2, pi/2)\n pred = non_max_suppression_obb(pred, conf_thres, iou_thres, classes, agnostic_nms, multi_label=True, max_det=max_det)\n dt[2] += time_sync() - t3\n\n # Second-stage classifier (optional)\n # pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)\n\n # Process predictions\n for i, det in enumerate(pred): # per image\n pred_poly = rbox2poly(det[:, :5]) # (n, [x1 y1 x2 y2 x3 y3 x4 y4])\n seen += 1\n if webcam: # batch_size >= 1\n p, im0, frame = path[i], im0s[i].copy(), dataset.count\n s += f'{i}: '\n else:\n p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)\n\n p = Path(p) # to Path\n save_path = str(save_dir / p.name) # im.jpg\n txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # im.txt\n s += '%gx%g ' % im.shape[2:] # print string\n gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh\n imc = im0.copy() if save_crop else im0 # for save_crop\n annotator = Annotator(im0, line_width=line_thickness, example=str(names))\n if len(det):\n # Rescale polys from img_size to im0 size\n # det[:, :4] = scale_coords(im.shape[2:], det[:, :4], im0.shape).round()\n pred_poly = scale_polys(im.shape[2:], pred_poly, im0.shape)\n det = torch.cat((pred_poly, det[:, -2:]), dim=1) # (n, [poly conf cls])\n\n # Print results\n for c in det[:, -1].unique():\n n = (det[:, -1] == c).sum() # detections per class\n s += f\"{n} {names[int(c)]}{'s' * (n > 1)}, \" # add to string\n\n # Write results\n for *poly, conf, cls in reversed(det):\n if save_txt: # Write to file\n # xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh\n poly = poly.tolist()\n line = (cls, *poly, conf) if save_conf else (cls, *poly) # label format\n with open(txt_path + '.txt', 'a') as f:\n f.write(('%g ' * len(line)).rstrip() % line + '\\n')\n\n if save_img or save_crop or view_img: # Add poly to image\n c = int(cls) # integer class\n label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')\n # annotator.box_label(xyxy, label, color=colors(c, True))\n annotator.poly_label(poly, label, color=colors(c, True))\n if save_crop: # Yolov5-obb doesn't support it yet\n # save_one_box(xyxy, imc, file=save_dir / 'crops' / names[c] / f'{p.stem}.jpg', BGR=True)\n pass\n\n # Print time (inference-only)\n LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)')\n\n # Stream results\n im0 = annotator.result()\n if view_img:\n cv2.imshow(str(p), im0)\n cv2.waitKey(1) # 1 millisecond\n\n # Save results (image with detections)\n if save_img:\n if dataset.mode == 'image':\n cv2.imwrite(save_path, im0)\n else: # 'video' or 'stream'\n if vid_path[i] != save_path: # new video\n vid_path[i] = save_path\n if isinstance(vid_writer[i], cv2.VideoWriter):\n vid_writer[i].release() # release previous video writer\n if vid_cap: # video\n fps = vid_cap.get(cv2.CAP_PROP_FPS)\n w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))\n h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))\n else: # stream\n fps, w, h = 30, im0.shape[1], im0.shape[0]\n save_path += '.mp4'\n vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))\n vid_writer[i].write(im0)\n\n # Print results\n t = tuple(x / seen * 1E3 for x in dt) # speeds per image\n LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t)\n if save_txt or save_img:\n s = f\"\\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}\" if save_txt else ''\n LOGGER.info(f\"Results saved to {colorstr('bold', save_dir)}{s}\")\n if update:\n strip_optimizer(weights) # update model (to fix SourceChangeWarning)\n\n\ndef parse_opt():\n parser = argparse.ArgumentParser()\n parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs/train/yolov5n_DroneVehicle/weights/best.pt', help='model path(s)')\n parser.add_argument('--source', type=str, default='/media/test/4d846cae-2315-4928-8d1b-ca6d3a61a3c6/DroneVehicle/val/raw/images/', help='file/dir/URL/glob, 0 for webcam')\n parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[840], help='inference size h,w')\n parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')\n parser.add_argument('--iou-thres', type=float, default=0.2, help='NMS IoU threshold')\n parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')\n parser.add_argument('--device', default='3', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')\n parser.add_argument('--view-img', action='store_true', help='show results')\n parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')\n parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')\n parser.add_argument('--save-crop', action='store_true', help='save cropped prediction boxes')\n parser.add_argument('--nosave', action='store_true', help='do not save images/videos')\n parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')\n parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')\n parser.add_argument('--augment', action='store_true', help='augmented inference')\n parser.add_argument('--visualize', action='store_true', help='visualize features')\n parser.add_argument('--update', action='store_true', help='update all models')\n parser.add_argument('--project', default='runs/detect', help='save results to project/name')\n parser.add_argument('--name', default='exp', help='save results to project/name')\n parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')\n parser.add_argument('--line-thickness', default=2, type=int, help='bounding box thickness (pixels)')\n parser.add_argument('--hide-labels', default=False, action='store_true', help='hide labels')\n parser.add_argument('--hide-conf', default=False, action='store_true', help='hide confidences')\n parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')\n parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')\n opt = parser.parse_args()\n opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand"},"next_line":{"kind":"string","value":" print_args(FILE.stem, opt)"},"gold_snippet_index":{"kind":"number","value":14,"string":"14"},"created_at":{"kind":"string","value":"2023-10-31 06:06:41+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5691,"cells":{"repo_name":{"kind":"string","value":"serengil/LightPHE"},"file_path":{"kind":"string","value":"lightphe/models/Ciphertext.py"},"context":{"kind":"list like","value":[{"identifier":"Homomorphic","path":"lightphe/models/Homomorphic.py","snippet":"class Homomorphic(ABC):\n keys: dict\n plaintext_modulo: int\n ciphertext_modulo: int\n\n @abstractmethod\n def generate_keys(self, key_size: int, s: Optional[int] = None) -> dict:\n pass\n\n @abstractmethod\n def generate_random_key(self) -> int:\n pass\n\n @abstractmethod\n def encrypt(\n self, plaintext: int, random_key: Union[Optional[int], Optional[list]] = None\n ) -> Union[int, tuple, list]:\n pass\n\n @abstractmethod\n def decrypt(self, ciphertext: Union[int, tuple, list]) -> int:\n pass\n\n @abstractmethod\n def add(\n self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]\n ) -> Union[int, tuple, list]:\n pass\n\n @abstractmethod\n def multiply(\n self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]\n ) -> Union[int, tuple]:\n pass\n\n @abstractmethod\n def xor(self, ciphertext1: list, ciphertext2: list) -> list:\n pass\n\n @abstractmethod\n def multiply_by_contant(self, ciphertext: Union[int, tuple, list], constant: int) -> int:\n pass\n\n @abstractmethod\n def reencrypt(self, ciphertext: Union[int, tuple, list]) -> Union[int, tuple, list]:\n pass"},{"identifier":"Algorithm","path":"lightphe/models/Algorithm.py","snippet":"class Algorithm:\n RSA = \"RSA\"\n ElGamal = \"ElGamal\"\n ExponentialElGamal = \"Exponential-ElGamal\"\n EllipticCurveElGamal = \"EllipticCurve-ElGamal\"\n Paillier = \"Paillier\"\n DamgardJurik = \"Damgard-Jurik\"\n OkamotoUchiyama = \"Okamoto-Uchiyama\"\n Benaloh = \"Benaloh\"\n NaccacheStern = \"Naccache-Stern\"\n GoldwasserMicali = \"Goldwasser-Micali\""},{"identifier":"RSA","path":"lightphe/cryptosystems/RSA.py","snippet":"class RSA(Homomorphic):\n \"\"\"\n RSA algorithm is partially homomorphic with respect to the multiplication\n Ref: https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, key_size: int = 1024, encrypt_with_public=True):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits\n encrypt_with_public (boolean): RSA has two keys: private (d) and public (e).\n If you encrypt a message with smo's public, then just that person can decrypt it\n with his private (secure message). Otherwise, if you encrypt it with your private,\n one can decrypt it with your public (digital signatures).\n Set this arg to True if you want to do encryption with public key e,\n and do decryption with private key d.\n \"\"\"\n self.keys = keys or self.generate_keys(key_size)\n self.plaintext_modulo = self.keys[\"public_key\"][\"n\"]\n self.ciphertext_modulo = self.keys[\"public_key\"][\"n\"]\n self.encrypt_with_public = encrypt_with_public\n\n def generate_keys(self, key_size: int) -> dict:\n \"\"\"\n Generate public and private keys of RSA cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n while True:\n try:\n # picking a prime modulus p and q\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n n = p * q\n phi = (p - 1) * (q - 1)\n\n # select public exponent e\n while True:\n e = random.randint(1, phi - 1)\n if math.gcd(e, n) == 1:\n break\n\n d = pow(e, -1, phi)\n break\n except:\n pass\n\n keys[\"public_key\"][\"n\"] = n\n keys[\"public_key\"][\"e\"] = e\n keys[\"private_key\"][\"d\"] = d\n return keys\n\n def generate_random_key(self) -> int:\n pass\n\n def encrypt(self, plaintext: int) -> int:\n \"\"\"\n Encrypt plain messages with RSA\n Args:\n plaintext (int): plain message\n Returns:\n ciphertext (int): ciphertext encrypted with RSA\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n\n if plaintext > n:\n plaintext = plaintext % n\n logger.debug(\n f\"RSA can encrypt messages [1, {n}]. \"\n f\"Seems you exceeded this limit. New plaintext is {plaintext}\"\n )\n\n if self.encrypt_with_public is True:\n e = self.keys[\"public_key\"][\"e\"]\n c = pow(plaintext, e, n)\n else:\n d = self.keys[\"private_key\"][\"d\"]\n c = pow(plaintext, d, n)\n\n return c\n\n def decrypt(self, ciphertext: int) -> int:\n \"\"\"\n Decrypt ciphertexts with RSA\n Args:\n ciphertext (int): encrypted message\n decrypt_with_private (int): RSA has two keys: private (d) and public (e).\n If you encrypt a message with smo's public, then just that person can decrypt it\n with his private (secure message). Otherwise, if you encrypt it with your private,\n one can decrypt it with your public (digital signatures).\n Set this arg to True if you want to do encryption with public key e,\n and do decryption with private key d.\n Returns:\n plaintext (int): restored message\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n if self.encrypt_with_public is True:\n d = self.keys[\"private_key\"][\"d\"]\n p = pow(ciphertext, d, n)\n else:\n e = self.keys[\"public_key\"][\"e\"]\n p = pow(ciphertext, e, n)\n\n return p\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n \"\"\"\n Perform homomorphic multiplication on encrypted data.\n Result of this must be equal to E(m1 * m2)\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n return (ciphertext1 * ciphertext2) % n\n\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"RSA is not homomorphic with respect to the addition\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"RSA is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\n raise ValueError(\"RSA is not supporting multiplying ciphertext by a known constant\")\n\n def reencrypt(self, ciphertext: int) -> int:\n raise ValueError(\"RSA does not support re-encryption\")"},{"identifier":"ElGamal","path":"lightphe/cryptosystems/ElGamal.py","snippet":"class ElGamal(Homomorphic):\n \"\"\"\n ElGamal algorithm is either multiplicatively or additively homomorphic\n Ref: https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, exponential=False, key_size: int = 1024):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits\n exponential (boolean): set this to True to make cryptosystem exponential ElGamal.\n Regular ElGamal is homomorphic with respect to the multiplication whereas\n exponential ElGamal is homomorphic with respect to the addition\n \"\"\"\n self.exponential = exponential\n self.keys = keys or self.generate_keys(key_size)\n self.plaintext_modulo = self.keys[\"public_key\"][\"p\"]\n self.ciphertext_modulo = self.keys[\"public_key\"][\"p\"]\n\n def generate_keys(self, key_size: int):\n \"\"\"\n Generate public and private keys of ElGamal cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # picking a prime modulus p\n p = sympy.randprime(100, 2 ** int(key_size / 2) - 1)\n\n # picking a generator g\n g = random.randint(2, int(math.sqrt(p)))\n\n # picking a private key x\n x = random.randint(1, p - 2)\n\n # public key\n y = pow(g, x, p)\n\n keys[\"public_key\"] = {\n \"p\": p,\n \"g\": g,\n \"y\": y,\n }\n\n keys[\"private_key\"] = {\"x\": x}\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n ElGamal requires to generate one-time random key per encryption\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n p = self.keys[\"public_key\"][\"p\"]\n return random.randint(1, p - 1)\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> tuple:\n \"\"\"\n Encrypt plaintext with ElGamal\n Args:\n plaintext (int): message to encrypt\n random_key (int): random key for encryption. Do not set this to a static value.\n Returns\n ciphertext (tuple): c1 and c2\n \"\"\"\n p = self.keys[\"public_key\"][\"p\"]\n g = self.keys[\"public_key\"][\"g\"]\n y = self.keys[\"public_key\"][\"y\"]\n r = random_key or self.generate_random_key()\n\n if plaintext > p:\n plaintext = plaintext % p\n logger.debug(\n f\"ElGamal can encrypt messages [1, {p}]. \"\n f\"Seems you exceeded this limit. New plaintext is {plaintext}\"\n )\n\n c1 = pow(g, r, p)\n if self.exponential is False:\n c2 = (plaintext * pow(y, r, p)) % p\n else:\n c2 = (pow(g, plaintext, p) * pow(y, r, p)) % p\n\n return c1, c2\n\n def decrypt(self, ciphertext: tuple) -> int:\n \"\"\"\n Decrypt ciphertext with ElGamal\n Args:\n ciphertext (tuple): c1 and c2\n Returns:\n plaintext (int): restored message\n \"\"\"\n c1, c2 = ciphertext\n\n x = self.keys[\"private_key\"][\"x\"]\n p = self.keys[\"public_key\"][\"p\"]\n g = self.keys[\"public_key\"][\"g\"]\n\n m_prime = (c2 * pow(c1, -1 * x, p)) % p\n\n if self.exponential is False:\n return m_prime\n\n if self.exponential is True:\n # m_prime = g^m . Find m for known m_prime and known g (DLP).\n m = 0\n while True:\n if pow(g, m, p) == m_prime:\n return m\n m += 1\n if m > p:\n raise ValueError(f\"Cannot restore the message in [0, {p}]\")\n\n return -1\n\n def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\n \"\"\"\n Perform homomorphic multiplication on encrypted data\n Result of this must be equal to E(m1 * m2)\n Args:\n ciphertext1 (dict): ElGamal ciphertext consisting of c1 and c2 keys\n ciphertext2 (dict): ElGamal ciphertext consisting of c1 and c2 keys\n Returns\n ciphertext (dict): ElGamal ciphertext consisting of c1 and c2 keys\n \"\"\"\n if self.exponential is True:\n raise ValueError(\"Exponential ElGamal is not homomorphic with respect to the addition\")\n p = self.keys[\"public_key\"][\"p\"]\n return (ciphertext1[0] * ciphertext2[0]) % p, (ciphertext1[1] * ciphertext2[1]) % p\n\n def add(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\n \"\"\"\n Perform homomorphic addition on encrypted data\n Result of this must be equal to E(m1 + m2)\n Args:\n ciphertext1 (dict): ElGamal ciphertext consisting of c1 and c2 keys\n ciphertext2 (dict): ElGamal ciphertext consisting of c1 and c2 keys\n Returns\n ciphertext (dict): ElGamal ciphertext consisting of c1 and c2 keys\n \"\"\"\n if self.exponential is False:\n raise ValueError(\"Regular ElGamal is not homomorphic with respect to the addition\")\n p = self.keys[\"public_key\"][\"p\"]\n return (ciphertext1[0] * ciphertext2[0]) % p, (ciphertext1[1] * ciphertext2[1]) % p\n\n def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:\n raise ValueError(\"ElGamal is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: tuple, constant: int) -> tuple:\n if self.exponential is False:\n raise ValueError(\"ElGamal is not supporting multiplying ciphertext by a known constant\")\n p = self.keys[\"public_key\"][\"p\"]\n if constant > p:\n constant = constant % p\n logger.debug(\n f\"ElGamal can encrypt messages [1, {p}]. \"\n f\"Seems constant exceeded this limit. New constant is {constant}\"\n )\n\n return pow(ciphertext[0], constant, p), pow(ciphertext[1], constant, p)\n\n def reencrypt(self, ciphertext: tuple) -> tuple:\n \"\"\"\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\n Args:\n ciphertext (int): given ciphertext\n Returns:\n new ciphertext (int): different ciphertext for same plaintext\n \"\"\"\n if self.exponential is True:\n # then this is additively homomorphic\n neutral_element = 0\n else:\n # then this is multiplicatively homomorphic\n neutral_element = 1\n\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\n\n if self.exponential is True:\n reencrypted_value = self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\n else:\n reencrypted_value = self.multiply(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\n\n return reencrypted_value"},{"identifier":"Paillier","path":"lightphe/cryptosystems/Paillier.py","snippet":"class Paillier(Homomorphic):\n \"\"\"\n Paillier algorithm is homomorphic with respect to the addition.\n Also, it supports power operation for ciphertext base and plaintext exponent\n Ref: https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, key_size=1024):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits\n \"\"\"\n self.keys = keys or self.generate_keys(key_size)\n n = self.keys[\"public_key\"][\"n\"]\n self.plaintext_modulo = n\n self.ciphertext_modulo = n * n\n\n def generate_keys(self, key_size: int):\n \"\"\"\n Generate public and private keys of Paillier cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # picking a prime modulus p\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n # picking a prime modulus q\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n n = p * q\n phi = (p - 1) * (q - 1)\n g = 1 + n\n\n keys[\"private_key\"][\"phi\"] = phi\n keys[\"public_key\"][\"g\"] = g\n keys[\"public_key\"][\"n\"] = n\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Paillier requires to generate one-time random key per encryption\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n while True:\n r = random.randint(0, n)\n if math.gcd(r, n) == 1:\n break\n return r\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\n \"\"\"\n Encrypt a given plaintext for optionally given random key with Paillier\n Args:\n plaintext (int): message to encrypt\n random_key (int): Paillier requires a random key that co-prime to n.\n Random key will be generated automatically if you do not set this.\n Returns:\n ciphertext (int): encrypted message\n \"\"\"\n g = self.keys[\"public_key\"][\"g\"]\n n = self.keys[\"public_key\"][\"n\"]\n r = random_key or self.generate_random_key()\n assert math.gcd(r, n) == 1\n return (pow(g, plaintext, n * n) * pow(r, n, n * n)) % (n * n)\n\n def decrypt(self, ciphertext: int):\n \"\"\"\n Decrypt a given ciphertext with Paillier\n Args:\n ciphertext (int): encrypted message\n Returns:\n plaintext (int): restored message\n \"\"\"\n phi = self.keys[\"private_key\"][\"phi\"]\n n = self.keys[\"public_key\"][\"n\"]\n mu = pow(phi, -1, n)\n\n return (self.lx(pow(ciphertext, phi, n * n)) * mu) % (n)\n\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\n \"\"\"\n Perform homomorphic addition on encrypted data.\n Result of this must be equal to E(m1 + m2)\n Encryption calculations are done in module n squared.\n Args:\n ciphertext1 (int): 1st ciphertext created with Paillier\n ciphertext2 (int): 2nd ciphertext created with Paillier\n Returns:\n ciphertext3 (int): 3rd ciphertext created with Paillier\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n return (ciphertext1 * ciphertext2) % (n * n)\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Paillier is not homomorphic with respect to the multiplication\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Paillier is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\n \"\"\"\n Multiply a ciphertext with a plain constant.\n Result of this must be equal to E(m1 * m2) where E(m1) = ciphertext\n Encryption calculations are done in module n squared.\n Args:\n ciphertext (int): ciphertext created with Paillier\n constant (int): known plain constant\n Returns:\n ciphertext (int): new ciphertext created with Paillier\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n\n if constant > self.plaintext_modulo:\n constant = constant % self.plaintext_modulo\n logger.debug(\n f\"Paillier can encrypt messages [1, {n}]. \"\n f\"Seems constant exceeded this limit. New constant is {constant}\"\n )\n\n return pow(ciphertext, constant, n * n)\n\n def reencrypt(self, ciphertext: int) -> int:\n \"\"\"\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\n Args:\n ciphertext (int): given ciphertext\n Returns:\n new ciphertext (int): different ciphertext for same plaintext\n \"\"\"\n neutral_element = 0\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\n\n def lx(self, x: int) -> int:\n \"\"\"\n Find logarithm over cyclic group\n Args:\n x (int): some integer\n Returns:\n lx (int): (x-1) / n\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n y = (x - 1) // n\n assert y - int(y) == 0\n return int(y)"},{"identifier":"DamgardJurik","path":"lightphe/cryptosystems/DamgardJurik.py","snippet":"class DamgardJurik(Homomorphic):\n \"\"\"\n Damgard-Jurik algorithm is a generalization of Paillier.\n It is homomorphic with respect to the addition.\n Ref: https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/\n \"\"\"\n\n def __init__(self, s: int = 2, keys: Optional[dict] = None, key_size: int = 1024):\n \"\"\"\n Args:\n s (int): cryptosystem's module is going to be n^(s+1). if s == 1 then this is Paillier\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits\n \"\"\"\n self.keys = keys or self.generate_keys(key_size=key_size, s=s)\n n = self.keys[\"public_key\"][\"n\"]\n self.plaintext_modulo = n\n self.ciphertext_modulo = pow(n, s + 1)\n\n def generate_keys(self, key_size: int, s: Optional[int] = None):\n \"\"\"\n Generate public and private keys of Paillier cryptosystem\n Args:\n s (int): cryptosystem's module is going to be n^(s+1). if s == 1 then this is Paillier\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # picking a prime modulus p\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n # picking a prime modulus q\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n n = p * q\n phi = (p - 1) * (q - 1)\n g = 1 + n\n\n keys[\"private_key\"][\"phi\"] = phi\n keys[\"public_key\"][\"g\"] = g\n keys[\"public_key\"][\"n\"] = n\n keys[\"public_key\"][\"s\"] = s\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Paillier requires to generate one-time random key per encryption\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n while True:\n r = random.randint(0, n)\n if math.gcd(r, n) == 1:\n break\n return r\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\n \"\"\"\n Encrypt a given plaintext for optionally given random key with Paillier\n Args:\n plaintext (int): message to encrypt\n random_key (int): Paillier requires a random key that co-prime to n.\n Random key will be generated automatically if you do not set this.\n Returns:\n ciphertext (int): encrypted message\n \"\"\"\n g = self.keys[\"public_key\"][\"g\"]\n n = self.keys[\"public_key\"][\"n\"]\n s = self.keys[\"public_key\"][\"s\"]\n r = random_key or self.generate_random_key()\n modulo = pow(n, s + 1)\n\n # assert math.gcd(r, n) == 1\n c = (pow(g, plaintext, modulo) * pow(r, n, modulo)) % modulo\n # c = (pow(g, plaintext, modulo) * pow(r, pow(n, s), modulo)) % modulo\n if math.gcd(c, modulo) != 1:\n logger.info(f\"WARNING! gcd({c=}, {modulo=}) != 1\")\n return c\n\n def decrypt(self, ciphertext: int):\n \"\"\"\n Decrypt a given ciphertext with Paillier\n Args:\n ciphertext (int): encrypted message\n Returns:\n plaintext (int): restored message\n \"\"\"\n phi = self.keys[\"private_key\"][\"phi\"]\n n = self.keys[\"public_key\"][\"n\"]\n s = self.keys[\"public_key\"][\"s\"]\n mu = pow(phi, -1, n)\n modulo = pow(n, s + 1)\n return (self.lx(pow(ciphertext, phi, modulo)) * mu) % (n)\n\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\n \"\"\"\n Perform homomorphic addition on encrypted data.\n Result of this must be equal to E(m1 + m2)\n Encryption calculations are done in module n squared.\n Args:\n ciphertext1 (int): 1st ciphertext created with Paillier\n ciphertext2 (int): 2nd ciphertext created with Paillier\n Returns:\n ciphertext3 (int): 3rd ciphertext created with Paillier\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n s = self.keys[\"public_key\"][\"s\"]\n modulo = pow(n, s + 1)\n return (ciphertext1 * ciphertext2) % modulo\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Damgard-Jurik is not homomorphic with respect to the multiplication\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Damgard-Jurik is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\n \"\"\"\n Multiply a ciphertext by a known plain constant\n Result of this must be equal to E(m1 * m2), where E(m1) = ciphertext\n Encryption calculations are done in module n squared.\n Args:\n ciphertext (int): ciphertext created with Damgard-Jurik\n constant (int): a known plain constant\n Returns:\n ciphertext (int): new ciphertext created with Damgard-Jurik\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n if constant > self.plaintext_modulo:\n constant = constant % self.plaintext_modulo\n logger.debug(\n f\"Damgard-Jurik can encrypt messages [1, {n}]. \"\n f\"Seems constant exceeded this limit. New constant is {constant}\"\n )\n return pow(ciphertext, constant, self.ciphertext_modulo)\n\n def reencrypt(self, ciphertext: int) -> int:\n \"\"\"\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\n Args:\n ciphertext (int): given ciphertext\n Returns:\n new ciphertext (int): different ciphertext for same plaintext\n \"\"\"\n neutral_element = 0\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\n\n def lx(self, x: int) -> int:\n \"\"\"\n Find logarithm over cyclic group\n Args:\n x (int): some integer\n Returns:\n lx (int): (x-1) / n\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n y = (x - 1) // n\n assert y - int(y) == 0\n return int(y)"},{"identifier":"OkamotoUchiyama","path":"lightphe/cryptosystems/OkamotoUchiyama.py","snippet":"class OkamotoUchiyama(Homomorphic):\n \"\"\"\n Okamoto-Uchiyama algorithm is homomorphic with respect to the addition.\n Ref: https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, key_size=1024):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits\n \"\"\"\n self.keys = keys or self.generate_keys(key_size)\n self.plaintext_modulo = self.keys[\"private_key\"][\"p\"]\n self.ciphertext_modulo = self.keys[\"public_key\"][\"n\"]\n\n def generate_keys(self, key_size: int) -> dict:\n \"\"\"\n Generate public and private keys of OkamotoUchiyama cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # picking a prime modulus p\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n # picking a prime modulus q\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n # modulo\n n = p * p * q\n\n # generator\n g = random.randint(2, n)\n\n if pow(g, p - 1, p * p) == 1:\n raise ValueError(\"Fermat's Little Theorem must be satisfied\")\n\n h = pow(g, n, n)\n\n keys[\"public_key\"][\"n\"] = n\n keys[\"public_key\"][\"g\"] = g\n keys[\"public_key\"][\"h\"] = h\n keys[\"private_key\"][\"p\"] = p\n keys[\"private_key\"][\"q\"] = q\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Okamoto-Uchiyama requires to generate one-time random key per encryption\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n return random.randint(1, n - 1)\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\n \"\"\"\n Encrypt a given plaintext for optionally given random key with OkamotoUchiyama\n Args:\n plaintext (int): message to encrypt\n random_key (int): OkamotoUchiyama requires a random key\n Random key will be generated automatically if you do not set this.\n Returns:\n ciphertext (int): encrypted message\n \"\"\"\n p = self.keys[\"private_key\"][\"p\"]\n g = self.keys[\"public_key\"][\"g\"]\n n = self.keys[\"public_key\"][\"n\"]\n h = self.keys[\"public_key\"][\"h\"]\n r = random_key or self.generate_random_key()\n\n if plaintext > p:\n plaintext = plaintext % p\n logger.debug(\n f\"plaintext must be in scale [0, {p=}] but this is exceeded.\"\n \"New plaintext is {plaintext}\"\n )\n return (pow(g, plaintext, n) * pow(h, r, n)) % n\n\n def decrypt(self, ciphertext: int):\n \"\"\"\n Decrypt a given ciphertext with Okamoto-Uchiyama\n Args:\n ciphertext (int): encrypted message\n Returns:\n plaintext (int): restored message\n \"\"\"\n p = self.keys[\"private_key\"][\"p\"]\n g = self.keys[\"public_key\"][\"g\"]\n\n a = self.lx(pow(ciphertext, p - 1, p * p))\n b = self.lx(pow(g, p - 1, p * p))\n return (a * pow(b, -1, p)) % p\n\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\n \"\"\"\n Perform homomorphic addition on encrypted data.\n Result of this must be equal to E(m1 + m2)\n Encryption calculations are done in module n\n Args:\n ciphertext1 (int): 1st ciphertext created with OkamotoUchiyama\n ciphertext2 (int): 2nd ciphertext created with OkamotoUchiyama\n Returns:\n ciphertext3 (int): 3rd ciphertext created with OkamotoUchiyama\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n return (ciphertext1 * ciphertext2) % n\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Okamoto-Uchiyama is not homomorphic with respect to the multiplication\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Okamoto-Uchiyama is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\n \"\"\"\n Multiply a ciphertext with a plain constant.\n Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext\n Encryption calculations are done in module n squared.\n Args:\n ciphertext (int): ciphertext created with Okamoto-Uchiyama\n constant (int): known plain constant\n Returns:\n ciphertext (int): new ciphertext created with Okamoto-Uchiyama\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n if constant > self.plaintext_modulo:\n constant = constant % self.plaintext_modulo\n logger.debug(\n f\"Okamoto-Uchiyama can encrypt messages [1, {n}]. \"\n f\"Seems constant exceeded this limit. New constant is {constant}\"\n )\n return pow(ciphertext, constant, n)\n\n def reencrypt(self, ciphertext: int) -> int:\n \"\"\"\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\n Args:\n ciphertext (int): given ciphertext\n Returns:\n new ciphertext (int): different ciphertext for same plaintext\n \"\"\"\n neutral_element = 0\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\n\n def lx(self, x: int) -> int:\n \"\"\"\n Find logarithm over cyclic group\n Args:\n x (int): some integer\n Returns:\n lx (int): (x-1) / p\n \"\"\"\n p = self.keys[\"private_key\"][\"p\"]\n if x % p != 1:\n raise ValueError(f\"Input passed to lx ({x}) must be identical to 1 in modulo {p}\")\n if math.gcd(x, p * p) != 1:\n raise ValueError(f\"gcd({x}, {p}^2) must be equal to 1\")\n y = (x - 1) // p\n assert y - int(y) == 0\n return int(y)"},{"identifier":"Benaloh","path":"lightphe/cryptosystems/Benaloh.py","snippet":"class Benaloh(Homomorphic):\n def __init__(self, keys: Optional[dict] = None, key_size: int = 50):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits. default is less than other cryptosystems\n because decryption of Benaloh requires to solve DLP :/\n \"\"\"\n self.keys = keys or self.generate_keys(key_size)\n self.plaintext_modulo = self.keys[\"public_key\"][\"r\"]\n self.ciphertext_modulo = self.keys[\"public_key\"][\"n\"]\n\n def generate_keys(self, key_size: int) -> dict:\n \"\"\"\n Generate public and private keys of Paillier cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n x = 1\n while x == 1:\n # picking a prime p\n p = sympy.randprime(200, 2**key_size)\n\n # picking a prime q\n q = sympy.randprime(100, p)\n\n n = p * q\n phi = (p - 1) * (q - 1)\n\n r = p - 1\n while gcd(q - 1, r) != 1:\n r = int(r / gcd(q - 1, r))\n\n if not (\n # r should divide p-1 without remainder\n (p - 1) % r == 0\n # r and (p - 1) / r must be coprimes\n and gcd(r, int((p - 1) / r)) == 1\n # r and q-1 must be coprimes\n and gcd(r, q - 1) == 1\n ):\n continue\n\n y = random.randint(2, n)\n if gcd(y, n) != 1:\n continue\n\n # to guarantee correct decryption\n prime_factors = sympy.factorint(r).keys()\n decryption_guaranteed = True\n for prime_factor in prime_factors:\n # none of r's prime factor should satisfy the condition\n if pow(y, int(phi / prime_factor), n) == 1:\n decryption_guaranteed = False\n\n if decryption_guaranteed is False:\n continue\n\n x = pow(y, int(phi / r), n)\n if x != 1:\n break\n\n keys[\"public_key\"][\"y\"] = y\n keys[\"public_key\"][\"r\"] = r\n keys[\"public_key\"][\"n\"] = n\n\n keys[\"private_key\"][\"p\"] = p\n keys[\"private_key\"][\"q\"] = q\n keys[\"private_key\"][\"phi\"] = phi\n keys[\"private_key\"][\"x\"] = x\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Generate random key for encryption\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n while True:\n u = random.randint(1, n)\n if gcd(u, n) == 1:\n break\n return u\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\n \"\"\"\n Encrypt a given plaintext for optionally given random key with Benaloh\n Args:\n plaintext (int): message to encrypt\n random_key (int): Benaloh requires a random key\n Random key will be generated automatically if you do not set this.\n Returns:\n ciphertext (int): encrypted message\n \"\"\"\n y = self.keys[\"public_key\"][\"y\"]\n r = self.keys[\"public_key\"][\"r\"]\n n = self.keys[\"public_key\"][\"n\"]\n\n u = random_key or self.generate_random_key()\n\n if plaintext > r:\n plaintext = plaintext % r\n logger.debug(\n f\"Benaloh lets you to encrypt messages in [0, {r=}].\"\n f\"But your plaintext exceeds this limit.\"\n f\"New plaintext is {plaintext}\"\n )\n\n c = (pow(y, plaintext, n) * pow(u, r, n)) % n\n\n if gcd(c, n) != 1:\n logger.debug(\"ciphertext is not co-prime with n!\")\n\n return c\n\n def decrypt(self, ciphertext: int) -> int:\n \"\"\"\n Decrypt a given ciphertext with Benaloh\n Args:\n ciphertext (int): encrypted message\n Returns:\n plaintext (int): restored message\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n r = self.keys[\"public_key\"][\"r\"]\n phi = self.keys[\"private_key\"][\"phi\"]\n x = self.keys[\"private_key\"][\"x\"]\n\n a = pow(ciphertext, int(phi / r), n)\n\n md = 0\n while True:\n if pow(x, md, n) == a:\n break\n md = md + 1\n if md > r:\n raise ValueError(f\"Message cannot be restored in [{0}, {n}]\")\n return md\n\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\n \"\"\"\n Perform homomorphic addition on encrypted data.\n Result of this must be equal to E(m1 + m2)\n Encryption calculations are done in module n\n Args:\n ciphertext1 (int): 1st ciphertext created with Benaloh\n ciphertext2 (int): 2nd ciphertext created with Benaloh\n Returns:\n ciphertext3 (int): 3rd ciphertext created with Benaloh\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n return (ciphertext1 * ciphertext2) % n\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Benaloh is not homomorphic with respect to the multiplication\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Benaloh is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\n \"\"\"\n Multiply a ciphertext with a plain constant.\n Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext\n Encryption calculations are done in module n squared.\n Args:\n ciphertext (int): ciphertext created with Benaloh\n constant (int): known plain constant\n Returns:\n ciphertext (int): new ciphertext created with Benaloh\n \"\"\"\n # raise ValueError(\"Benaloh is not supporting multiplying by a constant\")\n n = self.keys[\"public_key\"][\"n\"]\n if constant > self.plaintext_modulo:\n constant = constant % self.plaintext_modulo\n logger.debug(\n f\"Benaloh can encrypt messages [1, {self.plaintext_modulo}]. \"\n f\"Seems constant exceeded this limit. New constant is {constant}\"\n )\n return pow(ciphertext, constant, n)\n\n def reencrypt(self, ciphertext: int) -> int:\n \"\"\"\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\n Args:\n ciphertext (int): given ciphertext\n Returns:\n new ciphertext (int): different ciphertext for same plaintext\n \"\"\"\n neutral_element = 0\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)"},{"identifier":"NaccacheStern","path":"lightphe/cryptosystems/NaccacheStern.py","snippet":"class NaccacheStern(Homomorphic):\n \"\"\"\n Naccache-Stern algorithm is homomorphic with respect to the addition.\n It is a generaliation of Benaloh cryptosystem\n Ref: https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/\n Original paper: https://dl.acm.org/doi/pdf/10.1145/288090.288106\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, key_size=37, deterministic: bool = False):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits. Less than many cryptosystems because\n decryption requires to solve DLP.\n deterministic (boolean): deterministic or probabilistic version of\n cryptosystem\n \"\"\"\n self.keys = keys or self.generate_keys(key_size)\n self.plaintext_modulo = self.keys[\"public_key\"][\"sigma\"]\n self.ciphertext_modulo = self.keys[\"public_key\"][\"n\"]\n self.deterministic = deterministic\n\n def generate_keys(self, key_size: int) -> dict:\n \"\"\"\n Generate public and private keys of Naccache-Stern cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # pick a family of small primes. the largest one is 10-bits\n # TODO: do something generic instead of constant primes\n prime_set = [3, 5, 7, 11, 13, 17]\n k = len(prime_set)\n\n if all(sympy.isprime(prime) is True for prime in prime_set) is False:\n raise ValueError(\"All items of prime set must be prime!\")\n\n # divide the set in half and find products of primes\n u = 1\n v = 1\n\n for i, prime in enumerate(prime_set):\n if i < len(prime_set) / 2:\n u = u * prime\n else:\n v = v * prime\n\n # product of all primes\n sigma = u * v\n\n # pick large prime numbers\n while True:\n a = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n b = sympy.randprime(100, a)\n\n # calculate two primes from chosen ones\n p = (2 * a * u) + 1\n q = (2 * b * v) + 1\n\n # recommended n is 768 bits\n n = p * q\n phi = (p - 1) * (q - 1)\n\n if phi % sigma != 0:\n logger.debug(\"canceled because phi cannot be divisible by sigma\")\n continue\n\n if math.gcd(sigma, int(phi // sigma)) != 1:\n logger.debug(\"canceled because sigma and phi/sigma are not coprime\")\n continue\n\n p_conditions = []\n for i in range(0, int(k / 2)):\n pi = prime_set[i]\n if (\n (p - 1) % pi == 0\n and math.gcd(pi, int((p - 1) / pi)) == 1\n and math.gcd(pi, q - 1) == 1\n ):\n p_conditions.append(1)\n else:\n p_conditions.append(0)\n p_satisfied = True if len(p_conditions) == sum(p_conditions) else False\n if p_satisfied is False:\n logger.debug(\"canceled because p_conditions are not satisfied\")\n continue\n\n q_conditions = []\n for i in range(int(k / 2), k):\n pi = prime_set[i]\n if (\n (q - 1) % pi == 0\n and math.gcd(pi, int((q - 1) / pi)) == 1\n and math.gcd(pi, p - 1)\n ):\n q_conditions.append(1)\n else:\n q_conditions.append(0)\n\n q_satisfied = True if len(q_conditions) == sum(q_conditions) else False\n if q_satisfied is False:\n logger.debug(\"canceled because q_conditions are not satisfied\")\n continue\n\n # p and q must be primes\n if not (sympy.isprime(p) and sympy.isprime(q)):\n continue\n\n # choose a generator g\n g = random.randint(2, n)\n # it must be co-prime to n\n if math.gcd(g, n) != 1:\n logger.debug(\"canceled becuase g is not co-prime with ne\")\n continue\n # guarantee it is not pi-th power.\n for pi in prime_set:\n logger.debug(\"canceled because g is a pi-th power\")\n if pow(g, int(phi / pi), n) == 1:\n continue\n\n # the order of g modulo n must be phi/4\n if pow(g, int(phi / 4), n) != 1:\n continue\n\n # check decryption is guaranteed similar to benaloh\n # ps: this is not mentioned in the original paper\n is_decryption_guaranteed = True\n for pi in prime_set:\n prime_factors = sympy.factorint(pi).keys()\n for prime_factor in prime_factors:\n if pow(g, int(phi / prime_factor), n) == 1:\n is_decryption_guaranteed = False\n if is_decryption_guaranteed is True:\n break\n\n logger.debug(f\"n bits is {len(bin(n)[2:])}\")\n\n keys[\"public_key\"][\"g\"] = g\n keys[\"public_key\"][\"n\"] = n\n # sigma can optionally be secret in deterministic version\n keys[\"public_key\"][\"sigma\"] = sigma\n\n keys[\"private_key\"][\"p\"] = p\n keys[\"private_key\"][\"q\"] = q\n keys[\"private_key\"][\"phi\"] = phi\n keys[\"private_key\"][\"prime_set\"] = prime_set\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Naccache-Stern requires to generate one-time random key per encryption\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n return random.randint(1, n - 1)\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\n \"\"\"\n Encrypt a given plaintext for optionally given random key with Naccache-Stern\n Args:\n plaintext (int): message to encrypt\n random_key (int): Naccache-Stern requires a random key\n Random key will be generated automatically if you do not set this.\n Returns:\n ciphertext (int): encrypted message\n \"\"\"\n g = self.keys[\"public_key\"][\"g\"]\n n = self.keys[\"public_key\"][\"n\"]\n r = random_key or self.generate_random_key()\n sigma = self.keys[\"public_key\"][\"sigma\"]\n if plaintext > self.plaintext_modulo:\n plaintext = plaintext % self.plaintext_modulo\n logger.debug(\n f\"plaintext must be in scale [0, {self.plaintext_modulo}] \"\n \"but this is exceeded. New plaintext is {plaintext}\"\n )\n\n if self.deterministic is True:\n return pow(g, plaintext, n)\n\n # Probabilistic\n return (pow(r, sigma, n) * pow(g, plaintext, n)) % n\n\n def decrypt(self, ciphertext: int):\n \"\"\"\n Decrypt a given ciphertext with Naccache-Stern\n Args:\n ciphertext (int): encrypted message\n Returns:\n plaintext (int): restored message\n \"\"\"\n phi = self.keys[\"private_key\"][\"phi\"]\n n = self.keys[\"public_key\"][\"n\"]\n g = self.keys[\"public_key\"][\"g\"]\n prime_set = self.keys[\"private_key\"][\"prime_set\"]\n\n remainders = []\n for i, prime in enumerate(prime_set):\n ci = pow(ciphertext, int(phi / prime), n)\n logger.debug(f\"c_{i} = {ci}\")\n\n j = 0\n while True:\n if ci == pow(g, int((j * phi) / prime), n):\n logger.debug(f\"m_{i} = {j}\")\n remainders.append(j)\n break\n j = j + 1\n if j > prime**2:\n raise ValueError(\n f\"c_{i} cannot be restored from {ci} = {g}^(j*{phi}/{prime}) mod {n}\"\n )\n\n congruences = []\n for i in range(0, len(prime_set)):\n logger.debug(f\"m mod {prime_set[i]} = {remainders[i]}\")\n congruences.append((remainders[i], prime_set[i]))\n\n # chinese remainder problem\n ms = solve_congruence(*congruences)\n if not ms:\n raise ValueError(\"message cannot be restored with Chinese Remainder!\")\n return ms[0]\n\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\n \"\"\"\n Perform homomorphic addition on encrypted data.\n Result of this must be equal to E(m1 + m2)\n Encryption calculations are done in module n\n Args:\n ciphertext1 (int): 1st ciphertext created with Naccache-Stern\n ciphertext2 (int): 2nd ciphertext created with Naccache-Stern\n Returns:\n ciphertext3 (int): 3rd ciphertext created with Naccache-Stern\n \"\"\"\n return (ciphertext1 * ciphertext2) % self.ciphertext_modulo\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Naccache-Stern is not homomorphic with respect to the multiplication\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Naccache-Stern is not homomorphic with respect to the exclusive or\")\n\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\n \"\"\"\n Multiply a ciphertext with a plain constant.\n Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext\n Encryption calculations are done in module n squared.\n Args:\n ciphertext (int): ciphertext created with Naccache-Stern\n constant (int): known plain constant\n Returns:\n ciphertext (int): new ciphertext created with Naccache-Stern\n \"\"\"\n if constant > self.plaintext_modulo:\n constant = constant % self.plaintext_modulo\n logger.debug(\n f\"Naccache-Stern can encrypt messages [1, {self.plaintext_modulo}]. \"\n f\"Seems constant exceeded this limit. New constant is {constant}\"\n )\n\n return pow(ciphertext, constant, self.ciphertext_modulo)\n\n def reencrypt(self, ciphertext: int) -> int:\n \"\"\"\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\n Args:\n ciphertext (int): given ciphertext\n Returns:\n new ciphertext (int): different ciphertext for same plaintext\n \"\"\"\n if self.deterministic is True:\n raise ValueError(\n \"Deterministic version of Naccache-Stern does not support reencryption.\"\n \"If you still want to perform ciphertext regeneration, then you may \"\n \"consider to use its probabilistic version.\"\n )\n neutral_element = 0\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)"},{"identifier":"GoldwasserMicali","path":"lightphe/cryptosystems/GoldwasserMicali.py","snippet":"class GoldwasserMicali(Homomorphic):\n \"\"\"\n Goldwasser-Micali algorithm is homomorphic with respect to the Exclusively OR (XOR).\n Ref: https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, key_size=100):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits\n \"\"\"\n self.keys = keys or self.generate_keys(key_size)\n self.ciphertext_modulo = self.keys[\"public_key\"][\"n\"]\n # TODO: not sure about the plaintext modulo\n self.plaintext_modulo = self.keys[\"public_key\"][\"n\"]\n\n def generate_keys(self, key_size: int) -> dict:\n \"\"\"\n Generate public and private keys of Goldwasser-Micali cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # picking a prime p\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n # picking a prime q\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\n\n n = p * q\n\n # find non-residue x\n while True:\n x = random.randint(1, n - 1)\n if math.gcd(x, n) == 1 and jacobi_symbol(x, p) == -1 and jacobi_symbol(x, q) == -1:\n break\n\n keys[\"public_key\"][\"n\"] = n\n keys[\"public_key\"][\"x\"] = x\n\n keys[\"private_key\"][\"p\"] = p\n keys[\"private_key\"][\"q\"] = q\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Goldwasser-Micali requires to generate one-time random key that co-prime to n\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n while True:\n r = random.randint(1, n)\n if math.gcd(r, n) == 1:\n break\n return r\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> list:\n \"\"\"\n Encrypt a given plaintext for optionally given random key with Goldwasser-Micali\n Args:\n plaintext (int): message to encrypt\n random_key (int): Goldwasser-Micali requires a random key\n Random key will be generated automatically if you do not set this.\n Returns:\n ciphertext (int): encrypted message\n \"\"\"\n n = self.keys[\"public_key\"][\"n\"]\n x = self.keys[\"public_key\"][\"x\"]\n\n m_binary = bin(plaintext)[2:]\n\n # number of bits\n k = len(m_binary)\n\n if random_key and len(random_key) != k:\n raise ValueError(f\"Random key must be length of {k}\")\n\n c = []\n for i in range(0, k):\n mi = int(m_binary[i])\n\n if random_key:\n ri = random_key[i]\n else:\n ri = self.generate_random_key()\n\n ci = (pow(ri, 2, n) * pow(x, mi, n)) % n\n c.append(ci)\n\n return c\n\n def decrypt(self, ciphertext: list) -> int:\n \"\"\"\n Decrypt a given ciphertext with Goldwasser-Micali\n Args:\n ciphertext (int): encrypted message\n Returns:\n plaintext (int): restored message\n \"\"\"\n m_binaries = []\n\n p = self.keys[\"private_key\"][\"p\"]\n q = self.keys[\"private_key\"][\"q\"]\n\n for i in ciphertext:\n xp = i % p\n xq = i % q\n\n if pow(xp, int((p - 1) / 2), p) == 1 and pow(xq, int((q - 1) / 2), q) == 1:\n m_binaries.append(\"0\")\n else:\n m_binaries.append(\"1\")\n\n m_binary = \"\".join(m_binaries)\n return int(m_binary, 2)\n\n def add(self, ciphertext1: list, ciphertext2: list) -> list:\n raise ValueError(\"Goldwasser-Micali is not homomorphic with respect to the addition\")\n\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\n raise ValueError(\"Goldwasser-Micali is not homomorphic with respect to the multiplication\")\n\n def xor(self, ciphertext1: int, ciphertext2: int) -> list:\n \"\"\"\n Perform homomorphic xor on encrypted data.\n Result of this must be equal to E(m1 ^ m2) = E(m1) ^ E(m2)\n Encryption calculations are done in module n\n Args:\n ciphertext1 (int): 1st ciphertext created with Goldwasser-Micali\n ciphertext2 (int): 2nd ciphertext created with Goldwasser-Micali\n Returns:\n ciphertext3 (int): 3rd ciphertext created with Goldwasser-Micali\n \"\"\"\n ciphertext3 = []\n for i in range(0, len(ciphertext1)):\n c1 = ciphertext1[i]\n c2 = ciphertext2[i]\n ciphertext3.append((c1 * c2) % self.ciphertext_modulo)\n\n return ciphertext3\n\n def multiply_by_contant(self, ciphertext: int, constant: int):\n raise ValueError(\"Goldwasser-Micali does not support multiplying with constant\")\n\n def reencrypt(self, ciphertext: int):\n raise ValueError(\"Goldwasser-Micali does not support re-encryption\")"},{"identifier":"EllipticCurveElGamal","path":"lightphe/cryptosystems/EllipticCurveElGamal.py","snippet":"class EllipticCurveElGamal(Homomorphic):\n \"\"\"\n Elliptic Curve ElGamal algorithm is an additively homomorphic algorithm\n Unluckily, it requires to solve (EC)DLP to restore plaintext in decryption\n However it is easy to restore plaintext while plaintext is not very large\n unsimilar to Benaloh or Naccache-Stern\n Ref: https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/\n \"\"\"\n\n def __init__(self, keys: Optional[dict] = None, key_size: int = 160):\n \"\"\"\n Args:\n keys (dict): private - public key pair.\n set this to None if you want to generate random keys.\n key_size (int): key size in bits. default is 160.\n this is equivalent to 1024 bit RSA.\n \"\"\"\n # TODO: add different forms and curves. e.g. Koblitz, Edwards (Ed25519)\n self.curve = Weierstrass()\n self.keys = keys or self.generate_keys(key_size)\n self.plaintext_modulo = self.curve.p\n self.ciphertext_modulo = self.curve.p\n\n def generate_keys(self, key_size: int):\n \"\"\"\n Generate public and private keys of Elliptic Curve ElGamal cryptosystem\n Args:\n key_size (int): key size in bits\n Returns:\n keys (dict): having private_key and public_key keys\n \"\"\"\n keys = {}\n keys[\"private_key\"] = {}\n keys[\"public_key\"] = {}\n\n # private key\n ka = random.getrandbits(key_size)\n\n # public key\n Qa = self.curve.apply_double_and_add_method(G=self.curve.G, k=ka, p=self.curve.p)\n\n keys[\"public_key\"][\"Qa\"] = Qa\n keys[\"private_key\"][\"ka\"] = ka\n\n return keys\n\n def generate_random_key(self) -> int:\n \"\"\"\n Elliptic Curve ElGamal requires to generate one-time random key per encryption\n Returns:\n random key (int): one time random key for encryption\n \"\"\"\n return random.getrandbits(128)\n\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> tuple:\n \"\"\"\n Encrypt plaintext with Elliptic Curve ElGamal\n Args:\n plaintext (int): message to encrypt\n random_key (int): random key for encryption. Do not set this to a static value.\n Returns\n ciphertext (tuple): c1 and c2\n \"\"\"\n # modulo\n p = self.curve.p\n\n # base point\n G = self.curve.G\n\n # public key\n Qa = self.keys[\"public_key\"][\"Qa\"]\n\n # random key\n r = random_key or self.generate_random_key()\n\n s = self.curve.apply_double_and_add_method(G=G, k=plaintext, p=p)\n\n c1 = self.curve.apply_double_and_add_method(G=G, k=r, p=p)\n\n c2 = self.curve.apply_double_and_add_method(G=Qa, k=r, p=p)\n c2 = self.curve.add_points(c2, s, p)\n\n return c1, c2\n\n def decrypt(self, ciphertext: tuple) -> int:\n \"\"\"\n Decrypt ciphertext with Elliptic Curve ElGamal\n Args:\n ciphertext (tuple): c1 and c2\n Returns:\n plaintext (int): restored message\n \"\"\"\n # modulo\n p = self.curve.p\n\n # private key\n ka = self.keys[\"private_key\"][\"ka\"]\n\n c1, c2 = ciphertext\n c1_prime = (c1[0], (-1 * c1[1]) % p)\n s_prime = self.curve.apply_double_and_add_method(G=c1_prime, k=ka, p=p)\n s_prime = self.curve.add_points(P=c2, Q=s_prime, p=p)\n\n # s_prime is a point on the elliptic curve\n # s_prime = k x G\n # we need to find k from known s_prime and G\n # this requires to solve ECDLP\n\n # base point\n G = self.curve.G\n k = 2\n while True:\n G = self.curve.add_points(P=G, Q=self.curve.G, p=p)\n if G[0] == s_prime[0] and G[1] == s_prime[1]:\n return k\n k = k + 1\n if k > self.curve.n:\n raise ValueError(f\"Cannot restore scalar from {s_prime} = k x {self.curve.G}\")\n\n def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\n raise ValueError(\n \"Elliptic Curve ElGamal is not homomorphic with respect to the multiplication\"\n )\n\n def add(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\n \"\"\"\n Perform homomorphic addition on encrypted data\n Result of this must be equal to E(m1 + m2)\n Args:\n ciphertext1 (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys\n ciphertext2 (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys\n Returns\n ciphertext (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys\n \"\"\"\n a = self.curve.add_points(P=ciphertext1[0], Q=ciphertext2[0], p=self.curve.p)\n b = self.curve.add_points(P=ciphertext1[1], Q=ciphertext2[1], p=self.curve.p)\n return a, b\n\n def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:\n raise ValueError(\n \"Elliptic Curve ElGamal is not homomorphic with respect to the exclusive or\"\n )\n\n def multiply_by_contant(self, ciphertext: tuple, constant: int) -> tuple:\n \"\"\"\n Multiply a ciphertext with a plain constant.\n Result of this must be equal to k x E(m1) = E(m1 * k)\n where E(m1) = ciphertext\n Args:\n ciphertext (int): ciphertext created with Elliptic Curve ElGamal\n constant (int): known plain constant\n Returns:\n ciphertext (int): new ciphertext created with Elliptic Curve ElGamal\n \"\"\"\n return self.curve.apply_double_and_add_method(\n G=ciphertext[0], k=constant, p=self.curve.p\n ), self.curve.apply_double_and_add_method(G=ciphertext[1], k=constant, p=self.curve.p)\n\n def reencrypt(self, ciphertext: tuple) -> tuple:\n raise ValueError(\"Elliptic Curve ElGamal does not support regeneration of ciphertext\")"},{"identifier":"phe_utils","path":"lightphe/commons/phe_utils.py","snippet":"def parse_int(value: Union[int, float], modulo: int) -> int:\ndef fractionize(value: float, modulo: int, precision: Optional[int] = None) -> Tuple[int, int]:\ndef solve_dlp():"},{"identifier":"Logger","path":"lightphe/commons/logger.py","snippet":"class Logger:\n def __init__(self, module):\n self.module = module\n log_level = os.environ.get(\"LIGHTPHE_LOG_LEVEL\", str(logging.INFO))\n try:\n self.log_level = int(log_level)\n except Exception as err:\n self.dump_log(\n f\"Exception while parsing $LIGHTPHE_LOG_LEVEL.\"\n f\"Expected int but it is {log_level} ({str(err)})\"\n )\n self.log_level = logging.INFO\n\n def info(self, message):\n if self.log_level <= logging.INFO:\n self.dump_log(message)\n\n def debug(self, message):\n if self.log_level <= logging.DEBUG:\n self.dump_log(f\"🕷️ {message}\")\n\n def warn(self, message):\n if self.log_level <= logging.WARNING:\n self.dump_log(f\"⚠️ {message}\")\n\n def error(self, message):\n if self.log_level <= logging.ERROR:\n self.dump_log(f\"🔴 {message}\")\n\n def critical(self, message):\n if self.log_level <= logging.CRITICAL:\n self.dump_log(f\"💥 {message}\")\n\n def dump_log(self, message):\n print(f\"{str(datetime.now())[2:-7]} - {message}\")"}],"string":"[\n {\n \"identifier\": \"Homomorphic\",\n \"path\": \"lightphe/models/Homomorphic.py\",\n \"snippet\": \"class Homomorphic(ABC):\\n keys: dict\\n plaintext_modulo: int\\n ciphertext_modulo: int\\n\\n @abstractmethod\\n def generate_keys(self, key_size: int, s: Optional[int] = None) -> dict:\\n pass\\n\\n @abstractmethod\\n def generate_random_key(self) -> int:\\n pass\\n\\n @abstractmethod\\n def encrypt(\\n self, plaintext: int, random_key: Union[Optional[int], Optional[list]] = None\\n ) -> Union[int, tuple, list]:\\n pass\\n\\n @abstractmethod\\n def decrypt(self, ciphertext: Union[int, tuple, list]) -> int:\\n pass\\n\\n @abstractmethod\\n def add(\\n self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]\\n ) -> Union[int, tuple, list]:\\n pass\\n\\n @abstractmethod\\n def multiply(\\n self, ciphertext1: Union[int, tuple, list], ciphertext2: Union[int, tuple, list]\\n ) -> Union[int, tuple]:\\n pass\\n\\n @abstractmethod\\n def xor(self, ciphertext1: list, ciphertext2: list) -> list:\\n pass\\n\\n @abstractmethod\\n def multiply_by_contant(self, ciphertext: Union[int, tuple, list], constant: int) -> int:\\n pass\\n\\n @abstractmethod\\n def reencrypt(self, ciphertext: Union[int, tuple, list]) -> Union[int, tuple, list]:\\n pass\"\n },\n {\n \"identifier\": \"Algorithm\",\n \"path\": \"lightphe/models/Algorithm.py\",\n \"snippet\": \"class Algorithm:\\n RSA = \\\"RSA\\\"\\n ElGamal = \\\"ElGamal\\\"\\n ExponentialElGamal = \\\"Exponential-ElGamal\\\"\\n EllipticCurveElGamal = \\\"EllipticCurve-ElGamal\\\"\\n Paillier = \\\"Paillier\\\"\\n DamgardJurik = \\\"Damgard-Jurik\\\"\\n OkamotoUchiyama = \\\"Okamoto-Uchiyama\\\"\\n Benaloh = \\\"Benaloh\\\"\\n NaccacheStern = \\\"Naccache-Stern\\\"\\n GoldwasserMicali = \\\"Goldwasser-Micali\\\"\"\n },\n {\n \"identifier\": \"RSA\",\n \"path\": \"lightphe/cryptosystems/RSA.py\",\n \"snippet\": \"class RSA(Homomorphic):\\n \\\"\\\"\\\"\\n RSA algorithm is partially homomorphic with respect to the multiplication\\n Ref: https://sefiks.com/2023/03/06/a-step-by-step-partially-homomorphic-encryption-example-with-rsa-in-python/\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, key_size: int = 1024, encrypt_with_public=True):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits\\n encrypt_with_public (boolean): RSA has two keys: private (d) and public (e).\\n If you encrypt a message with smo's public, then just that person can decrypt it\\n with his private (secure message). Otherwise, if you encrypt it with your private,\\n one can decrypt it with your public (digital signatures).\\n Set this arg to True if you want to do encryption with public key e,\\n and do decryption with private key d.\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size)\\n self.plaintext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n self.ciphertext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n self.encrypt_with_public = encrypt_with_public\\n\\n def generate_keys(self, key_size: int) -> dict:\\n \\\"\\\"\\\"\\n Generate public and private keys of RSA cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n while True:\\n try:\\n # picking a prime modulus p and q\\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n n = p * q\\n phi = (p - 1) * (q - 1)\\n\\n # select public exponent e\\n while True:\\n e = random.randint(1, phi - 1)\\n if math.gcd(e, n) == 1:\\n break\\n\\n d = pow(e, -1, phi)\\n break\\n except:\\n pass\\n\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n keys[\\\"public_key\\\"][\\\"e\\\"] = e\\n keys[\\\"private_key\\\"][\\\"d\\\"] = d\\n return keys\\n\\n def generate_random_key(self) -> int:\\n pass\\n\\n def encrypt(self, plaintext: int) -> int:\\n \\\"\\\"\\\"\\n Encrypt plain messages with RSA\\n Args:\\n plaintext (int): plain message\\n Returns:\\n ciphertext (int): ciphertext encrypted with RSA\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n\\n if plaintext > n:\\n plaintext = plaintext % n\\n logger.debug(\\n f\\\"RSA can encrypt messages [1, {n}]. \\\"\\n f\\\"Seems you exceeded this limit. New plaintext is {plaintext}\\\"\\n )\\n\\n if self.encrypt_with_public is True:\\n e = self.keys[\\\"public_key\\\"][\\\"e\\\"]\\n c = pow(plaintext, e, n)\\n else:\\n d = self.keys[\\\"private_key\\\"][\\\"d\\\"]\\n c = pow(plaintext, d, n)\\n\\n return c\\n\\n def decrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Decrypt ciphertexts with RSA\\n Args:\\n ciphertext (int): encrypted message\\n decrypt_with_private (int): RSA has two keys: private (d) and public (e).\\n If you encrypt a message with smo's public, then just that person can decrypt it\\n with his private (secure message). Otherwise, if you encrypt it with your private,\\n one can decrypt it with your public (digital signatures).\\n Set this arg to True if you want to do encryption with public key e,\\n and do decryption with private key d.\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n if self.encrypt_with_public is True:\\n d = self.keys[\\\"private_key\\\"][\\\"d\\\"]\\n p = pow(ciphertext, d, n)\\n else:\\n e = self.keys[\\\"public_key\\\"][\\\"e\\\"]\\n p = pow(ciphertext, e, n)\\n\\n return p\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n \\\"\\\"\\\"\\n Perform homomorphic multiplication on encrypted data.\\n Result of this must be equal to E(m1 * m2)\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n return (ciphertext1 * ciphertext2) % n\\n\\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"RSA is not homomorphic with respect to the addition\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"RSA is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\\n raise ValueError(\\\"RSA is not supporting multiplying ciphertext by a known constant\\\")\\n\\n def reencrypt(self, ciphertext: int) -> int:\\n raise ValueError(\\\"RSA does not support re-encryption\\\")\"\n },\n {\n \"identifier\": \"ElGamal\",\n \"path\": \"lightphe/cryptosystems/ElGamal.py\",\n \"snippet\": \"class ElGamal(Homomorphic):\\n \\\"\\\"\\\"\\n ElGamal algorithm is either multiplicatively or additively homomorphic\\n Ref: https://sefiks.com/2023/03/27/a-step-by-step-partially-homomorphic-encryption-example-with-elgamal-in-python/\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, exponential=False, key_size: int = 1024):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits\\n exponential (boolean): set this to True to make cryptosystem exponential ElGamal.\\n Regular ElGamal is homomorphic with respect to the multiplication whereas\\n exponential ElGamal is homomorphic with respect to the addition\\n \\\"\\\"\\\"\\n self.exponential = exponential\\n self.keys = keys or self.generate_keys(key_size)\\n self.plaintext_modulo = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n self.ciphertext_modulo = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n\\n def generate_keys(self, key_size: int):\\n \\\"\\\"\\\"\\n Generate public and private keys of ElGamal cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # picking a prime modulus p\\n p = sympy.randprime(100, 2 ** int(key_size / 2) - 1)\\n\\n # picking a generator g\\n g = random.randint(2, int(math.sqrt(p)))\\n\\n # picking a private key x\\n x = random.randint(1, p - 2)\\n\\n # public key\\n y = pow(g, x, p)\\n\\n keys[\\\"public_key\\\"] = {\\n \\\"p\\\": p,\\n \\\"g\\\": g,\\n \\\"y\\\": y,\\n }\\n\\n keys[\\\"private_key\\\"] = {\\\"x\\\": x}\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n ElGamal requires to generate one-time random key per encryption\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n p = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n return random.randint(1, p - 1)\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> tuple:\\n \\\"\\\"\\\"\\n Encrypt plaintext with ElGamal\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): random key for encryption. Do not set this to a static value.\\n Returns\\n ciphertext (tuple): c1 and c2\\n \\\"\\\"\\\"\\n p = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n y = self.keys[\\\"public_key\\\"][\\\"y\\\"]\\n r = random_key or self.generate_random_key()\\n\\n if plaintext > p:\\n plaintext = plaintext % p\\n logger.debug(\\n f\\\"ElGamal can encrypt messages [1, {p}]. \\\"\\n f\\\"Seems you exceeded this limit. New plaintext is {plaintext}\\\"\\n )\\n\\n c1 = pow(g, r, p)\\n if self.exponential is False:\\n c2 = (plaintext * pow(y, r, p)) % p\\n else:\\n c2 = (pow(g, plaintext, p) * pow(y, r, p)) % p\\n\\n return c1, c2\\n\\n def decrypt(self, ciphertext: tuple) -> int:\\n \\\"\\\"\\\"\\n Decrypt ciphertext with ElGamal\\n Args:\\n ciphertext (tuple): c1 and c2\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n c1, c2 = ciphertext\\n\\n x = self.keys[\\\"private_key\\\"][\\\"x\\\"]\\n p = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n\\n m_prime = (c2 * pow(c1, -1 * x, p)) % p\\n\\n if self.exponential is False:\\n return m_prime\\n\\n if self.exponential is True:\\n # m_prime = g^m . Find m for known m_prime and known g (DLP).\\n m = 0\\n while True:\\n if pow(g, m, p) == m_prime:\\n return m\\n m += 1\\n if m > p:\\n raise ValueError(f\\\"Cannot restore the message in [0, {p}]\\\")\\n\\n return -1\\n\\n def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\\n \\\"\\\"\\\"\\n Perform homomorphic multiplication on encrypted data\\n Result of this must be equal to E(m1 * m2)\\n Args:\\n ciphertext1 (dict): ElGamal ciphertext consisting of c1 and c2 keys\\n ciphertext2 (dict): ElGamal ciphertext consisting of c1 and c2 keys\\n Returns\\n ciphertext (dict): ElGamal ciphertext consisting of c1 and c2 keys\\n \\\"\\\"\\\"\\n if self.exponential is True:\\n raise ValueError(\\\"Exponential ElGamal is not homomorphic with respect to the addition\\\")\\n p = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n return (ciphertext1[0] * ciphertext2[0]) % p, (ciphertext1[1] * ciphertext2[1]) % p\\n\\n def add(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data\\n Result of this must be equal to E(m1 + m2)\\n Args:\\n ciphertext1 (dict): ElGamal ciphertext consisting of c1 and c2 keys\\n ciphertext2 (dict): ElGamal ciphertext consisting of c1 and c2 keys\\n Returns\\n ciphertext (dict): ElGamal ciphertext consisting of c1 and c2 keys\\n \\\"\\\"\\\"\\n if self.exponential is False:\\n raise ValueError(\\\"Regular ElGamal is not homomorphic with respect to the addition\\\")\\n p = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n return (ciphertext1[0] * ciphertext2[0]) % p, (ciphertext1[1] * ciphertext2[1]) % p\\n\\n def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:\\n raise ValueError(\\\"ElGamal is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: tuple, constant: int) -> tuple:\\n if self.exponential is False:\\n raise ValueError(\\\"ElGamal is not supporting multiplying ciphertext by a known constant\\\")\\n p = self.keys[\\\"public_key\\\"][\\\"p\\\"]\\n if constant > p:\\n constant = constant % p\\n logger.debug(\\n f\\\"ElGamal can encrypt messages [1, {p}]. \\\"\\n f\\\"Seems constant exceeded this limit. New constant is {constant}\\\"\\n )\\n\\n return pow(ciphertext[0], constant, p), pow(ciphertext[1], constant, p)\\n\\n def reencrypt(self, ciphertext: tuple) -> tuple:\\n \\\"\\\"\\\"\\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\\n Args:\\n ciphertext (int): given ciphertext\\n Returns:\\n new ciphertext (int): different ciphertext for same plaintext\\n \\\"\\\"\\\"\\n if self.exponential is True:\\n # then this is additively homomorphic\\n neutral_element = 0\\n else:\\n # then this is multiplicatively homomorphic\\n neutral_element = 1\\n\\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\\n\\n if self.exponential is True:\\n reencrypted_value = self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\\n else:\\n reencrypted_value = self.multiply(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\\n\\n return reencrypted_value\"\n },\n {\n \"identifier\": \"Paillier\",\n \"path\": \"lightphe/cryptosystems/Paillier.py\",\n \"snippet\": \"class Paillier(Homomorphic):\\n \\\"\\\"\\\"\\n Paillier algorithm is homomorphic with respect to the addition.\\n Also, it supports power operation for ciphertext base and plaintext exponent\\n Ref: https://sefiks.com/2023/04/03/a-step-by-step-partially-homomorphic-encryption-example-with-paillier-in-python/\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, key_size=1024):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size)\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n self.plaintext_modulo = n\\n self.ciphertext_modulo = n * n\\n\\n def generate_keys(self, key_size: int):\\n \\\"\\\"\\\"\\n Generate public and private keys of Paillier cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # picking a prime modulus p\\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n # picking a prime modulus q\\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n n = p * q\\n phi = (p - 1) * (q - 1)\\n g = 1 + n\\n\\n keys[\\\"private_key\\\"][\\\"phi\\\"] = phi\\n keys[\\\"public_key\\\"][\\\"g\\\"] = g\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Paillier requires to generate one-time random key per encryption\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n while True:\\n r = random.randint(0, n)\\n if math.gcd(r, n) == 1:\\n break\\n return r\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\\n \\\"\\\"\\\"\\n Encrypt a given plaintext for optionally given random key with Paillier\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): Paillier requires a random key that co-prime to n.\\n Random key will be generated automatically if you do not set this.\\n Returns:\\n ciphertext (int): encrypted message\\n \\\"\\\"\\\"\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n r = random_key or self.generate_random_key()\\n assert math.gcd(r, n) == 1\\n return (pow(g, plaintext, n * n) * pow(r, n, n * n)) % (n * n)\\n\\n def decrypt(self, ciphertext: int):\\n \\\"\\\"\\\"\\n Decrypt a given ciphertext with Paillier\\n Args:\\n ciphertext (int): encrypted message\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n phi = self.keys[\\\"private_key\\\"][\\\"phi\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n mu = pow(phi, -1, n)\\n\\n return (self.lx(pow(ciphertext, phi, n * n)) * mu) % (n)\\n\\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data.\\n Result of this must be equal to E(m1 + m2)\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext1 (int): 1st ciphertext created with Paillier\\n ciphertext2 (int): 2nd ciphertext created with Paillier\\n Returns:\\n ciphertext3 (int): 3rd ciphertext created with Paillier\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n return (ciphertext1 * ciphertext2) % (n * n)\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Paillier is not homomorphic with respect to the multiplication\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Paillier is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\\n \\\"\\\"\\\"\\n Multiply a ciphertext with a plain constant.\\n Result of this must be equal to E(m1 * m2) where E(m1) = ciphertext\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext (int): ciphertext created with Paillier\\n constant (int): known plain constant\\n Returns:\\n ciphertext (int): new ciphertext created with Paillier\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n\\n if constant > self.plaintext_modulo:\\n constant = constant % self.plaintext_modulo\\n logger.debug(\\n f\\\"Paillier can encrypt messages [1, {n}]. \\\"\\n f\\\"Seems constant exceeded this limit. New constant is {constant}\\\"\\n )\\n\\n return pow(ciphertext, constant, n * n)\\n\\n def reencrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\\n Args:\\n ciphertext (int): given ciphertext\\n Returns:\\n new ciphertext (int): different ciphertext for same plaintext\\n \\\"\\\"\\\"\\n neutral_element = 0\\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\\n\\n def lx(self, x: int) -> int:\\n \\\"\\\"\\\"\\n Find logarithm over cyclic group\\n Args:\\n x (int): some integer\\n Returns:\\n lx (int): (x-1) / n\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n y = (x - 1) // n\\n assert y - int(y) == 0\\n return int(y)\"\n },\n {\n \"identifier\": \"DamgardJurik\",\n \"path\": \"lightphe/cryptosystems/DamgardJurik.py\",\n \"snippet\": \"class DamgardJurik(Homomorphic):\\n \\\"\\\"\\\"\\n Damgard-Jurik algorithm is a generalization of Paillier.\\n It is homomorphic with respect to the addition.\\n Ref: https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-damgard-jurik-in-python/\\n \\\"\\\"\\\"\\n\\n def __init__(self, s: int = 2, keys: Optional[dict] = None, key_size: int = 1024):\\n \\\"\\\"\\\"\\n Args:\\n s (int): cryptosystem's module is going to be n^(s+1). if s == 1 then this is Paillier\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size=key_size, s=s)\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n self.plaintext_modulo = n\\n self.ciphertext_modulo = pow(n, s + 1)\\n\\n def generate_keys(self, key_size: int, s: Optional[int] = None):\\n \\\"\\\"\\\"\\n Generate public and private keys of Paillier cryptosystem\\n Args:\\n s (int): cryptosystem's module is going to be n^(s+1). if s == 1 then this is Paillier\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # picking a prime modulus p\\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n # picking a prime modulus q\\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n n = p * q\\n phi = (p - 1) * (q - 1)\\n g = 1 + n\\n\\n keys[\\\"private_key\\\"][\\\"phi\\\"] = phi\\n keys[\\\"public_key\\\"][\\\"g\\\"] = g\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n keys[\\\"public_key\\\"][\\\"s\\\"] = s\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Paillier requires to generate one-time random key per encryption\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n while True:\\n r = random.randint(0, n)\\n if math.gcd(r, n) == 1:\\n break\\n return r\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\\n \\\"\\\"\\\"\\n Encrypt a given plaintext for optionally given random key with Paillier\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): Paillier requires a random key that co-prime to n.\\n Random key will be generated automatically if you do not set this.\\n Returns:\\n ciphertext (int): encrypted message\\n \\\"\\\"\\\"\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n s = self.keys[\\\"public_key\\\"][\\\"s\\\"]\\n r = random_key or self.generate_random_key()\\n modulo = pow(n, s + 1)\\n\\n # assert math.gcd(r, n) == 1\\n c = (pow(g, plaintext, modulo) * pow(r, n, modulo)) % modulo\\n # c = (pow(g, plaintext, modulo) * pow(r, pow(n, s), modulo)) % modulo\\n if math.gcd(c, modulo) != 1:\\n logger.info(f\\\"WARNING! gcd({c=}, {modulo=}) != 1\\\")\\n return c\\n\\n def decrypt(self, ciphertext: int):\\n \\\"\\\"\\\"\\n Decrypt a given ciphertext with Paillier\\n Args:\\n ciphertext (int): encrypted message\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n phi = self.keys[\\\"private_key\\\"][\\\"phi\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n s = self.keys[\\\"public_key\\\"][\\\"s\\\"]\\n mu = pow(phi, -1, n)\\n modulo = pow(n, s + 1)\\n return (self.lx(pow(ciphertext, phi, modulo)) * mu) % (n)\\n\\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data.\\n Result of this must be equal to E(m1 + m2)\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext1 (int): 1st ciphertext created with Paillier\\n ciphertext2 (int): 2nd ciphertext created with Paillier\\n Returns:\\n ciphertext3 (int): 3rd ciphertext created with Paillier\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n s = self.keys[\\\"public_key\\\"][\\\"s\\\"]\\n modulo = pow(n, s + 1)\\n return (ciphertext1 * ciphertext2) % modulo\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Damgard-Jurik is not homomorphic with respect to the multiplication\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Damgard-Jurik is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\\n \\\"\\\"\\\"\\n Multiply a ciphertext by a known plain constant\\n Result of this must be equal to E(m1 * m2), where E(m1) = ciphertext\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext (int): ciphertext created with Damgard-Jurik\\n constant (int): a known plain constant\\n Returns:\\n ciphertext (int): new ciphertext created with Damgard-Jurik\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n if constant > self.plaintext_modulo:\\n constant = constant % self.plaintext_modulo\\n logger.debug(\\n f\\\"Damgard-Jurik can encrypt messages [1, {n}]. \\\"\\n f\\\"Seems constant exceeded this limit. New constant is {constant}\\\"\\n )\\n return pow(ciphertext, constant, self.ciphertext_modulo)\\n\\n def reencrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\\n Args:\\n ciphertext (int): given ciphertext\\n Returns:\\n new ciphertext (int): different ciphertext for same plaintext\\n \\\"\\\"\\\"\\n neutral_element = 0\\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\\n\\n def lx(self, x: int) -> int:\\n \\\"\\\"\\\"\\n Find logarithm over cyclic group\\n Args:\\n x (int): some integer\\n Returns:\\n lx (int): (x-1) / n\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n y = (x - 1) // n\\n assert y - int(y) == 0\\n return int(y)\"\n },\n {\n \"identifier\": \"OkamotoUchiyama\",\n \"path\": \"lightphe/cryptosystems/OkamotoUchiyama.py\",\n \"snippet\": \"class OkamotoUchiyama(Homomorphic):\\n \\\"\\\"\\\"\\n Okamoto-Uchiyama algorithm is homomorphic with respect to the addition.\\n Ref: https://sefiks.com/2023/10/20/a-step-by-step-partially-homomorphic-encryption-example-with-okamoto-uchiyama-in-python/\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, key_size=1024):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size)\\n self.plaintext_modulo = self.keys[\\\"private_key\\\"][\\\"p\\\"]\\n self.ciphertext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n\\n def generate_keys(self, key_size: int) -> dict:\\n \\\"\\\"\\\"\\n Generate public and private keys of OkamotoUchiyama cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # picking a prime modulus p\\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n # picking a prime modulus q\\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n # modulo\\n n = p * p * q\\n\\n # generator\\n g = random.randint(2, n)\\n\\n if pow(g, p - 1, p * p) == 1:\\n raise ValueError(\\\"Fermat's Little Theorem must be satisfied\\\")\\n\\n h = pow(g, n, n)\\n\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n keys[\\\"public_key\\\"][\\\"g\\\"] = g\\n keys[\\\"public_key\\\"][\\\"h\\\"] = h\\n keys[\\\"private_key\\\"][\\\"p\\\"] = p\\n keys[\\\"private_key\\\"][\\\"q\\\"] = q\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Okamoto-Uchiyama requires to generate one-time random key per encryption\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n return random.randint(1, n - 1)\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\\n \\\"\\\"\\\"\\n Encrypt a given plaintext for optionally given random key with OkamotoUchiyama\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): OkamotoUchiyama requires a random key\\n Random key will be generated automatically if you do not set this.\\n Returns:\\n ciphertext (int): encrypted message\\n \\\"\\\"\\\"\\n p = self.keys[\\\"private_key\\\"][\\\"p\\\"]\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n h = self.keys[\\\"public_key\\\"][\\\"h\\\"]\\n r = random_key or self.generate_random_key()\\n\\n if plaintext > p:\\n plaintext = plaintext % p\\n logger.debug(\\n f\\\"plaintext must be in scale [0, {p=}] but this is exceeded.\\\"\\n \\\"New plaintext is {plaintext}\\\"\\n )\\n return (pow(g, plaintext, n) * pow(h, r, n)) % n\\n\\n def decrypt(self, ciphertext: int):\\n \\\"\\\"\\\"\\n Decrypt a given ciphertext with Okamoto-Uchiyama\\n Args:\\n ciphertext (int): encrypted message\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n p = self.keys[\\\"private_key\\\"][\\\"p\\\"]\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n\\n a = self.lx(pow(ciphertext, p - 1, p * p))\\n b = self.lx(pow(g, p - 1, p * p))\\n return (a * pow(b, -1, p)) % p\\n\\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data.\\n Result of this must be equal to E(m1 + m2)\\n Encryption calculations are done in module n\\n Args:\\n ciphertext1 (int): 1st ciphertext created with OkamotoUchiyama\\n ciphertext2 (int): 2nd ciphertext created with OkamotoUchiyama\\n Returns:\\n ciphertext3 (int): 3rd ciphertext created with OkamotoUchiyama\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n return (ciphertext1 * ciphertext2) % n\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Okamoto-Uchiyama is not homomorphic with respect to the multiplication\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Okamoto-Uchiyama is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\\n \\\"\\\"\\\"\\n Multiply a ciphertext with a plain constant.\\n Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext (int): ciphertext created with Okamoto-Uchiyama\\n constant (int): known plain constant\\n Returns:\\n ciphertext (int): new ciphertext created with Okamoto-Uchiyama\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n if constant > self.plaintext_modulo:\\n constant = constant % self.plaintext_modulo\\n logger.debug(\\n f\\\"Okamoto-Uchiyama can encrypt messages [1, {n}]. \\\"\\n f\\\"Seems constant exceeded this limit. New constant is {constant}\\\"\\n )\\n return pow(ciphertext, constant, n)\\n\\n def reencrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\\n Args:\\n ciphertext (int): given ciphertext\\n Returns:\\n new ciphertext (int): different ciphertext for same plaintext\\n \\\"\\\"\\\"\\n neutral_element = 0\\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\\n\\n def lx(self, x: int) -> int:\\n \\\"\\\"\\\"\\n Find logarithm over cyclic group\\n Args:\\n x (int): some integer\\n Returns:\\n lx (int): (x-1) / p\\n \\\"\\\"\\\"\\n p = self.keys[\\\"private_key\\\"][\\\"p\\\"]\\n if x % p != 1:\\n raise ValueError(f\\\"Input passed to lx ({x}) must be identical to 1 in modulo {p}\\\")\\n if math.gcd(x, p * p) != 1:\\n raise ValueError(f\\\"gcd({x}, {p}^2) must be equal to 1\\\")\\n y = (x - 1) // p\\n assert y - int(y) == 0\\n return int(y)\"\n },\n {\n \"identifier\": \"Benaloh\",\n \"path\": \"lightphe/cryptosystems/Benaloh.py\",\n \"snippet\": \"class Benaloh(Homomorphic):\\n def __init__(self, keys: Optional[dict] = None, key_size: int = 50):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits. default is less than other cryptosystems\\n because decryption of Benaloh requires to solve DLP :/\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size)\\n self.plaintext_modulo = self.keys[\\\"public_key\\\"][\\\"r\\\"]\\n self.ciphertext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n\\n def generate_keys(self, key_size: int) -> dict:\\n \\\"\\\"\\\"\\n Generate public and private keys of Paillier cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n x = 1\\n while x == 1:\\n # picking a prime p\\n p = sympy.randprime(200, 2**key_size)\\n\\n # picking a prime q\\n q = sympy.randprime(100, p)\\n\\n n = p * q\\n phi = (p - 1) * (q - 1)\\n\\n r = p - 1\\n while gcd(q - 1, r) != 1:\\n r = int(r / gcd(q - 1, r))\\n\\n if not (\\n # r should divide p-1 without remainder\\n (p - 1) % r == 0\\n # r and (p - 1) / r must be coprimes\\n and gcd(r, int((p - 1) / r)) == 1\\n # r and q-1 must be coprimes\\n and gcd(r, q - 1) == 1\\n ):\\n continue\\n\\n y = random.randint(2, n)\\n if gcd(y, n) != 1:\\n continue\\n\\n # to guarantee correct decryption\\n prime_factors = sympy.factorint(r).keys()\\n decryption_guaranteed = True\\n for prime_factor in prime_factors:\\n # none of r's prime factor should satisfy the condition\\n if pow(y, int(phi / prime_factor), n) == 1:\\n decryption_guaranteed = False\\n\\n if decryption_guaranteed is False:\\n continue\\n\\n x = pow(y, int(phi / r), n)\\n if x != 1:\\n break\\n\\n keys[\\\"public_key\\\"][\\\"y\\\"] = y\\n keys[\\\"public_key\\\"][\\\"r\\\"] = r\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n\\n keys[\\\"private_key\\\"][\\\"p\\\"] = p\\n keys[\\\"private_key\\\"][\\\"q\\\"] = q\\n keys[\\\"private_key\\\"][\\\"phi\\\"] = phi\\n keys[\\\"private_key\\\"][\\\"x\\\"] = x\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Generate random key for encryption\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n while True:\\n u = random.randint(1, n)\\n if gcd(u, n) == 1:\\n break\\n return u\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\\n \\\"\\\"\\\"\\n Encrypt a given plaintext for optionally given random key with Benaloh\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): Benaloh requires a random key\\n Random key will be generated automatically if you do not set this.\\n Returns:\\n ciphertext (int): encrypted message\\n \\\"\\\"\\\"\\n y = self.keys[\\\"public_key\\\"][\\\"y\\\"]\\n r = self.keys[\\\"public_key\\\"][\\\"r\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n\\n u = random_key or self.generate_random_key()\\n\\n if plaintext > r:\\n plaintext = plaintext % r\\n logger.debug(\\n f\\\"Benaloh lets you to encrypt messages in [0, {r=}].\\\"\\n f\\\"But your plaintext exceeds this limit.\\\"\\n f\\\"New plaintext is {plaintext}\\\"\\n )\\n\\n c = (pow(y, plaintext, n) * pow(u, r, n)) % n\\n\\n if gcd(c, n) != 1:\\n logger.debug(\\\"ciphertext is not co-prime with n!\\\")\\n\\n return c\\n\\n def decrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Decrypt a given ciphertext with Benaloh\\n Args:\\n ciphertext (int): encrypted message\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n r = self.keys[\\\"public_key\\\"][\\\"r\\\"]\\n phi = self.keys[\\\"private_key\\\"][\\\"phi\\\"]\\n x = self.keys[\\\"private_key\\\"][\\\"x\\\"]\\n\\n a = pow(ciphertext, int(phi / r), n)\\n\\n md = 0\\n while True:\\n if pow(x, md, n) == a:\\n break\\n md = md + 1\\n if md > r:\\n raise ValueError(f\\\"Message cannot be restored in [{0}, {n}]\\\")\\n return md\\n\\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data.\\n Result of this must be equal to E(m1 + m2)\\n Encryption calculations are done in module n\\n Args:\\n ciphertext1 (int): 1st ciphertext created with Benaloh\\n ciphertext2 (int): 2nd ciphertext created with Benaloh\\n Returns:\\n ciphertext3 (int): 3rd ciphertext created with Benaloh\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n return (ciphertext1 * ciphertext2) % n\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Benaloh is not homomorphic with respect to the multiplication\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Benaloh is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\\n \\\"\\\"\\\"\\n Multiply a ciphertext with a plain constant.\\n Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext (int): ciphertext created with Benaloh\\n constant (int): known plain constant\\n Returns:\\n ciphertext (int): new ciphertext created with Benaloh\\n \\\"\\\"\\\"\\n # raise ValueError(\\\"Benaloh is not supporting multiplying by a constant\\\")\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n if constant > self.plaintext_modulo:\\n constant = constant % self.plaintext_modulo\\n logger.debug(\\n f\\\"Benaloh can encrypt messages [1, {self.plaintext_modulo}]. \\\"\\n f\\\"Seems constant exceeded this limit. New constant is {constant}\\\"\\n )\\n return pow(ciphertext, constant, n)\\n\\n def reencrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\\n Args:\\n ciphertext (int): given ciphertext\\n Returns:\\n new ciphertext (int): different ciphertext for same plaintext\\n \\\"\\\"\\\"\\n neutral_element = 0\\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\"\n },\n {\n \"identifier\": \"NaccacheStern\",\n \"path\": \"lightphe/cryptosystems/NaccacheStern.py\",\n \"snippet\": \"class NaccacheStern(Homomorphic):\\n \\\"\\\"\\\"\\n Naccache-Stern algorithm is homomorphic with respect to the addition.\\n It is a generaliation of Benaloh cryptosystem\\n Ref: https://sefiks.com/2023/10/26/a-step-by-step-partially-homomorphic-encryption-example-with-naccache-stern-in-python/\\n Original paper: https://dl.acm.org/doi/pdf/10.1145/288090.288106\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, key_size=37, deterministic: bool = False):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits. Less than many cryptosystems because\\n decryption requires to solve DLP.\\n deterministic (boolean): deterministic or probabilistic version of\\n cryptosystem\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size)\\n self.plaintext_modulo = self.keys[\\\"public_key\\\"][\\\"sigma\\\"]\\n self.ciphertext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n self.deterministic = deterministic\\n\\n def generate_keys(self, key_size: int) -> dict:\\n \\\"\\\"\\\"\\n Generate public and private keys of Naccache-Stern cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # pick a family of small primes. the largest one is 10-bits\\n # TODO: do something generic instead of constant primes\\n prime_set = [3, 5, 7, 11, 13, 17]\\n k = len(prime_set)\\n\\n if all(sympy.isprime(prime) is True for prime in prime_set) is False:\\n raise ValueError(\\\"All items of prime set must be prime!\\\")\\n\\n # divide the set in half and find products of primes\\n u = 1\\n v = 1\\n\\n for i, prime in enumerate(prime_set):\\n if i < len(prime_set) / 2:\\n u = u * prime\\n else:\\n v = v * prime\\n\\n # product of all primes\\n sigma = u * v\\n\\n # pick large prime numbers\\n while True:\\n a = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n b = sympy.randprime(100, a)\\n\\n # calculate two primes from chosen ones\\n p = (2 * a * u) + 1\\n q = (2 * b * v) + 1\\n\\n # recommended n is 768 bits\\n n = p * q\\n phi = (p - 1) * (q - 1)\\n\\n if phi % sigma != 0:\\n logger.debug(\\\"canceled because phi cannot be divisible by sigma\\\")\\n continue\\n\\n if math.gcd(sigma, int(phi // sigma)) != 1:\\n logger.debug(\\\"canceled because sigma and phi/sigma are not coprime\\\")\\n continue\\n\\n p_conditions = []\\n for i in range(0, int(k / 2)):\\n pi = prime_set[i]\\n if (\\n (p - 1) % pi == 0\\n and math.gcd(pi, int((p - 1) / pi)) == 1\\n and math.gcd(pi, q - 1) == 1\\n ):\\n p_conditions.append(1)\\n else:\\n p_conditions.append(0)\\n p_satisfied = True if len(p_conditions) == sum(p_conditions) else False\\n if p_satisfied is False:\\n logger.debug(\\\"canceled because p_conditions are not satisfied\\\")\\n continue\\n\\n q_conditions = []\\n for i in range(int(k / 2), k):\\n pi = prime_set[i]\\n if (\\n (q - 1) % pi == 0\\n and math.gcd(pi, int((q - 1) / pi)) == 1\\n and math.gcd(pi, p - 1)\\n ):\\n q_conditions.append(1)\\n else:\\n q_conditions.append(0)\\n\\n q_satisfied = True if len(q_conditions) == sum(q_conditions) else False\\n if q_satisfied is False:\\n logger.debug(\\\"canceled because q_conditions are not satisfied\\\")\\n continue\\n\\n # p and q must be primes\\n if not (sympy.isprime(p) and sympy.isprime(q)):\\n continue\\n\\n # choose a generator g\\n g = random.randint(2, n)\\n # it must be co-prime to n\\n if math.gcd(g, n) != 1:\\n logger.debug(\\\"canceled becuase g is not co-prime with ne\\\")\\n continue\\n # guarantee it is not pi-th power.\\n for pi in prime_set:\\n logger.debug(\\\"canceled because g is a pi-th power\\\")\\n if pow(g, int(phi / pi), n) == 1:\\n continue\\n\\n # the order of g modulo n must be phi/4\\n if pow(g, int(phi / 4), n) != 1:\\n continue\\n\\n # check decryption is guaranteed similar to benaloh\\n # ps: this is not mentioned in the original paper\\n is_decryption_guaranteed = True\\n for pi in prime_set:\\n prime_factors = sympy.factorint(pi).keys()\\n for prime_factor in prime_factors:\\n if pow(g, int(phi / prime_factor), n) == 1:\\n is_decryption_guaranteed = False\\n if is_decryption_guaranteed is True:\\n break\\n\\n logger.debug(f\\\"n bits is {len(bin(n)[2:])}\\\")\\n\\n keys[\\\"public_key\\\"][\\\"g\\\"] = g\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n # sigma can optionally be secret in deterministic version\\n keys[\\\"public_key\\\"][\\\"sigma\\\"] = sigma\\n\\n keys[\\\"private_key\\\"][\\\"p\\\"] = p\\n keys[\\\"private_key\\\"][\\\"q\\\"] = q\\n keys[\\\"private_key\\\"][\\\"phi\\\"] = phi\\n keys[\\\"private_key\\\"][\\\"prime_set\\\"] = prime_set\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Naccache-Stern requires to generate one-time random key per encryption\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n return random.randint(1, n - 1)\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> int:\\n \\\"\\\"\\\"\\n Encrypt a given plaintext for optionally given random key with Naccache-Stern\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): Naccache-Stern requires a random key\\n Random key will be generated automatically if you do not set this.\\n Returns:\\n ciphertext (int): encrypted message\\n \\\"\\\"\\\"\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n r = random_key or self.generate_random_key()\\n sigma = self.keys[\\\"public_key\\\"][\\\"sigma\\\"]\\n if plaintext > self.plaintext_modulo:\\n plaintext = plaintext % self.plaintext_modulo\\n logger.debug(\\n f\\\"plaintext must be in scale [0, {self.plaintext_modulo}] \\\"\\n \\\"but this is exceeded. New plaintext is {plaintext}\\\"\\n )\\n\\n if self.deterministic is True:\\n return pow(g, plaintext, n)\\n\\n # Probabilistic\\n return (pow(r, sigma, n) * pow(g, plaintext, n)) % n\\n\\n def decrypt(self, ciphertext: int):\\n \\\"\\\"\\\"\\n Decrypt a given ciphertext with Naccache-Stern\\n Args:\\n ciphertext (int): encrypted message\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n phi = self.keys[\\\"private_key\\\"][\\\"phi\\\"]\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n g = self.keys[\\\"public_key\\\"][\\\"g\\\"]\\n prime_set = self.keys[\\\"private_key\\\"][\\\"prime_set\\\"]\\n\\n remainders = []\\n for i, prime in enumerate(prime_set):\\n ci = pow(ciphertext, int(phi / prime), n)\\n logger.debug(f\\\"c_{i} = {ci}\\\")\\n\\n j = 0\\n while True:\\n if ci == pow(g, int((j * phi) / prime), n):\\n logger.debug(f\\\"m_{i} = {j}\\\")\\n remainders.append(j)\\n break\\n j = j + 1\\n if j > prime**2:\\n raise ValueError(\\n f\\\"c_{i} cannot be restored from {ci} = {g}^(j*{phi}/{prime}) mod {n}\\\"\\n )\\n\\n congruences = []\\n for i in range(0, len(prime_set)):\\n logger.debug(f\\\"m mod {prime_set[i]} = {remainders[i]}\\\")\\n congruences.append((remainders[i], prime_set[i]))\\n\\n # chinese remainder problem\\n ms = solve_congruence(*congruences)\\n if not ms:\\n raise ValueError(\\\"message cannot be restored with Chinese Remainder!\\\")\\n return ms[0]\\n\\n def add(self, ciphertext1: int, ciphertext2: int) -> int:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data.\\n Result of this must be equal to E(m1 + m2)\\n Encryption calculations are done in module n\\n Args:\\n ciphertext1 (int): 1st ciphertext created with Naccache-Stern\\n ciphertext2 (int): 2nd ciphertext created with Naccache-Stern\\n Returns:\\n ciphertext3 (int): 3rd ciphertext created with Naccache-Stern\\n \\\"\\\"\\\"\\n return (ciphertext1 * ciphertext2) % self.ciphertext_modulo\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Naccache-Stern is not homomorphic with respect to the multiplication\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Naccache-Stern is not homomorphic with respect to the exclusive or\\\")\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int) -> int:\\n \\\"\\\"\\\"\\n Multiply a ciphertext with a plain constant.\\n Result of this must be equal to E(m1 * constant) where E(m1) = ciphertext\\n Encryption calculations are done in module n squared.\\n Args:\\n ciphertext (int): ciphertext created with Naccache-Stern\\n constant (int): known plain constant\\n Returns:\\n ciphertext (int): new ciphertext created with Naccache-Stern\\n \\\"\\\"\\\"\\n if constant > self.plaintext_modulo:\\n constant = constant % self.plaintext_modulo\\n logger.debug(\\n f\\\"Naccache-Stern can encrypt messages [1, {self.plaintext_modulo}]. \\\"\\n f\\\"Seems constant exceeded this limit. New constant is {constant}\\\"\\n )\\n\\n return pow(ciphertext, constant, self.ciphertext_modulo)\\n\\n def reencrypt(self, ciphertext: int) -> int:\\n \\\"\\\"\\\"\\n Re-generate ciphertext with re-encryption. Many ciphertext will be decrypted to same plaintext.\\n Args:\\n ciphertext (int): given ciphertext\\n Returns:\\n new ciphertext (int): different ciphertext for same plaintext\\n \\\"\\\"\\\"\\n if self.deterministic is True:\\n raise ValueError(\\n \\\"Deterministic version of Naccache-Stern does not support reencryption.\\\"\\n \\\"If you still want to perform ciphertext regeneration, then you may \\\"\\n \\\"consider to use its probabilistic version.\\\"\\n )\\n neutral_element = 0\\n neutral_encrypted = self.encrypt(plaintext=neutral_element)\\n return self.add(ciphertext1=ciphertext, ciphertext2=neutral_encrypted)\"\n },\n {\n \"identifier\": \"GoldwasserMicali\",\n \"path\": \"lightphe/cryptosystems/GoldwasserMicali.py\",\n \"snippet\": \"class GoldwasserMicali(Homomorphic):\\n \\\"\\\"\\\"\\n Goldwasser-Micali algorithm is homomorphic with respect to the Exclusively OR (XOR).\\n Ref: https://sefiks.com/2023/10/27/a-step-by-step-partially-homomorphic-encryption-example-with-goldwasser-micali-in-python/\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, key_size=100):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits\\n \\\"\\\"\\\"\\n self.keys = keys or self.generate_keys(key_size)\\n self.ciphertext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n # TODO: not sure about the plaintext modulo\\n self.plaintext_modulo = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n\\n def generate_keys(self, key_size: int) -> dict:\\n \\\"\\\"\\\"\\n Generate public and private keys of Goldwasser-Micali cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # picking a prime p\\n p = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n # picking a prime q\\n q = sympy.randprime(200, 2 ** int(key_size / 2) - 1)\\n\\n n = p * q\\n\\n # find non-residue x\\n while True:\\n x = random.randint(1, n - 1)\\n if math.gcd(x, n) == 1 and jacobi_symbol(x, p) == -1 and jacobi_symbol(x, q) == -1:\\n break\\n\\n keys[\\\"public_key\\\"][\\\"n\\\"] = n\\n keys[\\\"public_key\\\"][\\\"x\\\"] = x\\n\\n keys[\\\"private_key\\\"][\\\"p\\\"] = p\\n keys[\\\"private_key\\\"][\\\"q\\\"] = q\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Goldwasser-Micali requires to generate one-time random key that co-prime to n\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n while True:\\n r = random.randint(1, n)\\n if math.gcd(r, n) == 1:\\n break\\n return r\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> list:\\n \\\"\\\"\\\"\\n Encrypt a given plaintext for optionally given random key with Goldwasser-Micali\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): Goldwasser-Micali requires a random key\\n Random key will be generated automatically if you do not set this.\\n Returns:\\n ciphertext (int): encrypted message\\n \\\"\\\"\\\"\\n n = self.keys[\\\"public_key\\\"][\\\"n\\\"]\\n x = self.keys[\\\"public_key\\\"][\\\"x\\\"]\\n\\n m_binary = bin(plaintext)[2:]\\n\\n # number of bits\\n k = len(m_binary)\\n\\n if random_key and len(random_key) != k:\\n raise ValueError(f\\\"Random key must be length of {k}\\\")\\n\\n c = []\\n for i in range(0, k):\\n mi = int(m_binary[i])\\n\\n if random_key:\\n ri = random_key[i]\\n else:\\n ri = self.generate_random_key()\\n\\n ci = (pow(ri, 2, n) * pow(x, mi, n)) % n\\n c.append(ci)\\n\\n return c\\n\\n def decrypt(self, ciphertext: list) -> int:\\n \\\"\\\"\\\"\\n Decrypt a given ciphertext with Goldwasser-Micali\\n Args:\\n ciphertext (int): encrypted message\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n m_binaries = []\\n\\n p = self.keys[\\\"private_key\\\"][\\\"p\\\"]\\n q = self.keys[\\\"private_key\\\"][\\\"q\\\"]\\n\\n for i in ciphertext:\\n xp = i % p\\n xq = i % q\\n\\n if pow(xp, int((p - 1) / 2), p) == 1 and pow(xq, int((q - 1) / 2), q) == 1:\\n m_binaries.append(\\\"0\\\")\\n else:\\n m_binaries.append(\\\"1\\\")\\n\\n m_binary = \\\"\\\".join(m_binaries)\\n return int(m_binary, 2)\\n\\n def add(self, ciphertext1: list, ciphertext2: list) -> list:\\n raise ValueError(\\\"Goldwasser-Micali is not homomorphic with respect to the addition\\\")\\n\\n def multiply(self, ciphertext1: int, ciphertext2: int) -> int:\\n raise ValueError(\\\"Goldwasser-Micali is not homomorphic with respect to the multiplication\\\")\\n\\n def xor(self, ciphertext1: int, ciphertext2: int) -> list:\\n \\\"\\\"\\\"\\n Perform homomorphic xor on encrypted data.\\n Result of this must be equal to E(m1 ^ m2) = E(m1) ^ E(m2)\\n Encryption calculations are done in module n\\n Args:\\n ciphertext1 (int): 1st ciphertext created with Goldwasser-Micali\\n ciphertext2 (int): 2nd ciphertext created with Goldwasser-Micali\\n Returns:\\n ciphertext3 (int): 3rd ciphertext created with Goldwasser-Micali\\n \\\"\\\"\\\"\\n ciphertext3 = []\\n for i in range(0, len(ciphertext1)):\\n c1 = ciphertext1[i]\\n c2 = ciphertext2[i]\\n ciphertext3.append((c1 * c2) % self.ciphertext_modulo)\\n\\n return ciphertext3\\n\\n def multiply_by_contant(self, ciphertext: int, constant: int):\\n raise ValueError(\\\"Goldwasser-Micali does not support multiplying with constant\\\")\\n\\n def reencrypt(self, ciphertext: int):\\n raise ValueError(\\\"Goldwasser-Micali does not support re-encryption\\\")\"\n },\n {\n \"identifier\": \"EllipticCurveElGamal\",\n \"path\": \"lightphe/cryptosystems/EllipticCurveElGamal.py\",\n \"snippet\": \"class EllipticCurveElGamal(Homomorphic):\\n \\\"\\\"\\\"\\n Elliptic Curve ElGamal algorithm is an additively homomorphic algorithm\\n Unluckily, it requires to solve (EC)DLP to restore plaintext in decryption\\n However it is easy to restore plaintext while plaintext is not very large\\n unsimilar to Benaloh or Naccache-Stern\\n Ref: https://sefiks.com/2018/08/21/elliptic-curve-elgamal-encryption/\\n \\\"\\\"\\\"\\n\\n def __init__(self, keys: Optional[dict] = None, key_size: int = 160):\\n \\\"\\\"\\\"\\n Args:\\n keys (dict): private - public key pair.\\n set this to None if you want to generate random keys.\\n key_size (int): key size in bits. default is 160.\\n this is equivalent to 1024 bit RSA.\\n \\\"\\\"\\\"\\n # TODO: add different forms and curves. e.g. Koblitz, Edwards (Ed25519)\\n self.curve = Weierstrass()\\n self.keys = keys or self.generate_keys(key_size)\\n self.plaintext_modulo = self.curve.p\\n self.ciphertext_modulo = self.curve.p\\n\\n def generate_keys(self, key_size: int):\\n \\\"\\\"\\\"\\n Generate public and private keys of Elliptic Curve ElGamal cryptosystem\\n Args:\\n key_size (int): key size in bits\\n Returns:\\n keys (dict): having private_key and public_key keys\\n \\\"\\\"\\\"\\n keys = {}\\n keys[\\\"private_key\\\"] = {}\\n keys[\\\"public_key\\\"] = {}\\n\\n # private key\\n ka = random.getrandbits(key_size)\\n\\n # public key\\n Qa = self.curve.apply_double_and_add_method(G=self.curve.G, k=ka, p=self.curve.p)\\n\\n keys[\\\"public_key\\\"][\\\"Qa\\\"] = Qa\\n keys[\\\"private_key\\\"][\\\"ka\\\"] = ka\\n\\n return keys\\n\\n def generate_random_key(self) -> int:\\n \\\"\\\"\\\"\\n Elliptic Curve ElGamal requires to generate one-time random key per encryption\\n Returns:\\n random key (int): one time random key for encryption\\n \\\"\\\"\\\"\\n return random.getrandbits(128)\\n\\n def encrypt(self, plaintext: int, random_key: Optional[int] = None) -> tuple:\\n \\\"\\\"\\\"\\n Encrypt plaintext with Elliptic Curve ElGamal\\n Args:\\n plaintext (int): message to encrypt\\n random_key (int): random key for encryption. Do not set this to a static value.\\n Returns\\n ciphertext (tuple): c1 and c2\\n \\\"\\\"\\\"\\n # modulo\\n p = self.curve.p\\n\\n # base point\\n G = self.curve.G\\n\\n # public key\\n Qa = self.keys[\\\"public_key\\\"][\\\"Qa\\\"]\\n\\n # random key\\n r = random_key or self.generate_random_key()\\n\\n s = self.curve.apply_double_and_add_method(G=G, k=plaintext, p=p)\\n\\n c1 = self.curve.apply_double_and_add_method(G=G, k=r, p=p)\\n\\n c2 = self.curve.apply_double_and_add_method(G=Qa, k=r, p=p)\\n c2 = self.curve.add_points(c2, s, p)\\n\\n return c1, c2\\n\\n def decrypt(self, ciphertext: tuple) -> int:\\n \\\"\\\"\\\"\\n Decrypt ciphertext with Elliptic Curve ElGamal\\n Args:\\n ciphertext (tuple): c1 and c2\\n Returns:\\n plaintext (int): restored message\\n \\\"\\\"\\\"\\n # modulo\\n p = self.curve.p\\n\\n # private key\\n ka = self.keys[\\\"private_key\\\"][\\\"ka\\\"]\\n\\n c1, c2 = ciphertext\\n c1_prime = (c1[0], (-1 * c1[1]) % p)\\n s_prime = self.curve.apply_double_and_add_method(G=c1_prime, k=ka, p=p)\\n s_prime = self.curve.add_points(P=c2, Q=s_prime, p=p)\\n\\n # s_prime is a point on the elliptic curve\\n # s_prime = k x G\\n # we need to find k from known s_prime and G\\n # this requires to solve ECDLP\\n\\n # base point\\n G = self.curve.G\\n k = 2\\n while True:\\n G = self.curve.add_points(P=G, Q=self.curve.G, p=p)\\n if G[0] == s_prime[0] and G[1] == s_prime[1]:\\n return k\\n k = k + 1\\n if k > self.curve.n:\\n raise ValueError(f\\\"Cannot restore scalar from {s_prime} = k x {self.curve.G}\\\")\\n\\n def multiply(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\\n raise ValueError(\\n \\\"Elliptic Curve ElGamal is not homomorphic with respect to the multiplication\\\"\\n )\\n\\n def add(self, ciphertext1: tuple, ciphertext2: tuple) -> tuple:\\n \\\"\\\"\\\"\\n Perform homomorphic addition on encrypted data\\n Result of this must be equal to E(m1 + m2)\\n Args:\\n ciphertext1 (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys\\n ciphertext2 (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys\\n Returns\\n ciphertext (dict): Elliptic Curve ElGamal ciphertext consisting of c1 and c2 keys\\n \\\"\\\"\\\"\\n a = self.curve.add_points(P=ciphertext1[0], Q=ciphertext2[0], p=self.curve.p)\\n b = self.curve.add_points(P=ciphertext1[1], Q=ciphertext2[1], p=self.curve.p)\\n return a, b\\n\\n def xor(self, ciphertext1: tuple, ciphertext2: tuple) -> int:\\n raise ValueError(\\n \\\"Elliptic Curve ElGamal is not homomorphic with respect to the exclusive or\\\"\\n )\\n\\n def multiply_by_contant(self, ciphertext: tuple, constant: int) -> tuple:\\n \\\"\\\"\\\"\\n Multiply a ciphertext with a plain constant.\\n Result of this must be equal to k x E(m1) = E(m1 * k)\\n where E(m1) = ciphertext\\n Args:\\n ciphertext (int): ciphertext created with Elliptic Curve ElGamal\\n constant (int): known plain constant\\n Returns:\\n ciphertext (int): new ciphertext created with Elliptic Curve ElGamal\\n \\\"\\\"\\\"\\n return self.curve.apply_double_and_add_method(\\n G=ciphertext[0], k=constant, p=self.curve.p\\n ), self.curve.apply_double_and_add_method(G=ciphertext[1], k=constant, p=self.curve.p)\\n\\n def reencrypt(self, ciphertext: tuple) -> tuple:\\n raise ValueError(\\\"Elliptic Curve ElGamal does not support regeneration of ciphertext\\\")\"\n },\n {\n \"identifier\": \"phe_utils\",\n \"path\": \"lightphe/commons/phe_utils.py\",\n \"snippet\": \"def parse_int(value: Union[int, float], modulo: int) -> int:\\ndef fractionize(value: float, modulo: int, precision: Optional[int] = None) -> Tuple[int, int]:\\ndef solve_dlp():\"\n },\n {\n \"identifier\": \"Logger\",\n \"path\": \"lightphe/commons/logger.py\",\n \"snippet\": \"class Logger:\\n def __init__(self, module):\\n self.module = module\\n log_level = os.environ.get(\\\"LIGHTPHE_LOG_LEVEL\\\", str(logging.INFO))\\n try:\\n self.log_level = int(log_level)\\n except Exception as err:\\n self.dump_log(\\n f\\\"Exception while parsing $LIGHTPHE_LOG_LEVEL.\\\"\\n f\\\"Expected int but it is {log_level} ({str(err)})\\\"\\n )\\n self.log_level = logging.INFO\\n\\n def info(self, message):\\n if self.log_level <= logging.INFO:\\n self.dump_log(message)\\n\\n def debug(self, message):\\n if self.log_level <= logging.DEBUG:\\n self.dump_log(f\\\"🕷️ {message}\\\")\\n\\n def warn(self, message):\\n if self.log_level <= logging.WARNING:\\n self.dump_log(f\\\"⚠️ {message}\\\")\\n\\n def error(self, message):\\n if self.log_level <= logging.ERROR:\\n self.dump_log(f\\\"🔴 {message}\\\")\\n\\n def critical(self, message):\\n if self.log_level <= logging.CRITICAL:\\n self.dump_log(f\\\"💥 {message}\\\")\\n\\n def dump_log(self, message):\\n print(f\\\"{str(datetime.now())[2:-7]} - {message}\\\")\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from typing import Union\nfrom lightphe.models.Homomorphic import Homomorphic\nfrom lightphe.models.Algorithm import Algorithm\nfrom lightphe.cryptosystems.RSA import RSA\nfrom lightphe.cryptosystems.ElGamal import ElGamal\nfrom lightphe.cryptosystems.Paillier import Paillier\nfrom lightphe.cryptosystems.DamgardJurik import DamgardJurik\nfrom lightphe.cryptosystems.OkamotoUchiyama import OkamotoUchiyama\nfrom lightphe.cryptosystems.Benaloh import Benaloh\nfrom lightphe.cryptosystems.NaccacheStern import NaccacheStern\nfrom lightphe.cryptosystems.GoldwasserMicali import GoldwasserMicali\nfrom lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal\nfrom lightphe.commons import phe_utils\nfrom lightphe.commons.logger import Logger"},"token_num":{"kind":"number","value":18005,"string":"18,005"},"cropped_code":{"kind":"string","value":"\nlogger = Logger(module=\"lightphe/models/Ciphertext.py\")\n\n# pylint: disable=too-few-public-methods, no-else-return\n\n\nclass Ciphertext:\n def __init__(self, algorithm_name: str, keys: dict, value: Union[int, tuple, list]):\n self.algorithm_name = algorithm_name\n self.keys = keys\n self.value = value\n\n if algorithm_name == Algorithm.RSA:\n cs = RSA(keys=keys)\n elif algorithm_name == Algorithm.ElGamal:\n cs = ElGamal(keys=keys)\n elif algorithm_name == Algorithm.ExponentialElGamal:\n cs = ElGamal(keys=keys, exponential=True)\n elif algorithm_name == Algorithm.EllipticCurveElGamal:\n cs = EllipticCurveElGamal(keys=keys)\n elif algorithm_name == Algorithm.Paillier:\n cs = Paillier(keys=keys)\n elif algorithm_name == Algorithm.DamgardJurik:\n cs = DamgardJurik(keys=keys)\n elif algorithm_name == Algorithm.OkamotoUchiyama:\n cs = OkamotoUchiyama(keys=keys)\n elif algorithm_name == Algorithm.Benaloh:\n cs = Benaloh(keys=keys)\n elif algorithm_name == Algorithm.NaccacheStern:\n cs = NaccacheStern(keys=keys)\n elif algorithm_name == Algorithm.GoldwasserMicali:\n cs = GoldwasserMicali(keys=keys)\n else:\n raise ValueError(f\"unimplemented algorithm - {algorithm_name}\")\n\n self.cs: Homomorphic = cs\n\n def __str__(self) -> str:\n return f\"Ciphertext({self.value})\"\n\n def __repr__(self) -> str:\n return f\"Ciphertext({self.value})\"\n\n def __add__(self, other: \"Ciphertext\") -> \"Ciphertext\":\n \"\"\"\n Perform homomorphic addition methods\n Args:\n other (Ciperhtext): some other ciphertext\n Returns:\n ciphertext (Ciphertext): homomorphic addition of ciphertext\n \"\"\"\n if self.cs.keys.get(\"public_key\") is None:\n raise ValueError(\"You must have public key to perform homomorphic addition\")\n\n result = self.cs.add(ciphertext1=self.value, ciphertext2=other.value)\n return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)\n\n def __mul__(self, other: Union[\"Ciphertext\", int, float]) -> \"Ciphertext\":\n \"\"\"\n Perform homomorphic multiplication or multiply a ciphertext with a known constant\n Args:\n other (int | float | Ciphertext): a known plain constant of some other ciphertext\n Returns\n homomorphic multiplication of ciphertexts | scalar multiplication of ciphertext\n \"\"\"\n if self.cs.keys.get(\"public_key\") is None:\n raise ValueError(\"You must have public key to perform homomorphic multiplication\")\n\n if isinstance(other, Ciphertext):\n # Handle multiplication with another EncryptedObject\n result = self.cs.multiply(ciphertext1=self.value, ciphertext2=other.value)\n elif isinstance(other, int):\n result = self.cs.multiply_by_contant(ciphertext=self.value, constant=other)\n elif isinstance(other, float):\n"},"all_code":{"kind":"string","value":"\nlogger = Logger(module=\"lightphe/models/Ciphertext.py\")\n\n# pylint: disable=too-few-public-methods, no-else-return\n\n\nclass Ciphertext:\n def __init__(self, algorithm_name: str, keys: dict, value: Union[int, tuple, list]):\n self.algorithm_name = algorithm_name\n self.keys = keys\n self.value = value\n\n if algorithm_name == Algorithm.RSA:\n cs = RSA(keys=keys)\n elif algorithm_name == Algorithm.ElGamal:\n cs = ElGamal(keys=keys)\n elif algorithm_name == Algorithm.ExponentialElGamal:\n cs = ElGamal(keys=keys, exponential=True)\n elif algorithm_name == Algorithm.EllipticCurveElGamal:\n cs = EllipticCurveElGamal(keys=keys)\n elif algorithm_name == Algorithm.Paillier:\n cs = Paillier(keys=keys)\n elif algorithm_name == Algorithm.DamgardJurik:\n cs = DamgardJurik(keys=keys)\n elif algorithm_name == Algorithm.OkamotoUchiyama:\n cs = OkamotoUchiyama(keys=keys)\n elif algorithm_name == Algorithm.Benaloh:\n cs = Benaloh(keys=keys)\n elif algorithm_name == Algorithm.NaccacheStern:\n cs = NaccacheStern(keys=keys)\n elif algorithm_name == Algorithm.GoldwasserMicali:\n cs = GoldwasserMicali(keys=keys)\n else:\n raise ValueError(f\"unimplemented algorithm - {algorithm_name}\")\n\n self.cs: Homomorphic = cs\n\n def __str__(self) -> str:\n return f\"Ciphertext({self.value})\"\n\n def __repr__(self) -> str:\n return f\"Ciphertext({self.value})\"\n\n def __add__(self, other: \"Ciphertext\") -> \"Ciphertext\":\n \"\"\"\n Perform homomorphic addition methods\n Args:\n other (Ciperhtext): some other ciphertext\n Returns:\n ciphertext (Ciphertext): homomorphic addition of ciphertext\n \"\"\"\n if self.cs.keys.get(\"public_key\") is None:\n raise ValueError(\"You must have public key to perform homomorphic addition\")\n\n result = self.cs.add(ciphertext1=self.value, ciphertext2=other.value)\n return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)\n\n def __mul__(self, other: Union[\"Ciphertext\", int, float]) -> \"Ciphertext\":\n \"\"\"\n Perform homomorphic multiplication or multiply a ciphertext with a known constant\n Args:\n other (int | float | Ciphertext): a known plain constant of some other ciphertext\n Returns\n homomorphic multiplication of ciphertexts | scalar multiplication of ciphertext\n \"\"\"\n if self.cs.keys.get(\"public_key\") is None:\n raise ValueError(\"You must have public key to perform homomorphic multiplication\")\n\n if isinstance(other, Ciphertext):\n # Handle multiplication with another EncryptedObject\n result = self.cs.multiply(ciphertext1=self.value, ciphertext2=other.value)\n elif isinstance(other, int):\n result = self.cs.multiply_by_contant(ciphertext=self.value, constant=other)\n elif isinstance(other, float):"},"next_line":{"kind":"string","value":" constant = phe_utils.parse_int(value=other, modulo=self.cs.plaintext_modulo)"},"gold_snippet_index":{"kind":"number","value":11,"string":"11"},"created_at":{"kind":"string","value":"2023-10-28 14:57:59+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5692,"cells":{"repo_name":{"kind":"string","value":"chenran-li/RQL-release"},"file_path":{"kind":"string","value":"stable_baselines3/sac_residual/sac_residual.py"},"context":{"kind":"list like","value":[{"identifier":"ReplayBuffer","path":"stable_baselines3/common/buffers.py","snippet":"class ReplayBuffer(BaseBuffer):\n \"\"\"\n Replay buffer used in off-policy algorithms like SAC/TD3.\n\n :param buffer_size: Max number of element in the buffer\n :param observation_space: Observation space\n :param action_space: Action space\n :param device: PyTorch device\n :param n_envs: Number of parallel environments\n :param optimize_memory_usage: Enable a memory efficient variant\n of the replay buffer which reduces by almost a factor two the memory used,\n at a cost of more complexity.\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\n and https://github.com/DLR-RM/stable-baselines3/pull/28#issuecomment-637559274\n Cannot be used in combination with handle_timeout_termination.\n :param handle_timeout_termination: Handle timeout termination (due to timelimit)\n separately and treat the task as infinite horizon task.\n https://github.com/DLR-RM/stable-baselines3/issues/284\n \"\"\"\n\n def __init__(\n self,\n buffer_size: int,\n observation_space: spaces.Space,\n action_space: spaces.Space,\n device: Union[th.device, str] = \"auto\",\n n_envs: int = 1,\n optimize_memory_usage: bool = False,\n handle_timeout_termination: bool = True,\n ):\n super().__init__(buffer_size, observation_space, action_space, device, n_envs=n_envs)\n\n # Adjust buffer size\n self.buffer_size = max(buffer_size // n_envs, 1)\n\n # Check that the replay buffer can fit into the memory\n if psutil is not None:\n mem_available = psutil.virtual_memory().available\n\n # there is a bug if both optimize_memory_usage and handle_timeout_termination are true\n # see https://github.com/DLR-RM/stable-baselines3/issues/934\n if optimize_memory_usage and handle_timeout_termination:\n raise ValueError(\n \"ReplayBuffer does not support optimize_memory_usage = True \"\n \"and handle_timeout_termination = True simultaneously.\"\n )\n self.optimize_memory_usage = optimize_memory_usage\n\n self.observations = np.zeros((self.buffer_size, self.n_envs) + self.obs_shape, dtype=observation_space.dtype)\n\n if optimize_memory_usage:\n # `observations` contains also the next observation\n self.next_observations = None\n else:\n self.next_observations = np.zeros((self.buffer_size, self.n_envs) + self.obs_shape, dtype=observation_space.dtype)\n\n self.actions = np.zeros((self.buffer_size, self.n_envs, self.action_dim), dtype=action_space.dtype)\n\n self.rewards = np.zeros((self.buffer_size, self.n_envs), dtype=np.float32)\n self.dones = np.zeros((self.buffer_size, self.n_envs), dtype=np.float32)\n # Handle timeouts termination properly if needed\n # see https://github.com/DLR-RM/stable-baselines3/issues/284\n self.handle_timeout_termination = handle_timeout_termination\n self.timeouts = np.zeros((self.buffer_size, self.n_envs), dtype=np.float32)\n\n if psutil is not None:\n total_memory_usage = self.observations.nbytes + self.actions.nbytes + self.rewards.nbytes + self.dones.nbytes\n\n if self.next_observations is not None:\n total_memory_usage += self.next_observations.nbytes\n\n if total_memory_usage > mem_available:\n # Convert to GB\n total_memory_usage /= 1e9\n mem_available /= 1e9\n warnings.warn(\n \"This system does not have apparently enough memory to store the complete \"\n f\"replay buffer {total_memory_usage:.2f}GB > {mem_available:.2f}GB\"\n )\n\n def add(\n self,\n obs: np.ndarray,\n next_obs: np.ndarray,\n action: np.ndarray,\n reward: np.ndarray,\n done: np.ndarray,\n infos: List[Dict[str, Any]],\n ) -> None:\n\n # Reshape needed when using multiple envs with discrete observations\n # as numpy cannot broadcast (n_discrete,) to (n_discrete, 1)\n if isinstance(self.observation_space, spaces.Discrete):\n obs = obs.reshape((self.n_envs,) + self.obs_shape)\n next_obs = next_obs.reshape((self.n_envs,) + self.obs_shape)\n\n # Same, for actions\n action = action.reshape((self.n_envs, self.action_dim))\n\n # Copy to avoid modification by reference\n self.observations[self.pos] = np.array(obs).copy()\n\n if self.optimize_memory_usage:\n self.observations[(self.pos + 1) % self.buffer_size] = np.array(next_obs).copy()\n else:\n self.next_observations[self.pos] = np.array(next_obs).copy()\n\n self.actions[self.pos] = np.array(action).copy()\n self.rewards[self.pos] = np.array(reward).copy()\n self.dones[self.pos] = np.array(done).copy()\n\n if self.handle_timeout_termination:\n self.timeouts[self.pos] = np.array([info.get(\"TimeLimit.truncated\", False) for info in infos])\n\n self.pos += 1\n if self.pos == self.buffer_size:\n self.full = True\n self.pos = 0\n\n def sample(self, batch_size: int, env: Optional[VecNormalize] = None) -> ReplayBufferSamples:\n \"\"\"\n Sample elements from the replay buffer.\n Custom sampling when using memory efficient variant,\n as we should not sample the element with index `self.pos`\n See https://github.com/DLR-RM/stable-baselines3/pull/28#issuecomment-637559274\n\n :param batch_size: Number of element to sample\n :param env: associated gym VecEnv\n to normalize the observations/rewards when sampling\n :return:\n \"\"\"\n if not self.optimize_memory_usage:\n return super().sample(batch_size=batch_size, env=env)\n # Do not sample the element with index `self.pos` as the transitions is invalid\n # (we use only one array to store `obs` and `next_obs`)\n if self.full:\n batch_inds = (np.random.randint(1, self.buffer_size, size=batch_size) + self.pos) % self.buffer_size\n else:\n batch_inds = np.random.randint(0, self.pos, size=batch_size)\n return self._get_samples(batch_inds, env=env)\n\n def _get_samples(self, batch_inds: np.ndarray, env: Optional[VecNormalize] = None) -> ReplayBufferSamples:\n # Sample randomly the env idx\n env_indices = np.random.randint(0, high=self.n_envs, size=(len(batch_inds),))\n\n if self.optimize_memory_usage:\n next_obs = self._normalize_obs(self.observations[(batch_inds + 1) % self.buffer_size, env_indices, :], env)\n else:\n next_obs = self._normalize_obs(self.next_observations[batch_inds, env_indices, :], env)\n\n data = (\n self._normalize_obs(self.observations[batch_inds, env_indices, :], env),\n self.actions[batch_inds, env_indices, :],\n next_obs,\n # Only use dones that are not due to timeouts\n # deactivated by default (timeouts is initialized as an array of False)\n (self.dones[batch_inds, env_indices] * (1 - self.timeouts[batch_inds, env_indices])).reshape(-1, 1),\n self._normalize_reward(self.rewards[batch_inds, env_indices].reshape(-1, 1), env),\n )\n return ReplayBufferSamples(*tuple(map(self.to_torch, data)))"},{"identifier":"ActionNoise","path":"stable_baselines3/common/noise.py","snippet":"class ActionNoise(ABC):\n \"\"\"\n The action noise base class\n \"\"\"\n\n def __init__(self) -> None:\n super().__init__()\n\n def reset(self) -> None:\n \"\"\"\n call end of episode reset for the noise\n \"\"\"\n pass\n\n @abstractmethod\n def __call__(self) -> np.ndarray:\n raise NotImplementedError()"},{"identifier":"OffPolicyAlgorithm","path":"stable_baselines3/common/off_policy_algorithm.py","snippet":"class OffPolicyAlgorithm(BaseAlgorithm):\n \"\"\"\n The base for Off-Policy algorithms (ex: SAC/TD3)\n\n :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)\n :param env: The environment to learn from\n (if registered in Gym, can be str. Can be None for loading trained models)\n :param learning_rate: learning rate for the optimizer,\n it can be a function of the current progress remaining (from 1 to 0)\n :param buffer_size: size of the replay buffer\n :param learning_starts: how many steps of the model to collect transitions for before learning starts\n :param batch_size: Minibatch size for each gradient update\n :param tau: the soft update coefficient (\"Polyak update\", between 0 and 1)\n :param gamma: the discount factor\n :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit\n like ``(5, \"step\")`` or ``(2, \"episode\")``.\n :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)\n Set to ``-1`` means to do as many gradient steps as steps done in the environment\n during the rollout.\n :param action_noise: the action noise type (None by default), this can help\n for hard exploration problem. Cf common.noise for the different action noise type.\n :param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).\n If ``None``, it will be automatically selected.\n :param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.\n :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer\n at a cost of more complexity.\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\n :param policy_kwargs: Additional arguments to be passed to the policy on creation\n :param tensorboard_log: the log location for tensorboard (if None, no logging)\n :param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for\n debug messages\n :param device: Device on which the code should run.\n By default, it will try to use a Cuda compatible device and fallback to cpu\n if it is not possible.\n :param support_multi_env: Whether the algorithm supports training\n with multiple environments (as in A2C)\n :param monitor_wrapper: When creating an environment, whether to wrap it\n or not in a Monitor wrapper.\n :param seed: Seed for the pseudo random generators\n :param use_sde: Whether to use State Dependent Exploration (SDE)\n instead of action noise exploration (default: False)\n :param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE\n Default: -1 (only sample at the beginning of the rollout)\n :param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling\n during the warm up phase (before learning starts)\n :param sde_support: Whether the model support gSDE or not\n :param supported_action_spaces: The action spaces supported by the algorithm.\n \"\"\"\n\n def __init__(\n self,\n policy: Union[str, Type[BasePolicy]],\n env: Union[GymEnv, str],\n learning_rate: Union[float, Schedule],\n buffer_size: int = 1_000_000, # 1e6\n learning_starts: int = 100,\n batch_size: int = 256,\n tau: float = 0.005,\n gamma: float = 0.99,\n train_freq: Union[int, Tuple[int, str]] = (1, \"step\"),\n gradient_steps: int = 1,\n action_noise: Optional[ActionNoise] = None,\n replay_buffer_class: Optional[Type[ReplayBuffer]] = None,\n replay_buffer_kwargs: Optional[Dict[str, Any]] = None,\n optimize_memory_usage: bool = False,\n policy_kwargs: Optional[Dict[str, Any]] = None,\n tensorboard_log: Optional[str] = None,\n verbose: int = 0,\n device: Union[th.device, str] = \"auto\",\n support_multi_env: bool = False,\n monitor_wrapper: bool = True,\n seed: Optional[int] = None,\n use_sde: bool = False,\n sde_sample_freq: int = -1,\n use_sde_at_warmup: bool = False,\n sde_support: bool = True,\n supported_action_spaces: Optional[Tuple[spaces.Space, ...]] = None,\n ):\n\n super().__init__(\n policy=policy,\n env=env,\n learning_rate=learning_rate,\n policy_kwargs=policy_kwargs,\n tensorboard_log=tensorboard_log,\n verbose=verbose,\n device=device,\n support_multi_env=support_multi_env,\n monitor_wrapper=monitor_wrapper,\n seed=seed,\n use_sde=use_sde,\n sde_sample_freq=sde_sample_freq,\n supported_action_spaces=supported_action_spaces,\n )\n self.buffer_size = buffer_size\n self.batch_size = batch_size\n self.learning_starts = learning_starts\n self.tau = tau\n self.gamma = gamma\n self.gradient_steps = gradient_steps\n self.action_noise = action_noise\n self.optimize_memory_usage = optimize_memory_usage\n self.replay_buffer_class = replay_buffer_class\n if replay_buffer_kwargs is None:\n replay_buffer_kwargs = {}\n self.replay_buffer_kwargs = replay_buffer_kwargs\n self._episode_storage = None\n\n # Save train freq parameter, will be converted later to TrainFreq object\n self.train_freq = train_freq\n\n self.actor = None # type: Optional[th.nn.Module]\n self.replay_buffer = None # type: Optional[ReplayBuffer]\n # Update policy keyword arguments\n if sde_support:\n self.policy_kwargs[\"use_sde\"] = self.use_sde\n # For gSDE only\n self.use_sde_at_warmup = use_sde_at_warmup\n\n def _convert_train_freq(self) -> None:\n \"\"\"\n Convert `train_freq` parameter (int or tuple)\n to a TrainFreq object.\n \"\"\"\n if not isinstance(self.train_freq, TrainFreq):\n train_freq = self.train_freq\n\n # The value of the train frequency will be checked later\n if not isinstance(train_freq, tuple):\n train_freq = (train_freq, \"step\")\n\n try:\n train_freq = (train_freq[0], TrainFrequencyUnit(train_freq[1]))\n except ValueError as e:\n raise ValueError(\n f\"The unit of the `train_freq` must be either 'step' or 'episode' not '{train_freq[1]}'!\"\n ) from e\n\n if not isinstance(train_freq[0], int):\n raise ValueError(f\"The frequency of `train_freq` must be an integer and not {train_freq[0]}\")\n\n self.train_freq = TrainFreq(*train_freq)\n\n def _setup_model(self) -> None:\n self._setup_lr_schedule()\n self.set_random_seed(self.seed)\n\n # Use DictReplayBuffer if needed\n if self.replay_buffer_class is None:\n if isinstance(self.observation_space, spaces.Dict):\n self.replay_buffer_class = DictReplayBuffer\n else:\n self.replay_buffer_class = ReplayBuffer\n\n elif self.replay_buffer_class == HerReplayBuffer:\n assert self.env is not None, \"You must pass an environment when using `HerReplayBuffer`\"\n\n # If using offline sampling, we need a classic replay buffer too\n if self.replay_buffer_kwargs.get(\"online_sampling\", True):\n replay_buffer = None\n else:\n replay_buffer = DictReplayBuffer(\n self.buffer_size,\n self.observation_space,\n self.action_space,\n device=self.device,\n optimize_memory_usage=self.optimize_memory_usage,\n )\n\n self.replay_buffer = HerReplayBuffer(\n self.env,\n self.buffer_size,\n device=self.device,\n replay_buffer=replay_buffer,\n **self.replay_buffer_kwargs,\n )\n\n if self.replay_buffer is None:\n self.replay_buffer = self.replay_buffer_class(\n self.buffer_size,\n self.observation_space,\n self.action_space,\n device=self.device,\n n_envs=self.n_envs,\n optimize_memory_usage=self.optimize_memory_usage,\n **self.replay_buffer_kwargs,\n )\n\n self.policy = self.policy_class( # pytype:disable=not-instantiable\n self.observation_space,\n self.action_space,\n self.lr_schedule,\n **self.policy_kwargs, # pytype:disable=not-instantiable\n )\n self.policy = self.policy.to(self.device)\n\n # Convert train freq parameter to TrainFreq object\n self._convert_train_freq()\n\n def save_replay_buffer(self, path: Union[str, pathlib.Path, io.BufferedIOBase]) -> None:\n \"\"\"\n Save the replay buffer as a pickle file.\n\n :param path: Path to the file where the replay buffer should be saved.\n if path is a str or pathlib.Path, the path is automatically created if necessary.\n \"\"\"\n assert self.replay_buffer is not None, \"The replay buffer is not defined\"\n save_to_pkl(path, self.replay_buffer, self.verbose)\n\n def load_replay_buffer(\n self,\n path: Union[str, pathlib.Path, io.BufferedIOBase],\n truncate_last_traj: bool = True,\n ) -> None:\n \"\"\"\n Load a replay buffer from a pickle file.\n\n :param path: Path to the pickled replay buffer.\n :param truncate_last_traj: When using ``HerReplayBuffer`` with online sampling:\n If set to ``True``, we assume that the last trajectory in the replay buffer was finished\n (and truncate it).\n If set to ``False``, we assume that we continue the same trajectory (same episode).\n \"\"\"\n self.replay_buffer = load_from_pkl(path, self.verbose)\n assert isinstance(self.replay_buffer, ReplayBuffer), \"The replay buffer must inherit from ReplayBuffer class\"\n\n # Backward compatibility with SB3 < 2.1.0 replay buffer\n # Keep old behavior: do not handle timeout termination separately\n if not hasattr(self.replay_buffer, \"handle_timeout_termination\"): # pragma: no cover\n self.replay_buffer.handle_timeout_termination = False\n self.replay_buffer.timeouts = np.zeros_like(self.replay_buffer.dones)\n\n if isinstance(self.replay_buffer, HerReplayBuffer):\n assert self.env is not None, \"You must pass an environment at load time when using `HerReplayBuffer`\"\n self.replay_buffer.set_env(self.get_env())\n if truncate_last_traj:\n self.replay_buffer.truncate_last_trajectory()\n\n def _setup_learn(\n self,\n total_timesteps: int,\n callback: MaybeCallback = None,\n reset_num_timesteps: bool = True,\n tb_log_name: str = \"run\",\n progress_bar: bool = False,\n ) -> Tuple[int, BaseCallback]:\n \"\"\"\n cf `BaseAlgorithm`.\n \"\"\"\n # Prevent continuity issue by truncating trajectory\n # when using memory efficient replay buffer\n # see https://github.com/DLR-RM/stable-baselines3/issues/46\n\n # Special case when using HerReplayBuffer,\n # the classic replay buffer is inside it when using offline sampling\n if isinstance(self.replay_buffer, HerReplayBuffer):\n replay_buffer = self.replay_buffer.replay_buffer\n else:\n replay_buffer = self.replay_buffer\n\n truncate_last_traj = (\n self.optimize_memory_usage\n and reset_num_timesteps\n and replay_buffer is not None\n and (replay_buffer.full or replay_buffer.pos > 0)\n )\n\n if truncate_last_traj:\n warnings.warn(\n \"The last trajectory in the replay buffer will be truncated, \"\n \"see https://github.com/DLR-RM/stable-baselines3/issues/46.\"\n \"You should use `reset_num_timesteps=False` or `optimize_memory_usage=False`\"\n \"to avoid that issue.\"\n )\n # Go to the previous index\n pos = (replay_buffer.pos - 1) % replay_buffer.buffer_size\n replay_buffer.dones[pos] = True\n\n return super()._setup_learn(\n total_timesteps,\n callback,\n reset_num_timesteps,\n tb_log_name,\n progress_bar,\n )\n\n def learn(\n self: SelfOffPolicyAlgorithm,\n total_timesteps: int,\n callback: MaybeCallback = None,\n log_interval: int = 4,\n tb_log_name: str = \"run\",\n reset_num_timesteps: bool = True,\n progress_bar: bool = False,\n ) -> SelfOffPolicyAlgorithm:\n\n total_timesteps, callback = self._setup_learn(\n total_timesteps,\n callback,\n reset_num_timesteps,\n tb_log_name,\n progress_bar,\n )\n\n callback.on_training_start(locals(), globals())\n\n while self.num_timesteps < total_timesteps:\n rollout = self.collect_rollouts(\n self.env,\n train_freq=self.train_freq,\n action_noise=self.action_noise,\n callback=callback,\n learning_starts=self.learning_starts,\n replay_buffer=self.replay_buffer,\n log_interval=log_interval,\n )\n\n if rollout.continue_training is False:\n break\n\n if self.num_timesteps > 0 and self.num_timesteps > self.learning_starts:\n # If no `gradient_steps` is specified,\n # do as many gradients steps as steps performed during the rollout\n gradient_steps = self.gradient_steps if self.gradient_steps >= 0 else rollout.episode_timesteps\n # Special case when the user passes `gradient_steps=0`\n if gradient_steps > 0:\n self.train(batch_size=self.batch_size, gradient_steps=gradient_steps)\n\n callback.on_training_end()\n\n return self\n\n def train(self, gradient_steps: int, batch_size: int) -> None:\n \"\"\"\n Sample the replay buffer and do the updates\n (gradient descent and update target networks)\n \"\"\"\n raise NotImplementedError()\n\n def _sample_action(\n self,\n learning_starts: int,\n action_noise: Optional[ActionNoise] = None,\n n_envs: int = 1,\n ) -> Tuple[np.ndarray, np.ndarray]:\n \"\"\"\n Sample an action according to the exploration policy.\n This is either done by sampling the probability distribution of the policy,\n or sampling a random action (from a uniform distribution over the action space)\n or by adding noise to the deterministic output.\n\n :param action_noise: Action noise that will be used for exploration\n Required for deterministic policy (e.g. TD3). This can also be used\n in addition to the stochastic policy for SAC.\n :param learning_starts: Number of steps before learning for the warm-up phase.\n :param n_envs:\n :return: action to take in the environment\n and scaled action that will be stored in the replay buffer.\n The two differs when the action space is not normalized (bounds are not [-1, 1]).\n \"\"\"\n # Select action randomly or according to policy\n if self.num_timesteps < learning_starts and not (self.use_sde and self.use_sde_at_warmup):\n # Warmup phase\n unscaled_action = np.array([self.action_space.sample() for _ in range(n_envs)])\n else:\n # Note: when using continuous actions,\n # we assume that the policy uses tanh to scale the action\n # We use non-deterministic action in the case of SAC, for TD3, it does not matter\n unscaled_action, _ = self.predict(self._last_obs, deterministic=False)\n\n # Rescale the action from [low, high] to [-1, 1]\n if isinstance(self.action_space, spaces.Box):\n scaled_action = self.policy.scale_action(unscaled_action)\n\n # Add noise to the action (improve exploration)\n if action_noise is not None:\n scaled_action = np.clip(scaled_action + action_noise(), -1, 1)\n\n # We store the scaled action in the buffer\n buffer_action = scaled_action\n action = self.policy.unscale_action(scaled_action)\n else:\n # Discrete case, no need to normalize or clip\n buffer_action = unscaled_action\n action = buffer_action\n return action, buffer_action\n\n def _dump_logs(self) -> None:\n \"\"\"\n Write log.\n \"\"\"\n time_elapsed = max((time.time_ns() - self.start_time) / 1e9, sys.float_info.epsilon)\n fps = int((self.num_timesteps - self._num_timesteps_at_start) / time_elapsed)\n self.logger.record(\"time/episodes\", self._episode_num, exclude=\"tensorboard\")\n if len(self.ep_info_buffer) > 0 and len(self.ep_info_buffer[0]) > 0:\n self.logger.record(\"rollout/ep_rew_mean\", safe_mean([ep_info[\"r\"] for ep_info in self.ep_info_buffer]))\n self.logger.record(\"rollout/ep_len_mean\", safe_mean([ep_info[\"l\"] for ep_info in self.ep_info_buffer]))\n self.logger.record(\"time/fps\", fps)\n self.logger.record(\"time/time_elapsed\", int(time_elapsed), exclude=\"tensorboard\")\n self.logger.record(\"time/total_timesteps\", self.num_timesteps, exclude=\"tensorboard\")\n if self.use_sde:\n self.logger.record(\"train/std\", (self.actor.get_std()).mean().item())\n\n if len(self.ep_success_buffer) > 0:\n self.logger.record(\"rollout/success_rate\", safe_mean(self.ep_success_buffer))\n # Pass the number of timesteps for tensorboard\n self.logger.dump(step=self.num_timesteps)\n\n def _on_step(self) -> None:\n \"\"\"\n Method called after each step in the environment.\n It is meant to trigger DQN target network update\n but can be used for other purposes\n \"\"\"\n pass\n\n def _store_transition(\n self,\n replay_buffer: ReplayBuffer,\n buffer_action: np.ndarray,\n new_obs: Union[np.ndarray, Dict[str, np.ndarray]],\n reward: np.ndarray,\n dones: np.ndarray,\n infos: List[Dict[str, Any]],\n ) -> None:\n \"\"\"\n Store transition in the replay buffer.\n We store the normalized action and the unnormalized observation.\n It also handles terminal observations (because VecEnv resets automatically).\n\n :param replay_buffer: Replay buffer object where to store the transition.\n :param buffer_action: normalized action\n :param new_obs: next observation in the current episode\n or first observation of the episode (when dones is True)\n :param reward: reward for the current transition\n :param dones: Termination signal\n :param infos: List of additional information about the transition.\n It may contain the terminal observations and information about timeout.\n \"\"\"\n # Store only the unnormalized version\n if self._vec_normalize_env is not None:\n new_obs_ = self._vec_normalize_env.get_original_obs()\n reward_ = self._vec_normalize_env.get_original_reward()\n else:\n # Avoid changing the original ones\n self._last_original_obs, new_obs_, reward_ = self._last_obs, new_obs, reward\n\n # Avoid modification by reference\n next_obs = deepcopy(new_obs_)\n # As the VecEnv resets automatically, new_obs is already the\n # first observation of the next episode\n for i, done in enumerate(dones):\n if done and infos[i].get(\"terminal_observation\") is not None:\n if isinstance(next_obs, dict):\n next_obs_ = infos[i][\"terminal_observation\"]\n # VecNormalize normalizes the terminal observation\n if self._vec_normalize_env is not None:\n next_obs_ = self._vec_normalize_env.unnormalize_obs(next_obs_)\n # Replace next obs for the correct envs\n for key in next_obs.keys():\n next_obs[key][i] = next_obs_[key]\n else:\n next_obs[i] = infos[i][\"terminal_observation\"]\n # VecNormalize normalizes the terminal observation\n if self._vec_normalize_env is not None:\n next_obs[i] = self._vec_normalize_env.unnormalize_obs(next_obs[i, :])\n\n replay_buffer.add(\n self._last_original_obs,\n next_obs,\n buffer_action,\n reward_,\n dones,\n infos,\n )\n\n self._last_obs = new_obs\n # Save the unnormalized observation\n if self._vec_normalize_env is not None:\n self._last_original_obs = new_obs_\n\n def collect_rollouts(\n self,\n env: VecEnv,\n callback: BaseCallback,\n train_freq: TrainFreq,\n replay_buffer: ReplayBuffer,\n action_noise: Optional[ActionNoise] = None,\n learning_starts: int = 0,\n log_interval: Optional[int] = None,\n ) -> RolloutReturn:\n \"\"\"\n Collect experiences and store them into a ``ReplayBuffer``.\n\n :param env: The training environment\n :param callback: Callback that will be called at each step\n (and at the beginning and end of the rollout)\n :param train_freq: How much experience to collect\n by doing rollouts of current policy.\n Either ``TrainFreq(<n>, TrainFrequencyUnit.STEP)``\n or ``TrainFreq(<n>, TrainFrequencyUnit.EPISODE)``\n with ``<n>`` being an integer greater than 0.\n :param action_noise: Action noise that will be used for exploration\n Required for deterministic policy (e.g. TD3). This can also be used\n in addition to the stochastic policy for SAC.\n :param learning_starts: Number of steps before learning for the warm-up phase.\n :param replay_buffer:\n :param log_interval: Log data every ``log_interval`` episodes\n :return:\n \"\"\"\n # Switch to eval mode (this affects batch norm / dropout)\n self.policy.set_training_mode(False)\n\n num_collected_steps, num_collected_episodes = 0, 0\n\n assert isinstance(env, VecEnv), \"You must pass a VecEnv\"\n assert train_freq.frequency > 0, \"Should at least collect one step or episode.\"\n\n if env.num_envs > 1:\n assert train_freq.unit == TrainFrequencyUnit.STEP, \"You must use only one env when doing episodic training.\"\n\n # Vectorize action noise if needed\n if action_noise is not None and env.num_envs > 1 and not isinstance(action_noise, VectorizedActionNoise):\n action_noise = VectorizedActionNoise(action_noise, env.num_envs)\n\n if self.use_sde:\n self.actor.reset_noise(env.num_envs)\n\n callback.on_rollout_start()\n continue_training = True\n\n while should_collect_more_steps(train_freq, num_collected_steps, num_collected_episodes):\n if self.use_sde and self.sde_sample_freq > 0 and num_collected_steps % self.sde_sample_freq == 0:\n # Sample a new noise matrix\n self.actor.reset_noise(env.num_envs)\n\n # Select action randomly or according to policy\n actions, buffer_actions = self._sample_action(learning_starts, action_noise, env.num_envs)\n\n # Rescale and perform action\n new_obs, rewards, dones, infos = env.step(actions)\n\n self.num_timesteps += env.num_envs\n num_collected_steps += 1\n\n # Give access to local variables\n callback.update_locals(locals())\n # Only stop training if return value is False, not when it is None.\n if callback.on_step() is False:\n return RolloutReturn(num_collected_steps * env.num_envs, num_collected_episodes, continue_training=False)\n\n # Retrieve reward and episode length if using Monitor wrapper\n self._update_info_buffer(infos, dones)\n\n # Store data in replay buffer (normalized action and unnormalized observation)\n self._store_transition(replay_buffer, buffer_actions, new_obs, rewards, dones, infos)\n\n self._update_current_progress_remaining(self.num_timesteps, self._total_timesteps)\n\n # For DQN, check if the target network should be updated\n # and update the exploration schedule\n # For SAC/TD3, the update is dones as the same time as the gradient update\n # see https://github.com/hill-a/stable-baselines/issues/900\n self._on_step()\n\n for idx, done in enumerate(dones):\n if done:\n # Update stats\n num_collected_episodes += 1\n self._episode_num += 1\n\n if action_noise is not None:\n kwargs = dict(indices=[idx]) if env.num_envs > 1 else {}\n action_noise.reset(**kwargs)\n\n # Log training infos\n if log_interval is not None and self._episode_num % log_interval == 0:\n self._dump_logs()\n callback.on_rollout_end()\n\n return RolloutReturn(num_collected_steps * env.num_envs, num_collected_episodes, continue_training)"},{"identifier":"BasePolicy","path":"stable_baselines3/common/policies.py","snippet":"class BasePolicy(BaseModel, ABC):\n \"\"\"The base policy object.\n\n Parameters are mostly the same as `BaseModel`; additions are documented below.\n\n :param args: positional arguments passed through to `BaseModel`.\n :param kwargs: keyword arguments passed through to `BaseModel`.\n :param squash_output: For continuous actions, whether the output is squashed\n or not using a ``tanh()`` function.\n \"\"\"\n\n def __init__(self, *args, squash_output: bool = False, **kwargs):\n super().__init__(*args, **kwargs)\n self._squash_output = squash_output\n\n @staticmethod\n def _dummy_schedule(progress_remaining: float) -> float:\n \"\"\"(float) Useful for pickling policy.\"\"\"\n del progress_remaining\n return 0.0\n\n @property\n def squash_output(self) -> bool:\n \"\"\"(bool) Getter for squash_output.\"\"\"\n return self._squash_output\n\n @staticmethod\n def init_weights(module: nn.Module, gain: float = 1) -> None:\n \"\"\"\n Orthogonal initialization (used in PPO and A2C)\n \"\"\"\n if isinstance(module, (nn.Linear, nn.Conv2d)):\n nn.init.orthogonal_(module.weight, gain=gain)\n if module.bias is not None:\n module.bias.data.fill_(0.0)\n\n @abstractmethod\n def _predict(self, observation: th.Tensor, deterministic: bool = False) -> th.Tensor:\n \"\"\"\n Get the action according to the policy for a given observation.\n\n By default provides a dummy implementation -- not all BasePolicy classes\n implement this, e.g. if they are a Critic in an Actor-Critic method.\n\n :param observation:\n :param deterministic: Whether to use stochastic or deterministic actions\n :return: Taken action according to the policy\n \"\"\"\n\n def predict(\n self,\n observation: Union[np.ndarray, Dict[str, np.ndarray]],\n state: Optional[Tuple[np.ndarray, ...]] = None,\n episode_start: Optional[np.ndarray] = None,\n deterministic: bool = False,\n ) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, ...]]]:\n \"\"\"\n Get the policy action from an observation (and optional hidden state).\n Includes sugar-coating to handle different observations (e.g. normalizing images).\n\n :param observation: the input observation\n :param state: The last hidden states (can be None, used in recurrent policies)\n :param episode_start: The last masks (can be None, used in recurrent policies)\n this correspond to beginning of episodes,\n where the hidden states of the RNN must be reset.\n :param deterministic: Whether or not to return deterministic actions.\n :return: the model's action and the next hidden state\n (used in recurrent policies)\n \"\"\"\n # TODO (GH/1): add support for RNN policies\n # if state is None:\n # state = self.initial_state\n # if episode_start is None:\n # episode_start = [False for _ in range(self.n_envs)]\n # Switch to eval mode (this affects batch norm / dropout)\n self.set_training_mode(False)\n\n observation, vectorized_env = self.obs_to_tensor(observation)\n\n with th.no_grad():\n actions = self._predict(observation, deterministic=deterministic)\n # Convert to numpy, and reshape to the original action shape\n actions = actions.cpu().numpy().reshape((-1,) + self.action_space.shape)\n\n if isinstance(self.action_space, spaces.Box):\n if self.squash_output:\n # Rescale to proper domain when using squashing\n actions = self.unscale_action(actions)\n else:\n # Actions could be on arbitrary scale, so clip the actions to avoid\n # out of bound error (e.g. if sampling from a Gaussian distribution)\n actions = np.clip(actions, self.action_space.low, self.action_space.high)\n\n # Remove batch dimension if needed\n if not vectorized_env:\n actions = actions.squeeze(axis=0)\n\n return actions, state\n\n def scale_action(self, action: np.ndarray) -> np.ndarray:\n \"\"\"\n Rescale the action from [low, high] to [-1, 1]\n (no need for symmetric action space)\n\n :param action: Action to scale\n :return: Scaled action\n \"\"\"\n low, high = self.action_space.low, self.action_space.high\n return 2.0 * ((action - low) / (high - low)) - 1.0\n\n def unscale_action(self, scaled_action: np.ndarray) -> np.ndarray:\n \"\"\"\n Rescale the action from [-1, 1] to [low, high]\n (no need for symmetric action space)\n\n :param scaled_action: Action to un-scale\n \"\"\"\n low, high = self.action_space.low, self.action_space.high\n return low + (0.5 * (scaled_action + 1.0) * (high - low))"},{"identifier":"GymEnv","path":"stable_baselines3/common/type_aliases.py","snippet":"class RolloutBufferSamples(NamedTuple):\nclass DictRolloutBufferSamples(NamedTuple):\nclass ReplayBufferSamples(NamedTuple):\nclass DictReplayBufferSamples(NamedTuple):\nclass RolloutReturn(NamedTuple):\nclass TrainFrequencyUnit(Enum):\nclass TrainFreq(NamedTuple):\nclass PolicyPredictor(Protocol):\n STEP = \"step\"\n EPISODE = \"episode\"\n def predict(\n self,\n observation: Union[np.ndarray, Dict[str, np.ndarray]],\n state: Optional[Tuple[np.ndarray, ...]] = None,\n episode_start: Optional[np.ndarray] = None,\n deterministic: bool = False,\n ) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, ...]]]:"},{"identifier":"get_parameters_by_name","path":"stable_baselines3/common/utils.py","snippet":"def get_parameters_by_name(model: th.nn.Module, included_names: Iterable[str]) -> List[th.Tensor]:\n \"\"\"\n Extract parameters from the state dict of ``model``\n if the name contains one of the strings in ``included_names``.\n\n :param model: the model where the parameters come from.\n :param included_names: substrings of names to include.\n :return: List of parameters values (Pytorch tensors)\n that matches the queried names.\n \"\"\"\n return [param for name, param in model.state_dict().items() if any([key in name for key in included_names])]"},{"identifier":"polyak_update","path":"stable_baselines3/common/utils.py","snippet":"def polyak_update(\n params: Iterable[th.Tensor],\n target_params: Iterable[th.Tensor],\n tau: float,\n) -> None:\n \"\"\"\n Perform a Polyak average update on ``target_params`` using ``params``:\n target parameters are slowly updated towards the main parameters.\n ``tau``, the soft update coefficient controls the interpolation:\n ``tau=1`` corresponds to copying the parameters to the target ones whereas nothing happens when ``tau=0``.\n The Polyak update is done in place, with ``no_grad``, and therefore does not create intermediate tensors,\n or a computation graph, reducing memory cost and improving performance. We scale the target params\n by ``1-tau`` (in-place), add the new weights, scaled by ``tau`` and store the result of the sum in the target\n params (in place).\n See https://github.com/DLR-RM/stable-baselines3/issues/93\n\n :param params: parameters to use to update the target params\n :param target_params: parameters to update\n :param tau: the soft update coefficient (\"Polyak update\", between 0 and 1)\n \"\"\"\n with th.no_grad():\n # zip does not raise an exception if length of parameters does not match.\n for param, target_param in zip_strict(params, target_params):\n target_param.data.mul_(1 - tau)\n th.add(target_param.data, param.data, alpha=tau, out=target_param.data)"},{"identifier":"ResidualCnnPolicy","path":"stable_baselines3/sac_residual/policies.py","snippet":"LOG_STD_MAX = 2\nLOG_STD_MIN = -20\nclass ResidualSACPolicy(SACPolicy):\nclass ResidualCnnPolicy(ResidualSACPolicy):\nclass ResidualMultiInputPolicy(ResidualSACPolicy):\n def __init__(\n self,\n observation_space: spaces.Space,\n action_space: spaces.Space,\n lr_schedule: Schedule,\n net_arch: Optional[Union[List[int], Dict[str, List[int]]]] = None,\n activation_fn: Type[nn.Module] = nn.ReLU,\n use_sde: bool = False,\n log_std_init: float = -3,\n use_expln: bool = False,\n clip_mean: float = 2.0,\n features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,\n features_extractor_kwargs: Optional[Dict[str, Any]] = None,\n normalize_images: bool = True,\n optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,\n optimizer_kwargs: Optional[Dict[str, Any]] = None,\n n_critics: int = 2,\n share_features_extractor: bool = False,\n ):\n def __init__(\n self,\n observation_space: spaces.Space,\n action_space: spaces.Space,\n lr_schedule: Schedule,\n net_arch: Optional[Union[List[int], Dict[str, List[int]]]] = None,\n activation_fn: Type[nn.Module] = nn.ReLU,\n use_sde: bool = False,\n log_std_init: float = -3,\n use_expln: bool = False,\n clip_mean: float = 2.0,\n features_extractor_class: Type[BaseFeaturesExtractor] = NatureCNN,\n features_extractor_kwargs: Optional[Dict[str, Any]] = None,\n normalize_images: bool = True,\n optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,\n optimizer_kwargs: Optional[Dict[str, Any]] = None,\n n_critics: int = 2,\n share_features_extractor: bool = False,\n ):\n def __init__(\n self,\n observation_space: spaces.Space,\n action_space: spaces.Space,\n lr_schedule: Schedule,\n net_arch: Optional[Union[List[int], Dict[str, List[int]]]] = None,\n activation_fn: Type[nn.Module] = nn.ReLU,\n use_sde: bool = False,\n log_std_init: float = -3,\n use_expln: bool = False,\n clip_mean: float = 2.0,\n features_extractor_class: Type[BaseFeaturesExtractor] = CombinedExtractor,\n features_extractor_kwargs: Optional[Dict[str, Any]] = None,\n normalize_images: bool = True,\n optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,\n optimizer_kwargs: Optional[Dict[str, Any]] = None,\n n_critics: int = 2,\n share_features_extractor: bool = False,\n ):"},{"identifier":"SAC","path":"stable_baselines3/sac/sac.py","snippet":"class SAC(OffPolicyAlgorithm):\n \"\"\"\n Soft Actor-Critic (SAC)\n Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor,\n This implementation borrows code from original implementation (https://github.com/haarnoja/sac)\n from OpenAI Spinning Up (https://github.com/openai/spinningup), from the softlearning repo\n (https://github.com/rail-berkeley/softlearning/)\n and from Stable Baselines (https://github.com/hill-a/stable-baselines)\n Paper: https://arxiv.org/abs/1801.01290\n Introduction to SAC: https://spinningup.openai.com/en/latest/algorithms/sac.html\n\n Note: we use double q target and not value target as discussed\n in https://github.com/hill-a/stable-baselines/issues/270\n\n :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)\n :param env: The environment to learn from (if registered in Gym, can be str)\n :param learning_rate: learning rate for adam optimizer,\n the same learning rate will be used for all networks (Q-Values, Actor and Value function)\n it can be a function of the current progress remaining (from 1 to 0)\n :param buffer_size: size of the replay buffer\n :param learning_starts: how many steps of the model to collect transitions for before learning starts\n :param batch_size: Minibatch size for each gradient update\n :param tau: the soft update coefficient (\"Polyak update\", between 0 and 1)\n :param gamma: the discount factor\n :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit\n like ``(5, \"step\")`` or ``(2, \"episode\")``.\n :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)\n Set to ``-1`` means to do as many gradient steps as steps done in the environment\n during the rollout.\n :param action_noise: the action noise type (None by default), this can help\n for hard exploration problem. Cf common.noise for the different action noise type.\n :param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).\n If ``None``, it will be automatically selected.\n :param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.\n :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer\n at a cost of more complexity.\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\n :param ent_coef: Entropy regularization coefficient. (Equivalent to\n inverse of reward scale in the original SAC paper.) Controlling exploration/exploitation trade-off.\n Set it to 'auto' to learn it automatically (and 'auto_0.1' for using 0.1 as initial value)\n :param target_update_interval: update the target network every ``target_network_update_freq``\n gradient steps.\n :param target_entropy: target entropy when learning ``ent_coef`` (``ent_coef = 'auto'``)\n :param use_sde: Whether to use generalized State Dependent Exploration (gSDE)\n instead of action noise exploration (default: False)\n :param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE\n Default: -1 (only sample at the beginning of the rollout)\n :param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling\n during the warm up phase (before learning starts)\n :param policy_kwargs: additional arguments to be passed to the policy on creation\n :param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for\n debug messages\n :param seed: Seed for the pseudo random generators\n :param device: Device (cpu, cuda, ...) on which the code should be run.\n Setting it to auto, the code will be run on the GPU if possible.\n :param _init_setup_model: Whether or not to build the network at the creation of the instance\n \"\"\"\n\n policy_aliases: Dict[str, Type[BasePolicy]] = {\n \"MlpPolicy\": MlpPolicy,\n \"CnnPolicy\": CnnPolicy,\n \"MultiInputPolicy\": MultiInputPolicy,\n }\n\n def __init__(\n self,\n policy: Union[str, Type[SACPolicy]],\n env: Union[GymEnv, str],\n learning_rate: Union[float, Schedule] = 3e-4,\n buffer_size: int = 1_000_000, # 1e6\n learning_starts: int = 100,\n batch_size: int = 256,\n tau: float = 0.005,\n gamma: float = 0.99,\n train_freq: Union[int, Tuple[int, str]] = 1,\n gradient_steps: int = 1,\n action_noise: Optional[ActionNoise] = None,\n replay_buffer_class: Optional[Type[ReplayBuffer]] = None,\n replay_buffer_kwargs: Optional[Dict[str, Any]] = None,\n optimize_memory_usage: bool = False,\n ent_coef: Union[str, float] = \"auto\",\n target_update_interval: int = 1,\n target_entropy: Union[str, float] = \"auto\",\n use_sde: bool = False,\n sde_sample_freq: int = -1,\n use_sde_at_warmup: bool = False,\n tensorboard_log: Optional[str] = None,\n policy_kwargs: Optional[Dict[str, Any]] = None,\n verbose: int = 0,\n seed: Optional[int] = None,\n device: Union[th.device, str] = \"auto\",\n _init_setup_model: bool = True,\n ):\n\n super().__init__(\n policy,\n env,\n learning_rate,\n buffer_size,\n learning_starts,\n batch_size,\n tau,\n gamma,\n train_freq,\n gradient_steps,\n action_noise,\n replay_buffer_class=replay_buffer_class,\n replay_buffer_kwargs=replay_buffer_kwargs,\n policy_kwargs=policy_kwargs,\n tensorboard_log=tensorboard_log,\n verbose=verbose,\n device=device,\n seed=seed,\n use_sde=use_sde,\n sde_sample_freq=sde_sample_freq,\n use_sde_at_warmup=use_sde_at_warmup,\n optimize_memory_usage=optimize_memory_usage,\n supported_action_spaces=(spaces.Box),\n support_multi_env=True,\n )\n\n self.target_entropy = target_entropy\n self.log_ent_coef = None # type: Optional[th.Tensor]\n # Entropy coefficient / Entropy temperature\n # Inverse of the reward scale\n self.ent_coef = ent_coef\n self.target_update_interval = target_update_interval\n self.ent_coef_optimizer = None\n\n if _init_setup_model:\n self._setup_model()\n\n def _setup_model(self) -> None:\n super()._setup_model()\n self._create_aliases()\n # Running mean and running var\n self.batch_norm_stats = get_parameters_by_name(self.critic, [\"running_\"])\n self.batch_norm_stats_target = get_parameters_by_name(self.critic_target, [\"running_\"])\n # Target entropy is used when learning the entropy coefficient\n if self.target_entropy == \"auto\":\n # automatically set target entropy if needed\n self.target_entropy = -np.prod(self.env.action_space.shape).astype(np.float32)\n else:\n # Force conversion\n # this will also throw an error for unexpected string\n self.target_entropy = float(self.target_entropy)\n\n # The entropy coefficient or entropy can be learned automatically\n # see Automating Entropy Adjustment for Maximum Entropy RL section\n # of https://arxiv.org/abs/1812.05905\n if isinstance(self.ent_coef, str) and self.ent_coef.startswith(\"auto\"):\n # Default initial value of ent_coef when learned\n init_value = 1.0\n if \"_\" in self.ent_coef:\n init_value = float(self.ent_coef.split(\"_\")[1])\n assert init_value > 0.0, \"The initial value of ent_coef must be greater than 0\"\n\n # Note: we optimize the log of the entropy coeff which is slightly different from the paper\n # as discussed in https://github.com/rail-berkeley/softlearning/issues/37\n self.log_ent_coef = th.log(th.ones(1, device=self.device) * init_value).requires_grad_(True)\n self.ent_coef_optimizer = th.optim.Adam([self.log_ent_coef], lr=self.lr_schedule(1))\n else:\n # Force conversion to float\n # this will throw an error if a malformed string (different from 'auto')\n # is passed\n self.ent_coef_tensor = th.tensor(float(self.ent_coef), device=self.device)\n\n def _create_aliases(self) -> None:\n self.actor = self.policy.actor\n self.critic = self.policy.critic\n self.critic_target = self.policy.critic_target\n\n def train(self, gradient_steps: int, batch_size: int = 64) -> None:\n # Switch to train mode (this affects batch norm / dropout)\n self.policy.set_training_mode(True)\n # Update optimizers learning rate\n optimizers = [self.actor.optimizer, self.critic.optimizer]\n if self.ent_coef_optimizer is not None:\n optimizers += [self.ent_coef_optimizer]\n\n # Update learning rate according to lr schedule\n self._update_learning_rate(optimizers)\n\n ent_coef_losses, ent_coefs = [], []\n actor_losses, critic_losses = [], []\n\n for gradient_step in range(gradient_steps):\n # Sample replay buffer\n replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)\n\n # We need to sample because `log_std` may have changed between two gradient steps\n if self.use_sde:\n self.actor.reset_noise()\n\n # Action by the current actor for the sampled state\n actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)\n log_prob = log_prob.reshape(-1, 1)\n\n ent_coef_loss = None\n if self.ent_coef_optimizer is not None:\n # Important: detach the variable from the graph\n # so we don't change it with other losses\n # see https://github.com/rail-berkeley/softlearning/issues/60\n ent_coef = th.exp(self.log_ent_coef.detach())\n ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean()\n ent_coef_losses.append(ent_coef_loss.item())\n else:\n ent_coef = self.ent_coef_tensor\n\n ent_coefs.append(ent_coef.item())\n\n # Optimize entropy coefficient, also called\n # entropy temperature or alpha in the paper\n if ent_coef_loss is not None:\n self.ent_coef_optimizer.zero_grad()\n ent_coef_loss.backward()\n self.ent_coef_optimizer.step()\n\n with th.no_grad():\n # Select action according to policy\n next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)\n # Compute the next Q values: min over all critics targets\n next_q_values = th.cat(self.critic_target(replay_data.next_observations, next_actions), dim=1)\n next_q_values, _ = th.min(next_q_values, dim=1, keepdim=True)\n # add entropy term\n next_q_values = next_q_values - ent_coef * next_log_prob.reshape(-1, 1)\n # td error + entropy term\n target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values\n\n # Get current Q-values estimates for each critic network\n # using action from the replay buffer\n current_q_values = self.critic(replay_data.observations, replay_data.actions)\n\n # Compute critic loss\n critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values) for current_q in current_q_values)\n critic_losses.append(critic_loss.item())\n\n # Optimize the critic\n self.critic.optimizer.zero_grad()\n critic_loss.backward()\n self.critic.optimizer.step()\n\n # Compute actor loss\n # Alternative: actor_loss = th.mean(log_prob - qf1_pi)\n # Min over all critic networks\n q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)\n min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)\n actor_loss = (ent_coef * log_prob - min_qf_pi).mean()\n actor_losses.append(actor_loss.item())\n\n # Optimize the actor\n self.actor.optimizer.zero_grad()\n actor_loss.backward()\n self.actor.optimizer.step()\n\n # Update target networks\n if gradient_step % self.target_update_interval == 0:\n polyak_update(self.critic.parameters(), self.critic_target.parameters(), self.tau)\n # Copy running stats, see GH issue #996\n polyak_update(self.batch_norm_stats, self.batch_norm_stats_target, 1.0)\n\n self._n_updates += gradient_steps\n\n self.logger.record(\"train/n_updates\", self._n_updates, exclude=\"tensorboard\")\n self.logger.record(\"train/ent_coef\", np.mean(ent_coefs))\n self.logger.record(\"train/actor_loss\", np.mean(actor_losses))\n self.logger.record(\"train/critic_loss\", np.mean(critic_losses))\n if len(ent_coef_losses) > 0:\n self.logger.record(\"train/ent_coef_loss\", np.mean(ent_coef_losses))\n\n def learn(\n self: SelfSAC,\n total_timesteps: int,\n callback: MaybeCallback = None,\n log_interval: int = 4,\n tb_log_name: str = \"SAC\",\n reset_num_timesteps: bool = True,\n progress_bar: bool = False,\n ) -> SelfSAC:\n\n return super().learn(\n total_timesteps=total_timesteps,\n callback=callback,\n log_interval=log_interval,\n tb_log_name=tb_log_name,\n reset_num_timesteps=reset_num_timesteps,\n progress_bar=progress_bar,\n )\n\n def _excluded_save_params(self) -> List[str]:\n return super()._excluded_save_params() + [\"actor\", \"critic\", \"critic_target\"]\n\n def _get_torch_save_params(self) -> Tuple[List[str], List[str]]:\n state_dicts = [\"policy\", \"actor.optimizer\", \"critic.optimizer\"]\n if self.ent_coef_optimizer is not None:\n saved_pytorch_variables = [\"log_ent_coef\"]\n state_dicts.append(\"ent_coef_optimizer\")\n else:\n saved_pytorch_variables = [\"ent_coef_tensor\"]\n return state_dicts, saved_pytorch_variables"}],"string":"[\n {\n \"identifier\": \"ReplayBuffer\",\n \"path\": \"stable_baselines3/common/buffers.py\",\n \"snippet\": \"class ReplayBuffer(BaseBuffer):\\n \\\"\\\"\\\"\\n Replay buffer used in off-policy algorithms like SAC/TD3.\\n\\n :param buffer_size: Max number of element in the buffer\\n :param observation_space: Observation space\\n :param action_space: Action space\\n :param device: PyTorch device\\n :param n_envs: Number of parallel environments\\n :param optimize_memory_usage: Enable a memory efficient variant\\n of the replay buffer which reduces by almost a factor two the memory used,\\n at a cost of more complexity.\\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\\n and https://github.com/DLR-RM/stable-baselines3/pull/28#issuecomment-637559274\\n Cannot be used in combination with handle_timeout_termination.\\n :param handle_timeout_termination: Handle timeout termination (due to timelimit)\\n separately and treat the task as infinite horizon task.\\n https://github.com/DLR-RM/stable-baselines3/issues/284\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n buffer_size: int,\\n observation_space: spaces.Space,\\n action_space: spaces.Space,\\n device: Union[th.device, str] = \\\"auto\\\",\\n n_envs: int = 1,\\n optimize_memory_usage: bool = False,\\n handle_timeout_termination: bool = True,\\n ):\\n super().__init__(buffer_size, observation_space, action_space, device, n_envs=n_envs)\\n\\n # Adjust buffer size\\n self.buffer_size = max(buffer_size // n_envs, 1)\\n\\n # Check that the replay buffer can fit into the memory\\n if psutil is not None:\\n mem_available = psutil.virtual_memory().available\\n\\n # there is a bug if both optimize_memory_usage and handle_timeout_termination are true\\n # see https://github.com/DLR-RM/stable-baselines3/issues/934\\n if optimize_memory_usage and handle_timeout_termination:\\n raise ValueError(\\n \\\"ReplayBuffer does not support optimize_memory_usage = True \\\"\\n \\\"and handle_timeout_termination = True simultaneously.\\\"\\n )\\n self.optimize_memory_usage = optimize_memory_usage\\n\\n self.observations = np.zeros((self.buffer_size, self.n_envs) + self.obs_shape, dtype=observation_space.dtype)\\n\\n if optimize_memory_usage:\\n # `observations` contains also the next observation\\n self.next_observations = None\\n else:\\n self.next_observations = np.zeros((self.buffer_size, self.n_envs) + self.obs_shape, dtype=observation_space.dtype)\\n\\n self.actions = np.zeros((self.buffer_size, self.n_envs, self.action_dim), dtype=action_space.dtype)\\n\\n self.rewards = np.zeros((self.buffer_size, self.n_envs), dtype=np.float32)\\n self.dones = np.zeros((self.buffer_size, self.n_envs), dtype=np.float32)\\n # Handle timeouts termination properly if needed\\n # see https://github.com/DLR-RM/stable-baselines3/issues/284\\n self.handle_timeout_termination = handle_timeout_termination\\n self.timeouts = np.zeros((self.buffer_size, self.n_envs), dtype=np.float32)\\n\\n if psutil is not None:\\n total_memory_usage = self.observations.nbytes + self.actions.nbytes + self.rewards.nbytes + self.dones.nbytes\\n\\n if self.next_observations is not None:\\n total_memory_usage += self.next_observations.nbytes\\n\\n if total_memory_usage > mem_available:\\n # Convert to GB\\n total_memory_usage /= 1e9\\n mem_available /= 1e9\\n warnings.warn(\\n \\\"This system does not have apparently enough memory to store the complete \\\"\\n f\\\"replay buffer {total_memory_usage:.2f}GB > {mem_available:.2f}GB\\\"\\n )\\n\\n def add(\\n self,\\n obs: np.ndarray,\\n next_obs: np.ndarray,\\n action: np.ndarray,\\n reward: np.ndarray,\\n done: np.ndarray,\\n infos: List[Dict[str, Any]],\\n ) -> None:\\n\\n # Reshape needed when using multiple envs with discrete observations\\n # as numpy cannot broadcast (n_discrete,) to (n_discrete, 1)\\n if isinstance(self.observation_space, spaces.Discrete):\\n obs = obs.reshape((self.n_envs,) + self.obs_shape)\\n next_obs = next_obs.reshape((self.n_envs,) + self.obs_shape)\\n\\n # Same, for actions\\n action = action.reshape((self.n_envs, self.action_dim))\\n\\n # Copy to avoid modification by reference\\n self.observations[self.pos] = np.array(obs).copy()\\n\\n if self.optimize_memory_usage:\\n self.observations[(self.pos + 1) % self.buffer_size] = np.array(next_obs).copy()\\n else:\\n self.next_observations[self.pos] = np.array(next_obs).copy()\\n\\n self.actions[self.pos] = np.array(action).copy()\\n self.rewards[self.pos] = np.array(reward).copy()\\n self.dones[self.pos] = np.array(done).copy()\\n\\n if self.handle_timeout_termination:\\n self.timeouts[self.pos] = np.array([info.get(\\\"TimeLimit.truncated\\\", False) for info in infos])\\n\\n self.pos += 1\\n if self.pos == self.buffer_size:\\n self.full = True\\n self.pos = 0\\n\\n def sample(self, batch_size: int, env: Optional[VecNormalize] = None) -> ReplayBufferSamples:\\n \\\"\\\"\\\"\\n Sample elements from the replay buffer.\\n Custom sampling when using memory efficient variant,\\n as we should not sample the element with index `self.pos`\\n See https://github.com/DLR-RM/stable-baselines3/pull/28#issuecomment-637559274\\n\\n :param batch_size: Number of element to sample\\n :param env: associated gym VecEnv\\n to normalize the observations/rewards when sampling\\n :return:\\n \\\"\\\"\\\"\\n if not self.optimize_memory_usage:\\n return super().sample(batch_size=batch_size, env=env)\\n # Do not sample the element with index `self.pos` as the transitions is invalid\\n # (we use only one array to store `obs` and `next_obs`)\\n if self.full:\\n batch_inds = (np.random.randint(1, self.buffer_size, size=batch_size) + self.pos) % self.buffer_size\\n else:\\n batch_inds = np.random.randint(0, self.pos, size=batch_size)\\n return self._get_samples(batch_inds, env=env)\\n\\n def _get_samples(self, batch_inds: np.ndarray, env: Optional[VecNormalize] = None) -> ReplayBufferSamples:\\n # Sample randomly the env idx\\n env_indices = np.random.randint(0, high=self.n_envs, size=(len(batch_inds),))\\n\\n if self.optimize_memory_usage:\\n next_obs = self._normalize_obs(self.observations[(batch_inds + 1) % self.buffer_size, env_indices, :], env)\\n else:\\n next_obs = self._normalize_obs(self.next_observations[batch_inds, env_indices, :], env)\\n\\n data = (\\n self._normalize_obs(self.observations[batch_inds, env_indices, :], env),\\n self.actions[batch_inds, env_indices, :],\\n next_obs,\\n # Only use dones that are not due to timeouts\\n # deactivated by default (timeouts is initialized as an array of False)\\n (self.dones[batch_inds, env_indices] * (1 - self.timeouts[batch_inds, env_indices])).reshape(-1, 1),\\n self._normalize_reward(self.rewards[batch_inds, env_indices].reshape(-1, 1), env),\\n )\\n return ReplayBufferSamples(*tuple(map(self.to_torch, data)))\"\n },\n {\n \"identifier\": \"ActionNoise\",\n \"path\": \"stable_baselines3/common/noise.py\",\n \"snippet\": \"class ActionNoise(ABC):\\n \\\"\\\"\\\"\\n The action noise base class\\n \\\"\\\"\\\"\\n\\n def __init__(self) -> None:\\n super().__init__()\\n\\n def reset(self) -> None:\\n \\\"\\\"\\\"\\n call end of episode reset for the noise\\n \\\"\\\"\\\"\\n pass\\n\\n @abstractmethod\\n def __call__(self) -> np.ndarray:\\n raise NotImplementedError()\"\n },\n {\n \"identifier\": \"OffPolicyAlgorithm\",\n \"path\": \"stable_baselines3/common/off_policy_algorithm.py\",\n \"snippet\": \"class OffPolicyAlgorithm(BaseAlgorithm):\\n \\\"\\\"\\\"\\n The base for Off-Policy algorithms (ex: SAC/TD3)\\n\\n :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)\\n :param env: The environment to learn from\\n (if registered in Gym, can be str. Can be None for loading trained models)\\n :param learning_rate: learning rate for the optimizer,\\n it can be a function of the current progress remaining (from 1 to 0)\\n :param buffer_size: size of the replay buffer\\n :param learning_starts: how many steps of the model to collect transitions for before learning starts\\n :param batch_size: Minibatch size for each gradient update\\n :param tau: the soft update coefficient (\\\"Polyak update\\\", between 0 and 1)\\n :param gamma: the discount factor\\n :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit\\n like ``(5, \\\"step\\\")`` or ``(2, \\\"episode\\\")``.\\n :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)\\n Set to ``-1`` means to do as many gradient steps as steps done in the environment\\n during the rollout.\\n :param action_noise: the action noise type (None by default), this can help\\n for hard exploration problem. Cf common.noise for the different action noise type.\\n :param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).\\n If ``None``, it will be automatically selected.\\n :param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.\\n :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer\\n at a cost of more complexity.\\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\\n :param policy_kwargs: Additional arguments to be passed to the policy on creation\\n :param tensorboard_log: the log location for tensorboard (if None, no logging)\\n :param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for\\n debug messages\\n :param device: Device on which the code should run.\\n By default, it will try to use a Cuda compatible device and fallback to cpu\\n if it is not possible.\\n :param support_multi_env: Whether the algorithm supports training\\n with multiple environments (as in A2C)\\n :param monitor_wrapper: When creating an environment, whether to wrap it\\n or not in a Monitor wrapper.\\n :param seed: Seed for the pseudo random generators\\n :param use_sde: Whether to use State Dependent Exploration (SDE)\\n instead of action noise exploration (default: False)\\n :param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE\\n Default: -1 (only sample at the beginning of the rollout)\\n :param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling\\n during the warm up phase (before learning starts)\\n :param sde_support: Whether the model support gSDE or not\\n :param supported_action_spaces: The action spaces supported by the algorithm.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n policy: Union[str, Type[BasePolicy]],\\n env: Union[GymEnv, str],\\n learning_rate: Union[float, Schedule],\\n buffer_size: int = 1_000_000, # 1e6\\n learning_starts: int = 100,\\n batch_size: int = 256,\\n tau: float = 0.005,\\n gamma: float = 0.99,\\n train_freq: Union[int, Tuple[int, str]] = (1, \\\"step\\\"),\\n gradient_steps: int = 1,\\n action_noise: Optional[ActionNoise] = None,\\n replay_buffer_class: Optional[Type[ReplayBuffer]] = None,\\n replay_buffer_kwargs: Optional[Dict[str, Any]] = None,\\n optimize_memory_usage: bool = False,\\n policy_kwargs: Optional[Dict[str, Any]] = None,\\n tensorboard_log: Optional[str] = None,\\n verbose: int = 0,\\n device: Union[th.device, str] = \\\"auto\\\",\\n support_multi_env: bool = False,\\n monitor_wrapper: bool = True,\\n seed: Optional[int] = None,\\n use_sde: bool = False,\\n sde_sample_freq: int = -1,\\n use_sde_at_warmup: bool = False,\\n sde_support: bool = True,\\n supported_action_spaces: Optional[Tuple[spaces.Space, ...]] = None,\\n ):\\n\\n super().__init__(\\n policy=policy,\\n env=env,\\n learning_rate=learning_rate,\\n policy_kwargs=policy_kwargs,\\n tensorboard_log=tensorboard_log,\\n verbose=verbose,\\n device=device,\\n support_multi_env=support_multi_env,\\n monitor_wrapper=monitor_wrapper,\\n seed=seed,\\n use_sde=use_sde,\\n sde_sample_freq=sde_sample_freq,\\n supported_action_spaces=supported_action_spaces,\\n )\\n self.buffer_size = buffer_size\\n self.batch_size = batch_size\\n self.learning_starts = learning_starts\\n self.tau = tau\\n self.gamma = gamma\\n self.gradient_steps = gradient_steps\\n self.action_noise = action_noise\\n self.optimize_memory_usage = optimize_memory_usage\\n self.replay_buffer_class = replay_buffer_class\\n if replay_buffer_kwargs is None:\\n replay_buffer_kwargs = {}\\n self.replay_buffer_kwargs = replay_buffer_kwargs\\n self._episode_storage = None\\n\\n # Save train freq parameter, will be converted later to TrainFreq object\\n self.train_freq = train_freq\\n\\n self.actor = None # type: Optional[th.nn.Module]\\n self.replay_buffer = None # type: Optional[ReplayBuffer]\\n # Update policy keyword arguments\\n if sde_support:\\n self.policy_kwargs[\\\"use_sde\\\"] = self.use_sde\\n # For gSDE only\\n self.use_sde_at_warmup = use_sde_at_warmup\\n\\n def _convert_train_freq(self) -> None:\\n \\\"\\\"\\\"\\n Convert `train_freq` parameter (int or tuple)\\n to a TrainFreq object.\\n \\\"\\\"\\\"\\n if not isinstance(self.train_freq, TrainFreq):\\n train_freq = self.train_freq\\n\\n # The value of the train frequency will be checked later\\n if not isinstance(train_freq, tuple):\\n train_freq = (train_freq, \\\"step\\\")\\n\\n try:\\n train_freq = (train_freq[0], TrainFrequencyUnit(train_freq[1]))\\n except ValueError as e:\\n raise ValueError(\\n f\\\"The unit of the `train_freq` must be either 'step' or 'episode' not '{train_freq[1]}'!\\\"\\n ) from e\\n\\n if not isinstance(train_freq[0], int):\\n raise ValueError(f\\\"The frequency of `train_freq` must be an integer and not {train_freq[0]}\\\")\\n\\n self.train_freq = TrainFreq(*train_freq)\\n\\n def _setup_model(self) -> None:\\n self._setup_lr_schedule()\\n self.set_random_seed(self.seed)\\n\\n # Use DictReplayBuffer if needed\\n if self.replay_buffer_class is None:\\n if isinstance(self.observation_space, spaces.Dict):\\n self.replay_buffer_class = DictReplayBuffer\\n else:\\n self.replay_buffer_class = ReplayBuffer\\n\\n elif self.replay_buffer_class == HerReplayBuffer:\\n assert self.env is not None, \\\"You must pass an environment when using `HerReplayBuffer`\\\"\\n\\n # If using offline sampling, we need a classic replay buffer too\\n if self.replay_buffer_kwargs.get(\\\"online_sampling\\\", True):\\n replay_buffer = None\\n else:\\n replay_buffer = DictReplayBuffer(\\n self.buffer_size,\\n self.observation_space,\\n self.action_space,\\n device=self.device,\\n optimize_memory_usage=self.optimize_memory_usage,\\n )\\n\\n self.replay_buffer = HerReplayBuffer(\\n self.env,\\n self.buffer_size,\\n device=self.device,\\n replay_buffer=replay_buffer,\\n **self.replay_buffer_kwargs,\\n )\\n\\n if self.replay_buffer is None:\\n self.replay_buffer = self.replay_buffer_class(\\n self.buffer_size,\\n self.observation_space,\\n self.action_space,\\n device=self.device,\\n n_envs=self.n_envs,\\n optimize_memory_usage=self.optimize_memory_usage,\\n **self.replay_buffer_kwargs,\\n )\\n\\n self.policy = self.policy_class( # pytype:disable=not-instantiable\\n self.observation_space,\\n self.action_space,\\n self.lr_schedule,\\n **self.policy_kwargs, # pytype:disable=not-instantiable\\n )\\n self.policy = self.policy.to(self.device)\\n\\n # Convert train freq parameter to TrainFreq object\\n self._convert_train_freq()\\n\\n def save_replay_buffer(self, path: Union[str, pathlib.Path, io.BufferedIOBase]) -> None:\\n \\\"\\\"\\\"\\n Save the replay buffer as a pickle file.\\n\\n :param path: Path to the file where the replay buffer should be saved.\\n if path is a str or pathlib.Path, the path is automatically created if necessary.\\n \\\"\\\"\\\"\\n assert self.replay_buffer is not None, \\\"The replay buffer is not defined\\\"\\n save_to_pkl(path, self.replay_buffer, self.verbose)\\n\\n def load_replay_buffer(\\n self,\\n path: Union[str, pathlib.Path, io.BufferedIOBase],\\n truncate_last_traj: bool = True,\\n ) -> None:\\n \\\"\\\"\\\"\\n Load a replay buffer from a pickle file.\\n\\n :param path: Path to the pickled replay buffer.\\n :param truncate_last_traj: When using ``HerReplayBuffer`` with online sampling:\\n If set to ``True``, we assume that the last trajectory in the replay buffer was finished\\n (and truncate it).\\n If set to ``False``, we assume that we continue the same trajectory (same episode).\\n \\\"\\\"\\\"\\n self.replay_buffer = load_from_pkl(path, self.verbose)\\n assert isinstance(self.replay_buffer, ReplayBuffer), \\\"The replay buffer must inherit from ReplayBuffer class\\\"\\n\\n # Backward compatibility with SB3 < 2.1.0 replay buffer\\n # Keep old behavior: do not handle timeout termination separately\\n if not hasattr(self.replay_buffer, \\\"handle_timeout_termination\\\"): # pragma: no cover\\n self.replay_buffer.handle_timeout_termination = False\\n self.replay_buffer.timeouts = np.zeros_like(self.replay_buffer.dones)\\n\\n if isinstance(self.replay_buffer, HerReplayBuffer):\\n assert self.env is not None, \\\"You must pass an environment at load time when using `HerReplayBuffer`\\\"\\n self.replay_buffer.set_env(self.get_env())\\n if truncate_last_traj:\\n self.replay_buffer.truncate_last_trajectory()\\n\\n def _setup_learn(\\n self,\\n total_timesteps: int,\\n callback: MaybeCallback = None,\\n reset_num_timesteps: bool = True,\\n tb_log_name: str = \\\"run\\\",\\n progress_bar: bool = False,\\n ) -> Tuple[int, BaseCallback]:\\n \\\"\\\"\\\"\\n cf `BaseAlgorithm`.\\n \\\"\\\"\\\"\\n # Prevent continuity issue by truncating trajectory\\n # when using memory efficient replay buffer\\n # see https://github.com/DLR-RM/stable-baselines3/issues/46\\n\\n # Special case when using HerReplayBuffer,\\n # the classic replay buffer is inside it when using offline sampling\\n if isinstance(self.replay_buffer, HerReplayBuffer):\\n replay_buffer = self.replay_buffer.replay_buffer\\n else:\\n replay_buffer = self.replay_buffer\\n\\n truncate_last_traj = (\\n self.optimize_memory_usage\\n and reset_num_timesteps\\n and replay_buffer is not None\\n and (replay_buffer.full or replay_buffer.pos > 0)\\n )\\n\\n if truncate_last_traj:\\n warnings.warn(\\n \\\"The last trajectory in the replay buffer will be truncated, \\\"\\n \\\"see https://github.com/DLR-RM/stable-baselines3/issues/46.\\\"\\n \\\"You should use `reset_num_timesteps=False` or `optimize_memory_usage=False`\\\"\\n \\\"to avoid that issue.\\\"\\n )\\n # Go to the previous index\\n pos = (replay_buffer.pos - 1) % replay_buffer.buffer_size\\n replay_buffer.dones[pos] = True\\n\\n return super()._setup_learn(\\n total_timesteps,\\n callback,\\n reset_num_timesteps,\\n tb_log_name,\\n progress_bar,\\n )\\n\\n def learn(\\n self: SelfOffPolicyAlgorithm,\\n total_timesteps: int,\\n callback: MaybeCallback = None,\\n log_interval: int = 4,\\n tb_log_name: str = \\\"run\\\",\\n reset_num_timesteps: bool = True,\\n progress_bar: bool = False,\\n ) -> SelfOffPolicyAlgorithm:\\n\\n total_timesteps, callback = self._setup_learn(\\n total_timesteps,\\n callback,\\n reset_num_timesteps,\\n tb_log_name,\\n progress_bar,\\n )\\n\\n callback.on_training_start(locals(), globals())\\n\\n while self.num_timesteps < total_timesteps:\\n rollout = self.collect_rollouts(\\n self.env,\\n train_freq=self.train_freq,\\n action_noise=self.action_noise,\\n callback=callback,\\n learning_starts=self.learning_starts,\\n replay_buffer=self.replay_buffer,\\n log_interval=log_interval,\\n )\\n\\n if rollout.continue_training is False:\\n break\\n\\n if self.num_timesteps > 0 and self.num_timesteps > self.learning_starts:\\n # If no `gradient_steps` is specified,\\n # do as many gradients steps as steps performed during the rollout\\n gradient_steps = self.gradient_steps if self.gradient_steps >= 0 else rollout.episode_timesteps\\n # Special case when the user passes `gradient_steps=0`\\n if gradient_steps > 0:\\n self.train(batch_size=self.batch_size, gradient_steps=gradient_steps)\\n\\n callback.on_training_end()\\n\\n return self\\n\\n def train(self, gradient_steps: int, batch_size: int) -> None:\\n \\\"\\\"\\\"\\n Sample the replay buffer and do the updates\\n (gradient descent and update target networks)\\n \\\"\\\"\\\"\\n raise NotImplementedError()\\n\\n def _sample_action(\\n self,\\n learning_starts: int,\\n action_noise: Optional[ActionNoise] = None,\\n n_envs: int = 1,\\n ) -> Tuple[np.ndarray, np.ndarray]:\\n \\\"\\\"\\\"\\n Sample an action according to the exploration policy.\\n This is either done by sampling the probability distribution of the policy,\\n or sampling a random action (from a uniform distribution over the action space)\\n or by adding noise to the deterministic output.\\n\\n :param action_noise: Action noise that will be used for exploration\\n Required for deterministic policy (e.g. TD3). This can also be used\\n in addition to the stochastic policy for SAC.\\n :param learning_starts: Number of steps before learning for the warm-up phase.\\n :param n_envs:\\n :return: action to take in the environment\\n and scaled action that will be stored in the replay buffer.\\n The two differs when the action space is not normalized (bounds are not [-1, 1]).\\n \\\"\\\"\\\"\\n # Select action randomly or according to policy\\n if self.num_timesteps < learning_starts and not (self.use_sde and self.use_sde_at_warmup):\\n # Warmup phase\\n unscaled_action = np.array([self.action_space.sample() for _ in range(n_envs)])\\n else:\\n # Note: when using continuous actions,\\n # we assume that the policy uses tanh to scale the action\\n # We use non-deterministic action in the case of SAC, for TD3, it does not matter\\n unscaled_action, _ = self.predict(self._last_obs, deterministic=False)\\n\\n # Rescale the action from [low, high] to [-1, 1]\\n if isinstance(self.action_space, spaces.Box):\\n scaled_action = self.policy.scale_action(unscaled_action)\\n\\n # Add noise to the action (improve exploration)\\n if action_noise is not None:\\n scaled_action = np.clip(scaled_action + action_noise(), -1, 1)\\n\\n # We store the scaled action in the buffer\\n buffer_action = scaled_action\\n action = self.policy.unscale_action(scaled_action)\\n else:\\n # Discrete case, no need to normalize or clip\\n buffer_action = unscaled_action\\n action = buffer_action\\n return action, buffer_action\\n\\n def _dump_logs(self) -> None:\\n \\\"\\\"\\\"\\n Write log.\\n \\\"\\\"\\\"\\n time_elapsed = max((time.time_ns() - self.start_time) / 1e9, sys.float_info.epsilon)\\n fps = int((self.num_timesteps - self._num_timesteps_at_start) / time_elapsed)\\n self.logger.record(\\\"time/episodes\\\", self._episode_num, exclude=\\\"tensorboard\\\")\\n if len(self.ep_info_buffer) > 0 and len(self.ep_info_buffer[0]) > 0:\\n self.logger.record(\\\"rollout/ep_rew_mean\\\", safe_mean([ep_info[\\\"r\\\"] for ep_info in self.ep_info_buffer]))\\n self.logger.record(\\\"rollout/ep_len_mean\\\", safe_mean([ep_info[\\\"l\\\"] for ep_info in self.ep_info_buffer]))\\n self.logger.record(\\\"time/fps\\\", fps)\\n self.logger.record(\\\"time/time_elapsed\\\", int(time_elapsed), exclude=\\\"tensorboard\\\")\\n self.logger.record(\\\"time/total_timesteps\\\", self.num_timesteps, exclude=\\\"tensorboard\\\")\\n if self.use_sde:\\n self.logger.record(\\\"train/std\\\", (self.actor.get_std()).mean().item())\\n\\n if len(self.ep_success_buffer) > 0:\\n self.logger.record(\\\"rollout/success_rate\\\", safe_mean(self.ep_success_buffer))\\n # Pass the number of timesteps for tensorboard\\n self.logger.dump(step=self.num_timesteps)\\n\\n def _on_step(self) -> None:\\n \\\"\\\"\\\"\\n Method called after each step in the environment.\\n It is meant to trigger DQN target network update\\n but can be used for other purposes\\n \\\"\\\"\\\"\\n pass\\n\\n def _store_transition(\\n self,\\n replay_buffer: ReplayBuffer,\\n buffer_action: np.ndarray,\\n new_obs: Union[np.ndarray, Dict[str, np.ndarray]],\\n reward: np.ndarray,\\n dones: np.ndarray,\\n infos: List[Dict[str, Any]],\\n ) -> None:\\n \\\"\\\"\\\"\\n Store transition in the replay buffer.\\n We store the normalized action and the unnormalized observation.\\n It also handles terminal observations (because VecEnv resets automatically).\\n\\n :param replay_buffer: Replay buffer object where to store the transition.\\n :param buffer_action: normalized action\\n :param new_obs: next observation in the current episode\\n or first observation of the episode (when dones is True)\\n :param reward: reward for the current transition\\n :param dones: Termination signal\\n :param infos: List of additional information about the transition.\\n It may contain the terminal observations and information about timeout.\\n \\\"\\\"\\\"\\n # Store only the unnormalized version\\n if self._vec_normalize_env is not None:\\n new_obs_ = self._vec_normalize_env.get_original_obs()\\n reward_ = self._vec_normalize_env.get_original_reward()\\n else:\\n # Avoid changing the original ones\\n self._last_original_obs, new_obs_, reward_ = self._last_obs, new_obs, reward\\n\\n # Avoid modification by reference\\n next_obs = deepcopy(new_obs_)\\n # As the VecEnv resets automatically, new_obs is already the\\n # first observation of the next episode\\n for i, done in enumerate(dones):\\n if done and infos[i].get(\\\"terminal_observation\\\") is not None:\\n if isinstance(next_obs, dict):\\n next_obs_ = infos[i][\\\"terminal_observation\\\"]\\n # VecNormalize normalizes the terminal observation\\n if self._vec_normalize_env is not None:\\n next_obs_ = self._vec_normalize_env.unnormalize_obs(next_obs_)\\n # Replace next obs for the correct envs\\n for key in next_obs.keys():\\n next_obs[key][i] = next_obs_[key]\\n else:\\n next_obs[i] = infos[i][\\\"terminal_observation\\\"]\\n # VecNormalize normalizes the terminal observation\\n if self._vec_normalize_env is not None:\\n next_obs[i] = self._vec_normalize_env.unnormalize_obs(next_obs[i, :])\\n\\n replay_buffer.add(\\n self._last_original_obs,\\n next_obs,\\n buffer_action,\\n reward_,\\n dones,\\n infos,\\n )\\n\\n self._last_obs = new_obs\\n # Save the unnormalized observation\\n if self._vec_normalize_env is not None:\\n self._last_original_obs = new_obs_\\n\\n def collect_rollouts(\\n self,\\n env: VecEnv,\\n callback: BaseCallback,\\n train_freq: TrainFreq,\\n replay_buffer: ReplayBuffer,\\n action_noise: Optional[ActionNoise] = None,\\n learning_starts: int = 0,\\n log_interval: Optional[int] = None,\\n ) -> RolloutReturn:\\n \\\"\\\"\\\"\\n Collect experiences and store them into a ``ReplayBuffer``.\\n\\n :param env: The training environment\\n :param callback: Callback that will be called at each step\\n (and at the beginning and end of the rollout)\\n :param train_freq: How much experience to collect\\n by doing rollouts of current policy.\\n Either ``TrainFreq(<n>, TrainFrequencyUnit.STEP)``\\n or ``TrainFreq(<n>, TrainFrequencyUnit.EPISODE)``\\n with ``<n>`` being an integer greater than 0.\\n :param action_noise: Action noise that will be used for exploration\\n Required for deterministic policy (e.g. TD3). This can also be used\\n in addition to the stochastic policy for SAC.\\n :param learning_starts: Number of steps before learning for the warm-up phase.\\n :param replay_buffer:\\n :param log_interval: Log data every ``log_interval`` episodes\\n :return:\\n \\\"\\\"\\\"\\n # Switch to eval mode (this affects batch norm / dropout)\\n self.policy.set_training_mode(False)\\n\\n num_collected_steps, num_collected_episodes = 0, 0\\n\\n assert isinstance(env, VecEnv), \\\"You must pass a VecEnv\\\"\\n assert train_freq.frequency > 0, \\\"Should at least collect one step or episode.\\\"\\n\\n if env.num_envs > 1:\\n assert train_freq.unit == TrainFrequencyUnit.STEP, \\\"You must use only one env when doing episodic training.\\\"\\n\\n # Vectorize action noise if needed\\n if action_noise is not None and env.num_envs > 1 and not isinstance(action_noise, VectorizedActionNoise):\\n action_noise = VectorizedActionNoise(action_noise, env.num_envs)\\n\\n if self.use_sde:\\n self.actor.reset_noise(env.num_envs)\\n\\n callback.on_rollout_start()\\n continue_training = True\\n\\n while should_collect_more_steps(train_freq, num_collected_steps, num_collected_episodes):\\n if self.use_sde and self.sde_sample_freq > 0 and num_collected_steps % self.sde_sample_freq == 0:\\n # Sample a new noise matrix\\n self.actor.reset_noise(env.num_envs)\\n\\n # Select action randomly or according to policy\\n actions, buffer_actions = self._sample_action(learning_starts, action_noise, env.num_envs)\\n\\n # Rescale and perform action\\n new_obs, rewards, dones, infos = env.step(actions)\\n\\n self.num_timesteps += env.num_envs\\n num_collected_steps += 1\\n\\n # Give access to local variables\\n callback.update_locals(locals())\\n # Only stop training if return value is False, not when it is None.\\n if callback.on_step() is False:\\n return RolloutReturn(num_collected_steps * env.num_envs, num_collected_episodes, continue_training=False)\\n\\n # Retrieve reward and episode length if using Monitor wrapper\\n self._update_info_buffer(infos, dones)\\n\\n # Store data in replay buffer (normalized action and unnormalized observation)\\n self._store_transition(replay_buffer, buffer_actions, new_obs, rewards, dones, infos)\\n\\n self._update_current_progress_remaining(self.num_timesteps, self._total_timesteps)\\n\\n # For DQN, check if the target network should be updated\\n # and update the exploration schedule\\n # For SAC/TD3, the update is dones as the same time as the gradient update\\n # see https://github.com/hill-a/stable-baselines/issues/900\\n self._on_step()\\n\\n for idx, done in enumerate(dones):\\n if done:\\n # Update stats\\n num_collected_episodes += 1\\n self._episode_num += 1\\n\\n if action_noise is not None:\\n kwargs = dict(indices=[idx]) if env.num_envs > 1 else {}\\n action_noise.reset(**kwargs)\\n\\n # Log training infos\\n if log_interval is not None and self._episode_num % log_interval == 0:\\n self._dump_logs()\\n callback.on_rollout_end()\\n\\n return RolloutReturn(num_collected_steps * env.num_envs, num_collected_episodes, continue_training)\"\n },\n {\n \"identifier\": \"BasePolicy\",\n \"path\": \"stable_baselines3/common/policies.py\",\n \"snippet\": \"class BasePolicy(BaseModel, ABC):\\n \\\"\\\"\\\"The base policy object.\\n\\n Parameters are mostly the same as `BaseModel`; additions are documented below.\\n\\n :param args: positional arguments passed through to `BaseModel`.\\n :param kwargs: keyword arguments passed through to `BaseModel`.\\n :param squash_output: For continuous actions, whether the output is squashed\\n or not using a ``tanh()`` function.\\n \\\"\\\"\\\"\\n\\n def __init__(self, *args, squash_output: bool = False, **kwargs):\\n super().__init__(*args, **kwargs)\\n self._squash_output = squash_output\\n\\n @staticmethod\\n def _dummy_schedule(progress_remaining: float) -> float:\\n \\\"\\\"\\\"(float) Useful for pickling policy.\\\"\\\"\\\"\\n del progress_remaining\\n return 0.0\\n\\n @property\\n def squash_output(self) -> bool:\\n \\\"\\\"\\\"(bool) Getter for squash_output.\\\"\\\"\\\"\\n return self._squash_output\\n\\n @staticmethod\\n def init_weights(module: nn.Module, gain: float = 1) -> None:\\n \\\"\\\"\\\"\\n Orthogonal initialization (used in PPO and A2C)\\n \\\"\\\"\\\"\\n if isinstance(module, (nn.Linear, nn.Conv2d)):\\n nn.init.orthogonal_(module.weight, gain=gain)\\n if module.bias is not None:\\n module.bias.data.fill_(0.0)\\n\\n @abstractmethod\\n def _predict(self, observation: th.Tensor, deterministic: bool = False) -> th.Tensor:\\n \\\"\\\"\\\"\\n Get the action according to the policy for a given observation.\\n\\n By default provides a dummy implementation -- not all BasePolicy classes\\n implement this, e.g. if they are a Critic in an Actor-Critic method.\\n\\n :param observation:\\n :param deterministic: Whether to use stochastic or deterministic actions\\n :return: Taken action according to the policy\\n \\\"\\\"\\\"\\n\\n def predict(\\n self,\\n observation: Union[np.ndarray, Dict[str, np.ndarray]],\\n state: Optional[Tuple[np.ndarray, ...]] = None,\\n episode_start: Optional[np.ndarray] = None,\\n deterministic: bool = False,\\n ) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, ...]]]:\\n \\\"\\\"\\\"\\n Get the policy action from an observation (and optional hidden state).\\n Includes sugar-coating to handle different observations (e.g. normalizing images).\\n\\n :param observation: the input observation\\n :param state: The last hidden states (can be None, used in recurrent policies)\\n :param episode_start: The last masks (can be None, used in recurrent policies)\\n this correspond to beginning of episodes,\\n where the hidden states of the RNN must be reset.\\n :param deterministic: Whether or not to return deterministic actions.\\n :return: the model's action and the next hidden state\\n (used in recurrent policies)\\n \\\"\\\"\\\"\\n # TODO (GH/1): add support for RNN policies\\n # if state is None:\\n # state = self.initial_state\\n # if episode_start is None:\\n # episode_start = [False for _ in range(self.n_envs)]\\n # Switch to eval mode (this affects batch norm / dropout)\\n self.set_training_mode(False)\\n\\n observation, vectorized_env = self.obs_to_tensor(observation)\\n\\n with th.no_grad():\\n actions = self._predict(observation, deterministic=deterministic)\\n # Convert to numpy, and reshape to the original action shape\\n actions = actions.cpu().numpy().reshape((-1,) + self.action_space.shape)\\n\\n if isinstance(self.action_space, spaces.Box):\\n if self.squash_output:\\n # Rescale to proper domain when using squashing\\n actions = self.unscale_action(actions)\\n else:\\n # Actions could be on arbitrary scale, so clip the actions to avoid\\n # out of bound error (e.g. if sampling from a Gaussian distribution)\\n actions = np.clip(actions, self.action_space.low, self.action_space.high)\\n\\n # Remove batch dimension if needed\\n if not vectorized_env:\\n actions = actions.squeeze(axis=0)\\n\\n return actions, state\\n\\n def scale_action(self, action: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Rescale the action from [low, high] to [-1, 1]\\n (no need for symmetric action space)\\n\\n :param action: Action to scale\\n :return: Scaled action\\n \\\"\\\"\\\"\\n low, high = self.action_space.low, self.action_space.high\\n return 2.0 * ((action - low) / (high - low)) - 1.0\\n\\n def unscale_action(self, scaled_action: np.ndarray) -> np.ndarray:\\n \\\"\\\"\\\"\\n Rescale the action from [-1, 1] to [low, high]\\n (no need for symmetric action space)\\n\\n :param scaled_action: Action to un-scale\\n \\\"\\\"\\\"\\n low, high = self.action_space.low, self.action_space.high\\n return low + (0.5 * (scaled_action + 1.0) * (high - low))\"\n },\n {\n \"identifier\": \"GymEnv\",\n \"path\": \"stable_baselines3/common/type_aliases.py\",\n \"snippet\": \"class RolloutBufferSamples(NamedTuple):\\nclass DictRolloutBufferSamples(NamedTuple):\\nclass ReplayBufferSamples(NamedTuple):\\nclass DictReplayBufferSamples(NamedTuple):\\nclass RolloutReturn(NamedTuple):\\nclass TrainFrequencyUnit(Enum):\\nclass TrainFreq(NamedTuple):\\nclass PolicyPredictor(Protocol):\\n STEP = \\\"step\\\"\\n EPISODE = \\\"episode\\\"\\n def predict(\\n self,\\n observation: Union[np.ndarray, Dict[str, np.ndarray]],\\n state: Optional[Tuple[np.ndarray, ...]] = None,\\n episode_start: Optional[np.ndarray] = None,\\n deterministic: bool = False,\\n ) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, ...]]]:\"\n },\n {\n \"identifier\": \"get_parameters_by_name\",\n \"path\": \"stable_baselines3/common/utils.py\",\n \"snippet\": \"def get_parameters_by_name(model: th.nn.Module, included_names: Iterable[str]) -> List[th.Tensor]:\\n \\\"\\\"\\\"\\n Extract parameters from the state dict of ``model``\\n if the name contains one of the strings in ``included_names``.\\n\\n :param model: the model where the parameters come from.\\n :param included_names: substrings of names to include.\\n :return: List of parameters values (Pytorch tensors)\\n that matches the queried names.\\n \\\"\\\"\\\"\\n return [param for name, param in model.state_dict().items() if any([key in name for key in included_names])]\"\n },\n {\n \"identifier\": \"polyak_update\",\n \"path\": \"stable_baselines3/common/utils.py\",\n \"snippet\": \"def polyak_update(\\n params: Iterable[th.Tensor],\\n target_params: Iterable[th.Tensor],\\n tau: float,\\n) -> None:\\n \\\"\\\"\\\"\\n Perform a Polyak average update on ``target_params`` using ``params``:\\n target parameters are slowly updated towards the main parameters.\\n ``tau``, the soft update coefficient controls the interpolation:\\n ``tau=1`` corresponds to copying the parameters to the target ones whereas nothing happens when ``tau=0``.\\n The Polyak update is done in place, with ``no_grad``, and therefore does not create intermediate tensors,\\n or a computation graph, reducing memory cost and improving performance. We scale the target params\\n by ``1-tau`` (in-place), add the new weights, scaled by ``tau`` and store the result of the sum in the target\\n params (in place).\\n See https://github.com/DLR-RM/stable-baselines3/issues/93\\n\\n :param params: parameters to use to update the target params\\n :param target_params: parameters to update\\n :param tau: the soft update coefficient (\\\"Polyak update\\\", between 0 and 1)\\n \\\"\\\"\\\"\\n with th.no_grad():\\n # zip does not raise an exception if length of parameters does not match.\\n for param, target_param in zip_strict(params, target_params):\\n target_param.data.mul_(1 - tau)\\n th.add(target_param.data, param.data, alpha=tau, out=target_param.data)\"\n },\n {\n \"identifier\": \"ResidualCnnPolicy\",\n \"path\": \"stable_baselines3/sac_residual/policies.py\",\n \"snippet\": \"LOG_STD_MAX = 2\\nLOG_STD_MIN = -20\\nclass ResidualSACPolicy(SACPolicy):\\nclass ResidualCnnPolicy(ResidualSACPolicy):\\nclass ResidualMultiInputPolicy(ResidualSACPolicy):\\n def __init__(\\n self,\\n observation_space: spaces.Space,\\n action_space: spaces.Space,\\n lr_schedule: Schedule,\\n net_arch: Optional[Union[List[int], Dict[str, List[int]]]] = None,\\n activation_fn: Type[nn.Module] = nn.ReLU,\\n use_sde: bool = False,\\n log_std_init: float = -3,\\n use_expln: bool = False,\\n clip_mean: float = 2.0,\\n features_extractor_class: Type[BaseFeaturesExtractor] = FlattenExtractor,\\n features_extractor_kwargs: Optional[Dict[str, Any]] = None,\\n normalize_images: bool = True,\\n optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,\\n optimizer_kwargs: Optional[Dict[str, Any]] = None,\\n n_critics: int = 2,\\n share_features_extractor: bool = False,\\n ):\\n def __init__(\\n self,\\n observation_space: spaces.Space,\\n action_space: spaces.Space,\\n lr_schedule: Schedule,\\n net_arch: Optional[Union[List[int], Dict[str, List[int]]]] = None,\\n activation_fn: Type[nn.Module] = nn.ReLU,\\n use_sde: bool = False,\\n log_std_init: float = -3,\\n use_expln: bool = False,\\n clip_mean: float = 2.0,\\n features_extractor_class: Type[BaseFeaturesExtractor] = NatureCNN,\\n features_extractor_kwargs: Optional[Dict[str, Any]] = None,\\n normalize_images: bool = True,\\n optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,\\n optimizer_kwargs: Optional[Dict[str, Any]] = None,\\n n_critics: int = 2,\\n share_features_extractor: bool = False,\\n ):\\n def __init__(\\n self,\\n observation_space: spaces.Space,\\n action_space: spaces.Space,\\n lr_schedule: Schedule,\\n net_arch: Optional[Union[List[int], Dict[str, List[int]]]] = None,\\n activation_fn: Type[nn.Module] = nn.ReLU,\\n use_sde: bool = False,\\n log_std_init: float = -3,\\n use_expln: bool = False,\\n clip_mean: float = 2.0,\\n features_extractor_class: Type[BaseFeaturesExtractor] = CombinedExtractor,\\n features_extractor_kwargs: Optional[Dict[str, Any]] = None,\\n normalize_images: bool = True,\\n optimizer_class: Type[th.optim.Optimizer] = th.optim.Adam,\\n optimizer_kwargs: Optional[Dict[str, Any]] = None,\\n n_critics: int = 2,\\n share_features_extractor: bool = False,\\n ):\"\n },\n {\n \"identifier\": \"SAC\",\n \"path\": \"stable_baselines3/sac/sac.py\",\n \"snippet\": \"class SAC(OffPolicyAlgorithm):\\n \\\"\\\"\\\"\\n Soft Actor-Critic (SAC)\\n Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor,\\n This implementation borrows code from original implementation (https://github.com/haarnoja/sac)\\n from OpenAI Spinning Up (https://github.com/openai/spinningup), from the softlearning repo\\n (https://github.com/rail-berkeley/softlearning/)\\n and from Stable Baselines (https://github.com/hill-a/stable-baselines)\\n Paper: https://arxiv.org/abs/1801.01290\\n Introduction to SAC: https://spinningup.openai.com/en/latest/algorithms/sac.html\\n\\n Note: we use double q target and not value target as discussed\\n in https://github.com/hill-a/stable-baselines/issues/270\\n\\n :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)\\n :param env: The environment to learn from (if registered in Gym, can be str)\\n :param learning_rate: learning rate for adam optimizer,\\n the same learning rate will be used for all networks (Q-Values, Actor and Value function)\\n it can be a function of the current progress remaining (from 1 to 0)\\n :param buffer_size: size of the replay buffer\\n :param learning_starts: how many steps of the model to collect transitions for before learning starts\\n :param batch_size: Minibatch size for each gradient update\\n :param tau: the soft update coefficient (\\\"Polyak update\\\", between 0 and 1)\\n :param gamma: the discount factor\\n :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit\\n like ``(5, \\\"step\\\")`` or ``(2, \\\"episode\\\")``.\\n :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)\\n Set to ``-1`` means to do as many gradient steps as steps done in the environment\\n during the rollout.\\n :param action_noise: the action noise type (None by default), this can help\\n for hard exploration problem. Cf common.noise for the different action noise type.\\n :param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).\\n If ``None``, it will be automatically selected.\\n :param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.\\n :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer\\n at a cost of more complexity.\\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\\n :param ent_coef: Entropy regularization coefficient. (Equivalent to\\n inverse of reward scale in the original SAC paper.) Controlling exploration/exploitation trade-off.\\n Set it to 'auto' to learn it automatically (and 'auto_0.1' for using 0.1 as initial value)\\n :param target_update_interval: update the target network every ``target_network_update_freq``\\n gradient steps.\\n :param target_entropy: target entropy when learning ``ent_coef`` (``ent_coef = 'auto'``)\\n :param use_sde: Whether to use generalized State Dependent Exploration (gSDE)\\n instead of action noise exploration (default: False)\\n :param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE\\n Default: -1 (only sample at the beginning of the rollout)\\n :param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling\\n during the warm up phase (before learning starts)\\n :param policy_kwargs: additional arguments to be passed to the policy on creation\\n :param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for\\n debug messages\\n :param seed: Seed for the pseudo random generators\\n :param device: Device (cpu, cuda, ...) on which the code should be run.\\n Setting it to auto, the code will be run on the GPU if possible.\\n :param _init_setup_model: Whether or not to build the network at the creation of the instance\\n \\\"\\\"\\\"\\n\\n policy_aliases: Dict[str, Type[BasePolicy]] = {\\n \\\"MlpPolicy\\\": MlpPolicy,\\n \\\"CnnPolicy\\\": CnnPolicy,\\n \\\"MultiInputPolicy\\\": MultiInputPolicy,\\n }\\n\\n def __init__(\\n self,\\n policy: Union[str, Type[SACPolicy]],\\n env: Union[GymEnv, str],\\n learning_rate: Union[float, Schedule] = 3e-4,\\n buffer_size: int = 1_000_000, # 1e6\\n learning_starts: int = 100,\\n batch_size: int = 256,\\n tau: float = 0.005,\\n gamma: float = 0.99,\\n train_freq: Union[int, Tuple[int, str]] = 1,\\n gradient_steps: int = 1,\\n action_noise: Optional[ActionNoise] = None,\\n replay_buffer_class: Optional[Type[ReplayBuffer]] = None,\\n replay_buffer_kwargs: Optional[Dict[str, Any]] = None,\\n optimize_memory_usage: bool = False,\\n ent_coef: Union[str, float] = \\\"auto\\\",\\n target_update_interval: int = 1,\\n target_entropy: Union[str, float] = \\\"auto\\\",\\n use_sde: bool = False,\\n sde_sample_freq: int = -1,\\n use_sde_at_warmup: bool = False,\\n tensorboard_log: Optional[str] = None,\\n policy_kwargs: Optional[Dict[str, Any]] = None,\\n verbose: int = 0,\\n seed: Optional[int] = None,\\n device: Union[th.device, str] = \\\"auto\\\",\\n _init_setup_model: bool = True,\\n ):\\n\\n super().__init__(\\n policy,\\n env,\\n learning_rate,\\n buffer_size,\\n learning_starts,\\n batch_size,\\n tau,\\n gamma,\\n train_freq,\\n gradient_steps,\\n action_noise,\\n replay_buffer_class=replay_buffer_class,\\n replay_buffer_kwargs=replay_buffer_kwargs,\\n policy_kwargs=policy_kwargs,\\n tensorboard_log=tensorboard_log,\\n verbose=verbose,\\n device=device,\\n seed=seed,\\n use_sde=use_sde,\\n sde_sample_freq=sde_sample_freq,\\n use_sde_at_warmup=use_sde_at_warmup,\\n optimize_memory_usage=optimize_memory_usage,\\n supported_action_spaces=(spaces.Box),\\n support_multi_env=True,\\n )\\n\\n self.target_entropy = target_entropy\\n self.log_ent_coef = None # type: Optional[th.Tensor]\\n # Entropy coefficient / Entropy temperature\\n # Inverse of the reward scale\\n self.ent_coef = ent_coef\\n self.target_update_interval = target_update_interval\\n self.ent_coef_optimizer = None\\n\\n if _init_setup_model:\\n self._setup_model()\\n\\n def _setup_model(self) -> None:\\n super()._setup_model()\\n self._create_aliases()\\n # Running mean and running var\\n self.batch_norm_stats = get_parameters_by_name(self.critic, [\\\"running_\\\"])\\n self.batch_norm_stats_target = get_parameters_by_name(self.critic_target, [\\\"running_\\\"])\\n # Target entropy is used when learning the entropy coefficient\\n if self.target_entropy == \\\"auto\\\":\\n # automatically set target entropy if needed\\n self.target_entropy = -np.prod(self.env.action_space.shape).astype(np.float32)\\n else:\\n # Force conversion\\n # this will also throw an error for unexpected string\\n self.target_entropy = float(self.target_entropy)\\n\\n # The entropy coefficient or entropy can be learned automatically\\n # see Automating Entropy Adjustment for Maximum Entropy RL section\\n # of https://arxiv.org/abs/1812.05905\\n if isinstance(self.ent_coef, str) and self.ent_coef.startswith(\\\"auto\\\"):\\n # Default initial value of ent_coef when learned\\n init_value = 1.0\\n if \\\"_\\\" in self.ent_coef:\\n init_value = float(self.ent_coef.split(\\\"_\\\")[1])\\n assert init_value > 0.0, \\\"The initial value of ent_coef must be greater than 0\\\"\\n\\n # Note: we optimize the log of the entropy coeff which is slightly different from the paper\\n # as discussed in https://github.com/rail-berkeley/softlearning/issues/37\\n self.log_ent_coef = th.log(th.ones(1, device=self.device) * init_value).requires_grad_(True)\\n self.ent_coef_optimizer = th.optim.Adam([self.log_ent_coef], lr=self.lr_schedule(1))\\n else:\\n # Force conversion to float\\n # this will throw an error if a malformed string (different from 'auto')\\n # is passed\\n self.ent_coef_tensor = th.tensor(float(self.ent_coef), device=self.device)\\n\\n def _create_aliases(self) -> None:\\n self.actor = self.policy.actor\\n self.critic = self.policy.critic\\n self.critic_target = self.policy.critic_target\\n\\n def train(self, gradient_steps: int, batch_size: int = 64) -> None:\\n # Switch to train mode (this affects batch norm / dropout)\\n self.policy.set_training_mode(True)\\n # Update optimizers learning rate\\n optimizers = [self.actor.optimizer, self.critic.optimizer]\\n if self.ent_coef_optimizer is not None:\\n optimizers += [self.ent_coef_optimizer]\\n\\n # Update learning rate according to lr schedule\\n self._update_learning_rate(optimizers)\\n\\n ent_coef_losses, ent_coefs = [], []\\n actor_losses, critic_losses = [], []\\n\\n for gradient_step in range(gradient_steps):\\n # Sample replay buffer\\n replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)\\n\\n # We need to sample because `log_std` may have changed between two gradient steps\\n if self.use_sde:\\n self.actor.reset_noise()\\n\\n # Action by the current actor for the sampled state\\n actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)\\n log_prob = log_prob.reshape(-1, 1)\\n\\n ent_coef_loss = None\\n if self.ent_coef_optimizer is not None:\\n # Important: detach the variable from the graph\\n # so we don't change it with other losses\\n # see https://github.com/rail-berkeley/softlearning/issues/60\\n ent_coef = th.exp(self.log_ent_coef.detach())\\n ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean()\\n ent_coef_losses.append(ent_coef_loss.item())\\n else:\\n ent_coef = self.ent_coef_tensor\\n\\n ent_coefs.append(ent_coef.item())\\n\\n # Optimize entropy coefficient, also called\\n # entropy temperature or alpha in the paper\\n if ent_coef_loss is not None:\\n self.ent_coef_optimizer.zero_grad()\\n ent_coef_loss.backward()\\n self.ent_coef_optimizer.step()\\n\\n with th.no_grad():\\n # Select action according to policy\\n next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)\\n # Compute the next Q values: min over all critics targets\\n next_q_values = th.cat(self.critic_target(replay_data.next_observations, next_actions), dim=1)\\n next_q_values, _ = th.min(next_q_values, dim=1, keepdim=True)\\n # add entropy term\\n next_q_values = next_q_values - ent_coef * next_log_prob.reshape(-1, 1)\\n # td error + entropy term\\n target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values\\n\\n # Get current Q-values estimates for each critic network\\n # using action from the replay buffer\\n current_q_values = self.critic(replay_data.observations, replay_data.actions)\\n\\n # Compute critic loss\\n critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values) for current_q in current_q_values)\\n critic_losses.append(critic_loss.item())\\n\\n # Optimize the critic\\n self.critic.optimizer.zero_grad()\\n critic_loss.backward()\\n self.critic.optimizer.step()\\n\\n # Compute actor loss\\n # Alternative: actor_loss = th.mean(log_prob - qf1_pi)\\n # Min over all critic networks\\n q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)\\n min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)\\n actor_loss = (ent_coef * log_prob - min_qf_pi).mean()\\n actor_losses.append(actor_loss.item())\\n\\n # Optimize the actor\\n self.actor.optimizer.zero_grad()\\n actor_loss.backward()\\n self.actor.optimizer.step()\\n\\n # Update target networks\\n if gradient_step % self.target_update_interval == 0:\\n polyak_update(self.critic.parameters(), self.critic_target.parameters(), self.tau)\\n # Copy running stats, see GH issue #996\\n polyak_update(self.batch_norm_stats, self.batch_norm_stats_target, 1.0)\\n\\n self._n_updates += gradient_steps\\n\\n self.logger.record(\\\"train/n_updates\\\", self._n_updates, exclude=\\\"tensorboard\\\")\\n self.logger.record(\\\"train/ent_coef\\\", np.mean(ent_coefs))\\n self.logger.record(\\\"train/actor_loss\\\", np.mean(actor_losses))\\n self.logger.record(\\\"train/critic_loss\\\", np.mean(critic_losses))\\n if len(ent_coef_losses) > 0:\\n self.logger.record(\\\"train/ent_coef_loss\\\", np.mean(ent_coef_losses))\\n\\n def learn(\\n self: SelfSAC,\\n total_timesteps: int,\\n callback: MaybeCallback = None,\\n log_interval: int = 4,\\n tb_log_name: str = \\\"SAC\\\",\\n reset_num_timesteps: bool = True,\\n progress_bar: bool = False,\\n ) -> SelfSAC:\\n\\n return super().learn(\\n total_timesteps=total_timesteps,\\n callback=callback,\\n log_interval=log_interval,\\n tb_log_name=tb_log_name,\\n reset_num_timesteps=reset_num_timesteps,\\n progress_bar=progress_bar,\\n )\\n\\n def _excluded_save_params(self) -> List[str]:\\n return super()._excluded_save_params() + [\\\"actor\\\", \\\"critic\\\", \\\"critic_target\\\"]\\n\\n def _get_torch_save_params(self) -> Tuple[List[str], List[str]]:\\n state_dicts = [\\\"policy\\\", \\\"actor.optimizer\\\", \\\"critic.optimizer\\\"]\\n if self.ent_coef_optimizer is not None:\\n saved_pytorch_variables = [\\\"log_ent_coef\\\"]\\n state_dicts.append(\\\"ent_coef_optimizer\\\")\\n else:\\n saved_pytorch_variables = [\\\"ent_coef_tensor\\\"]\\n return state_dicts, saved_pytorch_variables\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union\nfrom gym import spaces\nfrom torch.nn import functional as F\nfrom stable_baselines3.common.buffers import ReplayBuffer\nfrom stable_baselines3.common.noise import ActionNoise\nfrom stable_baselines3.common.off_policy_algorithm import OffPolicyAlgorithm\nfrom stable_baselines3.common.policies import BasePolicy\nfrom stable_baselines3.common.type_aliases import GymEnv, MaybeCallback, Schedule\nfrom stable_baselines3.common.utils import get_parameters_by_name, polyak_update\nfrom stable_baselines3.sac_residual.policies import ResidualCnnPolicy, ResidualMlpPolicy, ResidualMultiInputPolicy, ResidualSACPolicy\nfrom stable_baselines3.sac.sac import SAC\nimport numpy as np\nimport torch as th"},"token_num":{"kind":"number","value":17049,"string":"17,049"},"cropped_code":{"kind":"string","value":" target_update_interval=target_update_interval,\n target_entropy=target_entropy,\n use_sde=use_sde,\n sde_sample_freq=sde_sample_freq,\n use_sde_at_warmup=use_sde_at_warmup,\n tensorboard_log=tensorboard_log,\n policy_kwargs=policy_kwargs,\n verbose=verbose,\n seed=seed,\n device=device,\n _init_setup_model=_init_setup_model,\n )\n \n def _setup_model(self) -> None:\n super()._setup_model()\n self.policy.prior_model = SAC.load(self.prior_model_path,env=self.env)\n self.policy.prior_model.policy.set_training_mode(False) # freeze prior model parameters\n\n def train(self, gradient_steps: int, batch_size: int = 64) -> None:\n # Switch to train mode (this affects batch norm / dropout)\n self.policy.set_training_mode(True)\n # Update optimizers learning rate\n optimizers = [self.actor.optimizer, self.critic.optimizer]\n if self.ent_coef_optimizer is not None:\n optimizers += [self.ent_coef_optimizer]\n\n # Update learning rate according to lr schedule\n self._update_learning_rate(optimizers)\n\n ent_coef_losses, ent_coefs = [], []\n actor_losses, critic_losses = [], []\n\n for gradient_step in range(gradient_steps):\n # Sample replay buffer\n replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)\n\n # We need to sample because `log_std` may have changed between two gradient steps\n if self.use_sde:\n self.actor.reset_noise()\n\n # Action by the current actor for the sampled state\n actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)\n log_prob = log_prob.reshape(-1, 1)\n\n # SAC and GAIL prior policy\n prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.observations, actions_pi)\n prior_log_prob = prior_log_prob.reshape(-1, 1)\n\n ent_coef_loss = None\n if self.ent_coef_optimizer is not None:\n # Important: detach the variable from the graph\n # so we don't change it with other losses\n # see https://github.com/rail-berkeley/softlearning/issues/60\n ent_coef = th.exp(self.log_ent_coef.detach())\n ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean()\n ent_coef_losses.append(ent_coef_loss.item())\n else:\n ent_coef = self.ent_coef_tensor\n\n ent_coefs.append(ent_coef.item())\n\n # pre reward normalize to current reward.\n ent_coef_prior = self.policy.prior_model.ent_coef if not isinstance(self.policy.prior_model.ent_coef, str) else ent_coef\n if ent_coef_prior == 0:\n ent_coef_prior = ent_coef\n if self.num_timesteps < self.warmstarting_num_timesteps:\n ent_coef_prior = self.warmstarting_scale * ent_coef_prior\n\n # Optimize entropy coefficient, also called\n # entropy temperature or alpha in the paper\n if ent_coef_loss is not None:\n self.ent_coef_optimizer.zero_grad()\n ent_coef_loss.backward()\n self.ent_coef_optimizer.step()\n\n with th.no_grad():\n # Select action according to policy\n next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)\n next_log_prob = next_log_prob.reshape(-1, 1)\n\n # SAC and GAIL\n next_prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.next_observations, next_actions)\n next_prior_log_prob = next_prior_log_prob.reshape(-1, 1)\n\n # Compute the next Q values: min over all critics targets\n next_q_values = th.cat(self.critic_target(replay_data.next_observations, next_actions), dim=1)\n next_q_values, _ = th.min(next_q_values, dim=1, keepdim=True)\n # add entropy term and prior policy logprob\n next_q_values = next_q_values + ent_coef_prior * next_prior_log_prob - ent_coef * next_log_prob\n # td error + entropy term\n target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values\n\n # Get current Q-values estimates for each critic network\n # using action from the replay buffer\n current_q_values = self.critic(replay_data.observations, replay_data.actions)\n\n # Compute critic loss\n critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values) for current_q in current_q_values)\n critic_losses.append(critic_loss.item())\n\n # Optimize the critic\n self.critic.optimizer.zero_grad()\n critic_loss.backward()\n self.critic.optimizer.step()\n\n # Compute actor loss\n # Alternative: actor_loss = th.mean(log_prob - qf1_pi)\n # Min over all critic networks\n q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)\n min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)\n actor_loss = (ent_coef * log_prob - min_qf_pi - ent_coef_prior * prior_log_prob).mean()\n actor_losses.append(actor_loss.item())\n\n # Optimize the actor\n self.actor.optimizer.zero_grad()\n actor_loss.backward()\n self.actor.optimizer.step()\n\n # Update target networks\n if gradient_step % self.target_update_interval == 0:\n"},"all_code":{"kind":"string","value":"\n\n\nSelfResidualSAC = TypeVar(\"SelfResidualSAC\", bound=\"ResidualSAC\")\n\n\nclass ResidualSAC(SAC):\n \"\"\"\n Residual Soft Actor-Critic (SAC)\n Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor,\n This implementation borrows code from original implementation (https://github.com/haarnoja/sac)\n from OpenAI Spinning Up (https://github.com/openai/spinningup), from the softlearning repo\n (https://github.com/rail-berkeley/softlearning/)\n and from Stable Baselines (https://github.com/hill-a/stable-baselines)\n Paper: https://arxiv.org/abs/1801.01290\n Introduction to SAC: https://spinningup.openai.com/en/latest/algorithms/sac.html\n\n Note: we use double q target and not value target as discussed\n in https://github.com/hill-a/stable-baselines/issues/270\n\n :param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)\n :param env: The environment to learn from (if registered in Gym, can be str)\n :param learning_rate: learning rate for adam optimizer,\n the same learning rate will be used for all networks (Q-Values, Actor and Value function)\n it can be a function of the current progress remaining (from 1 to 0)\n :param buffer_size: size of the replay buffer\n :param learning_starts: how many steps of the model to collect transitions for before learning starts\n :param batch_size: Minibatch size for each gradient update\n :param tau: the soft update coefficient (\"Polyak update\", between 0 and 1)\n :param gamma: the discount factor\n :param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit\n like ``(5, \"step\")`` or ``(2, \"episode\")``.\n :param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)\n Set to ``-1`` means to do as many gradient steps as steps done in the environment\n during the rollout.\n :param action_noise: the action noise type (None by default), this can help\n for hard exploration problem. Cf common.noise for the different action noise type.\n :param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).\n If ``None``, it will be automatically selected.\n :param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.\n :param optimize_memory_usage: Enable a memory efficient variant of the replay buffer\n at a cost of more complexity.\n See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195\n :param ent_coef: Entropy regularization coefficient. (Equivalent to\n inverse of reward scale in the original SAC paper.) Controlling exploration/exploitation trade-off.\n Set it to 'auto' to learn it automatically (and 'auto_0.1' for using 0.1 as initial value)\n :param target_update_interval: update the target network every ``target_network_update_freq``\n gradient steps.\n :param target_entropy: target entropy when learning ``ent_coef`` (``ent_coef = 'auto'``)\n :param use_sde: Whether to use generalized State Dependent Exploration (gSDE)\n instead of action noise exploration (default: False)\n :param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE\n Default: -1 (only sample at the beginning of the rollout)\n :param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling\n during the warm up phase (before learning starts)\n :param policy_kwargs: additional arguments to be passed to the policy on creation\n :param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for\n debug messages\n :param seed: Seed for the pseudo random generators\n :param device: Device (cpu, cuda, ...) on which the code should be run.\n Setting it to auto, the code will be run on the GPU if possible.\n :param _init_setup_model: Whether or not to build the network at the creation of the instance\n \"\"\"\n\n policy_aliases: Dict[str, Type[BasePolicy]] = {\n \"MlpPolicy\": ResidualMlpPolicy,\n \"CnnPolicy\": ResidualCnnPolicy,\n \"MultiInputPolicy\": ResidualMultiInputPolicy,\n }\n\n def __init__(\n self,\n policy: Union[str, Type[ResidualSACPolicy]],\n env: Union[GymEnv, str],\n prior_model_path: str,\n learning_rate: Union[float, Schedule] = 3e-4,\n buffer_size: int = 1_000_000, # 1e6\n learning_starts: int = 100,\n batch_size: int = 256,\n tau: float = 0.005,\n gamma: float = 0.99,\n train_freq: Union[int, Tuple[int, str]] = 1,\n gradient_steps: int = 1,\n warmstarting_num_timesteps: int = 0,\n warmstarting_scale: int = 10,\n action_noise: Optional[ActionNoise] = None,\n replay_buffer_class: Optional[Type[ReplayBuffer]] = None,\n replay_buffer_kwargs: Optional[Dict[str, Any]] = None,\n optimize_memory_usage: bool = False,\n ent_coef: Union[str, float] = \"auto\",\n target_update_interval: int = 1,\n target_entropy: Union[str, float] = \"auto\",\n use_sde: bool = False,\n sde_sample_freq: int = -1,\n use_sde_at_warmup: bool = False,\n tensorboard_log: Optional[str] = None,\n policy_kwargs: Optional[Dict[str, Any]] = None,\n verbose: int = 0,\n seed: Optional[int] = None,\n device: Union[th.device, str] = \"auto\",\n _init_setup_model: bool = True,\n ):\n self.warmstarting_num_timesteps = warmstarting_num_timesteps\n self.warmstarting_scale = warmstarting_scale\n self.prior_model_path = prior_model_path \n super().__init__(\n policy,\n env,\n learning_rate,\n buffer_size,\n learning_starts,\n batch_size,\n tau,\n gamma,\n train_freq,\n gradient_steps,\n action_noise,\n replay_buffer_class=replay_buffer_class,\n replay_buffer_kwargs=replay_buffer_kwargs,\n optimize_memory_usage=optimize_memory_usage,\n ent_coef=ent_coef,\n target_update_interval=target_update_interval,\n target_entropy=target_entropy,\n use_sde=use_sde,\n sde_sample_freq=sde_sample_freq,\n use_sde_at_warmup=use_sde_at_warmup,\n tensorboard_log=tensorboard_log,\n policy_kwargs=policy_kwargs,\n verbose=verbose,\n seed=seed,\n device=device,\n _init_setup_model=_init_setup_model,\n )\n \n def _setup_model(self) -> None:\n super()._setup_model()\n self.policy.prior_model = SAC.load(self.prior_model_path,env=self.env)\n self.policy.prior_model.policy.set_training_mode(False) # freeze prior model parameters\n\n def train(self, gradient_steps: int, batch_size: int = 64) -> None:\n # Switch to train mode (this affects batch norm / dropout)\n self.policy.set_training_mode(True)\n # Update optimizers learning rate\n optimizers = [self.actor.optimizer, self.critic.optimizer]\n if self.ent_coef_optimizer is not None:\n optimizers += [self.ent_coef_optimizer]\n\n # Update learning rate according to lr schedule\n self._update_learning_rate(optimizers)\n\n ent_coef_losses, ent_coefs = [], []\n actor_losses, critic_losses = [], []\n\n for gradient_step in range(gradient_steps):\n # Sample replay buffer\n replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)\n\n # We need to sample because `log_std` may have changed between two gradient steps\n if self.use_sde:\n self.actor.reset_noise()\n\n # Action by the current actor for the sampled state\n actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)\n log_prob = log_prob.reshape(-1, 1)\n\n # SAC and GAIL prior policy\n prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.observations, actions_pi)\n prior_log_prob = prior_log_prob.reshape(-1, 1)\n\n ent_coef_loss = None\n if self.ent_coef_optimizer is not None:\n # Important: detach the variable from the graph\n # so we don't change it with other losses\n # see https://github.com/rail-berkeley/softlearning/issues/60\n ent_coef = th.exp(self.log_ent_coef.detach())\n ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean()\n ent_coef_losses.append(ent_coef_loss.item())\n else:\n ent_coef = self.ent_coef_tensor\n\n ent_coefs.append(ent_coef.item())\n\n # pre reward normalize to current reward.\n ent_coef_prior = self.policy.prior_model.ent_coef if not isinstance(self.policy.prior_model.ent_coef, str) else ent_coef\n if ent_coef_prior == 0:\n ent_coef_prior = ent_coef\n if self.num_timesteps < self.warmstarting_num_timesteps:\n ent_coef_prior = self.warmstarting_scale * ent_coef_prior\n\n # Optimize entropy coefficient, also called\n # entropy temperature or alpha in the paper\n if ent_coef_loss is not None:\n self.ent_coef_optimizer.zero_grad()\n ent_coef_loss.backward()\n self.ent_coef_optimizer.step()\n\n with th.no_grad():\n # Select action according to policy\n next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)\n next_log_prob = next_log_prob.reshape(-1, 1)\n\n # SAC and GAIL\n next_prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.next_observations, next_actions)\n next_prior_log_prob = next_prior_log_prob.reshape(-1, 1)\n\n # Compute the next Q values: min over all critics targets\n next_q_values = th.cat(self.critic_target(replay_data.next_observations, next_actions), dim=1)\n next_q_values, _ = th.min(next_q_values, dim=1, keepdim=True)\n # add entropy term and prior policy logprob\n next_q_values = next_q_values + ent_coef_prior * next_prior_log_prob - ent_coef * next_log_prob\n # td error + entropy term\n target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values\n\n # Get current Q-values estimates for each critic network\n # using action from the replay buffer\n current_q_values = self.critic(replay_data.observations, replay_data.actions)\n\n # Compute critic loss\n critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values) for current_q in current_q_values)\n critic_losses.append(critic_loss.item())\n\n # Optimize the critic\n self.critic.optimizer.zero_grad()\n critic_loss.backward()\n self.critic.optimizer.step()\n\n # Compute actor loss\n # Alternative: actor_loss = th.mean(log_prob - qf1_pi)\n # Min over all critic networks\n q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)\n min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)\n actor_loss = (ent_coef * log_prob - min_qf_pi - ent_coef_prior * prior_log_prob).mean()\n actor_losses.append(actor_loss.item())\n\n # Optimize the actor\n self.actor.optimizer.zero_grad()\n actor_loss.backward()\n self.actor.optimizer.step()\n\n # Update target networks\n if gradient_step % self.target_update_interval == 0:"},"next_line":{"kind":"string","value":" polyak_update(self.critic.parameters(), self.critic_target.parameters(), self.tau)"},"gold_snippet_index":{"kind":"number","value":6,"string":"6"},"created_at":{"kind":"string","value":"2023-10-28 01:09:21+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5693,"cells":{"repo_name":{"kind":"string","value":"pytabular-ai/auto-scikit-dl"},"file_path":{"kind":"string","value":"utils/model.py"},"context":{"kind":"list like","value":[{"identifier":"MLP","path":"models/mlp.py","snippet":"class MLP(TabModel):\n def __init__(\n self,\n model_config: dict,\n n_num_features: int,\n categories: ty.Optional[ty.List[int]],\n n_labels: int,\n device: ty.Union[str, torch.device] = 'cuda',\n ):\n super().__init__()\n model_config = self.preproc_config(model_config)\n self.model = _MLP(\n d_in=n_num_features,\n categories=categories,\n d_out=n_labels,\n **model_config\n ).to(device)\n self.base_name = 'mlp'\n self.device = torch.device(device)\n \n def preproc_config(self, model_config: dict):\n \"\"\"MLP config preprocessing\"\"\"\n # process mlp configs\n self.saved_model_config = model_config.copy()\n d_layers = []\n n_layers, first_dim, mid_dim, last_dim = \\\n (\n model_config.pop('n_layers'), model_config.pop('first_dim'),\n model_config.pop('mid_dim'), model_config.pop('last_dim')\n )\n for i in range(n_layers):\n if i == 0:\n d_layers.append(first_dim)\n elif i == n_layers - 1 and n_layers > 1:\n d_layers.append(last_dim)\n else:\n d_layers.append(mid_dim)\n model_config['d_layers'] = d_layers\n return model_config\n\n def fit(\n self,\n # API for specical sampler like curriculum learning\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\n # using normal sampler if is None\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None,\n y_std: ty.Optional[float] = None, # for RMSE\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\n patience: int = 0,\n task: str = None,\n training_args: dict = None,\n meta_args: ty.Optional[dict] = None,\n ):\n def train_step(model, x_num, x_cat, y): # input is X and y\n # process input (model-specific)\n # define your running time calculation\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time # don't forget backward time, calculate in outer loop\n return logits, used_time\n \n # to custom other training paradigm\n # 1. add self.dnn_fit2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_fit in abstract class\n self.dnn_fit( # uniform training paradigm\n dnn_fit_func=train_step,\n # training data\n train_loader=train_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\n # dev data\n eval_set=eval_set, patience=patience, task=task,\n # args\n training_args=training_args,\n meta_args=meta_args,\n )\n \n def predict(\n self,\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None, \n y_std: ty.Optional[float] = None, # for RMSE\n task: str = None,\n return_probs: bool = True,\n return_metric: bool = False,\n return_loss: bool = False,\n meta_args: ty.Optional[dict] = None,\n ):\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\n \"\"\"\n Inference Process\n `no_grad` will be applied in `dnn_predict'\n \"\"\"\n # process input (model-specific)\n # define your running time calculation\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other inference paradigm\n # 1. add self.dnn_predict2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_predict in abstract class\n return self.dnn_predict( # uniform training paradigm\n dnn_predict_func=inference_step,\n dev_loader=dev_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\n meta_args=meta_args\n )\n \n def save(self, output_dir):\n check_dir(output_dir)\n self.save_pt_model(output_dir)\n self.save_history(output_dir)\n self.save_config(output_dir)"},{"identifier":"FTTransformer","path":"models/ft_transformer.py","snippet":"class FTTransformer(TabModel):\n def __init__(\n self,\n model_config: dict,\n n_num_features: int,\n categories: ty.Optional[ty.List[int]],\n n_labels: int,\n device: ty.Union[str, torch.device] = 'cuda',\n ):\n super().__init__()\n model_config = self.preproc_config(model_config)\n self.model = rtdl.FTTransformer.make_baseline(\n n_num_features=n_num_features,\n cat_cardinalities=categories,\n d_out=n_labels,\n **model_config\n ).to(device)\n self.base_name = 'ft-transformer'\n self.device = torch.device(device)\n \n def preproc_config(self, model_config: dict):\n self.saved_model_config = model_config.copy()\n # process ftt configs\n if 'ffn_d_factor' in model_config:\n model_config['ffn_d_hidden'] = \\\n int(model_config['d_token'] * model_config.pop('ffn_d_factor'))\n return model_config\n \n def fit(\n self,\n # API for specical sampler like curriculum learning\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\n # using normal sampler if is None\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None,\n y_std: ty.Optional[float] = None, # for RMSE\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\n patience: int = 0,\n task: str = None,\n training_args: dict = None,\n meta_args: ty.Optional[dict] = None,\n ):\n def train_step(model, x_num, x_cat, y): # input is X and y\n # process input (model-specific)\n # define your running time calculation\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time # don't forget backward time, calculate in outer loop\n return logits, used_time\n \n # to custom other training paradigm\n # 1. add self.dnn_fit2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_fit in abstract class\n self.dnn_fit( # uniform training paradigm\n dnn_fit_func=train_step,\n # training data\n train_loader=train_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\n # dev data\n eval_set=eval_set, patience=patience, task=task,\n # args\n training_args=training_args,\n meta_args=meta_args,\n )\n \n def predict(\n self,\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None, \n y_std: ty.Optional[float] = None, # for RMSE\n task: str = None,\n return_probs: bool = True,\n return_metric: bool = False,\n return_loss: bool = False,\n meta_args: ty.Optional[dict] = None,\n ):\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\n \"\"\"\n Inference Process\n `no_grad` will be applied in `dnn_predict'\n \"\"\"\n # process input (model-specific)\n # define your running time calculation\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other inference paradigm\n # 1. add self.dnn_predict2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_predict in abstract class\n return self.dnn_predict( # uniform training paradigm\n dnn_predict_func=inference_step,\n dev_loader=dev_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\n meta_args=meta_args\n )\n \n def save(self, output_dir):\n check_dir(output_dir)\n self.save_pt_model(output_dir)\n self.save_history(output_dir)\n self.save_config(output_dir)"},{"identifier":"AutoInt","path":"models/autoint.py","snippet":"class AutoInt(TabModel):\n def __init__(\n self,\n model_config: dict,\n n_num_features: int,\n categories: ty.Optional[ty.List[int]],\n n_labels: int,\n device: ty.Union[str, torch.device] = 'cuda',\n ):\n super().__init__()\n model_config = self.preproc_config(model_config)\n self.model = _AutoInt(\n d_numerical=n_num_features,\n categories=categories,\n d_out=n_labels,\n **model_config\n ).to(device)\n self.base_name = 'autoint'\n self.device = torch.device(device)\n \n def preproc_config(self, model_config: dict):\n # process autoint configs\n self.saved_model_config = model_config.copy()\n return model_config\n\n def fit(\n self,\n # API for specical sampler like curriculum learning\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\n # using normal sampler if is None\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None,\n y_std: ty.Optional[float] = None, # for RMSE\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\n patience: int = 0,\n task: str = None,\n training_args: dict = None,\n meta_args: ty.Optional[dict] = None,\n ):\n def train_step(model, x_num, x_cat, y): # input is X and y\n # process input (model-specific)\n # define your model API\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other training paradigm\n # 1. add self.dnn_fit2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_fit in abstract class\n self.dnn_fit( # uniform training paradigm\n dnn_fit_func=train_step,\n # training data\n train_loader=train_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\n # dev data\n eval_set=eval_set, patience=patience, task=task,\n # args\n training_args=training_args,\n meta_args=meta_args,\n )\n \n def predict(\n self,\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None, \n y_std: ty.Optional[float] = None, # for RMSE\n task: str = None,\n return_probs: bool = True,\n return_metric: bool = False,\n return_loss: bool = False,\n meta_args: ty.Optional[dict] = None,\n ):\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\n \"\"\"\n Inference Process\n `no_grad` will be applied in `dnn_predict'\n \"\"\"\n # process input (model-specific)\n # define your model API\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other inference paradigm\n # 1. add self.dnn_predict2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_predict in abstract class\n return self.dnn_predict( # uniform training paradigm\n dnn_predict_func=inference_step,\n dev_loader=dev_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\n meta_args=meta_args,\n )\n \n def save(self, output_dir):\n check_dir(output_dir)\n self.save_pt_model(output_dir)\n self.save_history(output_dir)\n self.save_config(output_dir)"},{"identifier":"DCNv2","path":"models/dcnv2.py","snippet":"class DCNv2(TabModel):\n def __init__(\n self,\n model_config: dict,\n n_num_features: int,\n categories: ty.Optional[ty.List[int]],\n n_labels: int,\n device: ty.Union[str, torch.device] = 'cuda',\n ):\n super().__init__()\n model_config = self.preproc_config(model_config)\n self.model = _DCNv2(\n d_in=n_num_features,\n categories=categories,\n d_out=n_labels,\n **model_config\n ).to(device)\n self.base_name = 'dcnv2'\n self.device = torch.device(device)\n \n def preproc_config(self, model_config: dict):\n # process autoint configs\n self.saved_model_config = model_config.copy()\n return model_config\n\n def fit(\n self,\n # API for specical sampler like curriculum learning\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\n # using normal sampler if is None\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None,\n y_std: ty.Optional[float] = None, # for RMSE\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\n patience: int = 0,\n task: str = None,\n training_args: dict = None,\n meta_args: ty.Optional[dict] = None,\n ):\n def train_step(model, x_num, x_cat, y): # input is X and y\n # process input (model-specific)\n # define your model API\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other training paradigm\n # 1. add self.dnn_fit2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_fit in abstract class\n self.dnn_fit( # uniform training paradigm\n dnn_fit_func=train_step,\n # training data\n train_loader=train_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\n # dev data\n eval_set=eval_set, patience=patience, task=task,\n # args\n training_args=training_args,\n meta_args=meta_args,\n )\n \n def predict(\n self,\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None, \n y_std: ty.Optional[float] = None, # for RMSE\n task: str = None,\n return_probs: bool = True,\n return_metric: bool = False,\n return_loss: bool = False,\n meta_args: ty.Optional[dict] = None,\n ):\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\n \"\"\"\n Inference Process\n `no_grad` will be applied in `dnn_predict'\n \"\"\"\n # process input (model-specific)\n # define your model API\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other inference paradigm\n # 1. add self.dnn_predict2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_predict in abstract class\n return self.dnn_predict( # uniform training paradigm\n dnn_predict_func=inference_step,\n dev_loader=dev_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\n meta_args=meta_args\n )\n \n def save(self, output_dir):\n check_dir(output_dir)\n self.save_pt_model(output_dir)\n self.save_history(output_dir)\n self.save_config(output_dir)"},{"identifier":"NODE","path":"models/node_model.py","snippet":"class NODE(TabModel):\n def __init__(\n self,\n model_config: dict,\n n_num_features: int,\n categories: ty.Optional[ty.List[int]],\n n_labels: int,\n device: ty.Union[str, torch.device] = 'cuda',\n ):\n super().__init__()\n model_config = self.preproc_config(model_config)\n self.model = _NODE(\n d_in=n_num_features,\n categories=categories,\n d_out=n_labels,\n tree_dim=n_labels,\n **model_config\n ).to(device)\n self.base_name = 'node'\n self.device = torch.device(device)\n \n def preproc_config(self, model_config: dict):\n # process autoint configs\n self.saved_model_config = model_config.copy()\n return model_config\n\n def fit(\n self,\n # API for specical sampler like curriculum learning\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\n # using normal sampler if is None\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None,\n y_std: ty.Optional[float] = None, # for RMSE\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\n patience: int = 0,\n task: str = None,\n training_args: dict = None,\n meta_args: ty.Optional[dict] = None,\n ):\n def train_step(model, x_num, x_cat, y): # input is X and y\n # process input (model-specific)\n # define your model API\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other training paradigm\n # 1. add self.dnn_fit2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_fit in abstract class\n self.dnn_fit( # uniform training paradigm\n dnn_fit_func=train_step,\n # training data\n train_loader=train_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\n # dev data\n eval_set=eval_set, patience=patience, task=task,\n # args\n training_args=training_args,\n meta_args=meta_args,\n )\n \n def predict(\n self,\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\n X_num: ty.Optional[torch.Tensor] = None, \n X_cat: ty.Optional[torch.Tensor] = None, \n ys: ty.Optional[torch.Tensor] = None, \n y_std: ty.Optional[float] = None, # for RMSE\n task: str = None,\n return_probs: bool = True,\n return_metric: bool = False,\n return_loss: bool = False,\n meta_args: ty.Optional[dict] = None,\n ):\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\n \"\"\"\n Inference Process\n `no_grad` will be applied in `dnn_predict'\n \"\"\"\n # process input (model-specific)\n # define your running time calculation\n start_time = time.time()\n # define your model API\n logits = model(x_num, x_cat)\n used_time = time.time() - start_time\n return logits, used_time\n \n # to custom other inference paradigm\n # 1. add self.dnn_predict2(...) in abstract class for special training process\n # 2. (recommended) override self.dnn_predict in abstract class\n return self.dnn_predict( # uniform training paradigm\n dnn_predict_func=inference_step,\n dev_loader=dev_loader,\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\n meta_args=meta_args\n )\n \n def save(self, output_dir):\n check_dir(output_dir)\n self.save_pt_model(output_dir)\n self.save_history(output_dir)\n self.save_config(output_dir)"},{"identifier":"TabModel","path":"models/abstract.py","snippet":"class TabModel(ABC):\n def __init__(self):\n self.model: Optional[nn.Module] = None # true model\n self.base_name = None # model type name\n self.device = None\n self.saved_model_config = None\n self.training_config = None\n self.meta_config = None\n self.post_init()\n\n def post_init(self):\n self.history = {\n 'train': {'loss': [], 'tot_time': 0, 'avg_step_time': 0, 'avg_epoch_time': 0}, \n 'val': {\n 'metric_name': None, 'metric': [], 'best_metric': None, \n 'log_loss': [], 'best_log_loss': None,\n 'best_epoch': None, 'best_step': None,\n 'tot_time': 0, 'avg_step_time': 0, 'avg_epoch_time': 0\n }, \n # 'test': {'loss': [], 'metric': [], 'final_metric': None},\n 'device': torch.cuda.get_device_name(),\n } # save metrics\n self.no_improvement = 0 # for dnn early stop\n \n def preproc_config(self, model_config: dict):\n \"\"\"default preprocessing for model configurations\"\"\"\n self.saved_model_config = model_config\n return model_config\n \n @abstractmethod\n def fit(\n self,\n X_num: Union[torch.Tensor, np.ndarray], \n X_cat: Union[torch.Tensor, np.ndarray], \n ys: Union[torch.Tensor, np.ndarray],\n y_std: Optional[float],\n eval_set: Optional[Tuple[Union[torch.Tensor, np.ndarray]]],\n patience: int,\n task: str,\n training_args: dict,\n meta_args: Optional[dict],\n ):\n \"\"\"\n Training Model with Early Stop(optional)\n load best weights at the end\n \"\"\"\n pass\n \n def dnn_fit(\n self,\n *,\n dnn_fit_func: Optional[DNN_FIT_API] = None,\n # API for specical sampler like curriculum learning\n train_loader: Optional[Tuple[DataLoader, int]] = None, # (loader, missing_idx)\n # using normal dataloader sampler if is None\n X_num: Optional[torch.Tensor] = None, \n X_cat: Optional[torch.Tensor] = None, \n ys: Optional[torch.Tensor] = None,\n y_std: Optional[float] = None, # for RMSE\n eval_set: Tuple[torch.Tensor, np.ndarray] = None, # similar API as sk-learn\n patience: int = 0, # <= 0 without early stop\n task: str,\n training_args: dict,\n meta_args: Optional[dict] = None,\n ):\n # DONE: move to abstract class (dnn_fit)\n if dnn_fit_func is None:\n dnn_fit_func = default_dnn_fit\n # meta args\n if meta_args is None:\n meta_args = {}\n meta_args.setdefault('save_path', f'results/{self.base_name}')\n if not os.path.exists(meta_args['save_path']):\n print('create new results dir: ', meta_args['save_path'])\n os.makedirs(meta_args['save_path'])\n self.meta_config = meta_args\n # optimzier and scheduler\n training_args.setdefault('optimizer', 'adamw')\n optimizer, scheduler = TabModel.make_optimizer(self.model, training_args)\n # data loader\n training_args.setdefault('batch_size', 64)\n training_args.setdefault('ghost_batch_size', None)\n if train_loader is not None:\n train_loader, missing_idx = train_loader\n training_args['batch_size'] = train_loader.batch_size\n else:\n train_loader, missing_idx = TabModel.prepare_tensor_loader(\n X_num=X_num, X_cat=X_cat, ys=ys,\n batch_size=training_args['batch_size'],\n shuffle=True,\n )\n if eval_set is not None:\n eval_set = eval_set[0] # only use the first dev set\n dev_loader = TabModel.prepare_tensor_loader(\n X_num=eval_set[0], X_cat=eval_set[1], ys=eval_set[2],\n batch_size=training_args['batch_size'],\n )\n else:\n dev_loader = None\n # training loops\n training_args.setdefault('max_epochs', 1000)\n # training_args.setdefault('report_frequency', 100) # same as save_freq\n # training_args.setdefault('save_frequency', 100) # save per 100 steps\n training_args.setdefault('patience', patience)\n training_args.setdefault('save_frequency', 'epoch') # save per epoch\n self.training_config = training_args\n\n steps_per_backward = 1 if training_args['ghost_batch_size'] is None \\\n else training_args['batch_size'] // training_args['ghost_batch_size']\n steps_per_epoch = len(train_loader)\n tot_step, tot_time = 0, 0\n for e in range(training_args['max_epochs']):\n self.model.train()\n tot_loss = 0\n for step, batch in enumerate(train_loader):\n optimizer.zero_grad()\n x_num, x_cat, y = TabModel.parse_batch(batch, missing_idx, self.device)\n logits, forward_time = dnn_fit_func(self.model, x_num, x_cat, y)\n loss = TabModel.compute_loss(logits, y, task)\n # backward\n start_time = time.time()\n loss.backward()\n backward_time = time.time() - start_time\n self.gradient_policy()\n tot_time += forward_time + backward_time\n optimizer.step()\n if scheduler is not None:\n scheduler.step()\n # print or save infos\n tot_step += 1\n tot_loss += loss.cpu().item()\n if isinstance(training_args['save_frequency'], int) \\\n and tot_step % training_args['save_frequency'] == 0:\n is_early_stop = self.save_evaluate_dnn(\n tot_step, steps_per_epoch, \n tot_loss, tot_time,\n task, training_args['patience'], meta_args['save_path'],\n dev_loader, y_std,\n )\n if is_early_stop:\n self.save(meta_args['save_path'])\n self.load_best_dnn(meta_args['save_path'])\n return\n if training_args['save_frequency'] == 'epoch':\n if hasattr(self.model, 'layer_masks'):\n print('layer_mask: ', self.model.layer_masks > 0)\n is_early_stop = self.save_evaluate_dnn(\n tot_step, steps_per_epoch, \n tot_loss, tot_time,\n task, training_args['patience'], meta_args['save_path'],\n dev_loader, y_std,\n )\n if is_early_stop:\n self.save(meta_args['save_path'])\n self.load_best_dnn(meta_args['save_path'])\n return\n self.save(meta_args['save_path'])\n self.load_best_dnn(meta_args['save_path'])\n \n @abstractmethod\n def predict(\n self,\n dev_loader: Optional[DataLoader],\n X_num: Union[torch.Tensor, np.ndarray], \n X_cat: Union[torch.Tensor, np.ndarray], \n ys: Union[torch.Tensor, np.ndarray],\n y_std: Optional[float],\n task: str,\n return_probs: bool = True,\n return_metric: bool = True,\n return_loss: bool = True,\n meta_args: Optional[dict] = None,\n ):\n \"\"\"\n Prediction\n \"\"\"\n pass\n \n def dnn_predict(\n self,\n *,\n dnn_predict_func: Optional[DNN_PREDICT_API] = None,\n dev_loader: Optional[Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\n X_num: Optional[torch.Tensor] = None, \n X_cat: Optional[torch.Tensor] = None, \n ys: Optional[torch.Tensor] = None, \n y_std: Optional[float] = None, # for RMSE\n task: str,\n return_probs: bool = True,\n return_metric: bool = False,\n return_loss: bool = False,\n meta_args: Optional[dict] = None,\n ):\n # DONE: move to abstract class (dnn_predict)\n if dnn_predict_func is None:\n dnn_predict_func = default_dnn_predict\n if dev_loader is None:\n dev_loader, missing_idx = TabModel.prepare_tensor_loader(\n X_num=X_num, X_cat=X_cat, ys=ys,\n batch_size=128,\n )\n else:\n dev_loader, missing_idx = dev_loader\n # print(\"Evaluate...\")\n predictions, golds = [], []\n tot_time = 0\n self.model.eval()\n for batch in dev_loader:\n x_num, x_cat, y = TabModel.parse_batch(batch, missing_idx, self.device)\n with torch.no_grad():\n logits, used_time = dnn_predict_func(self.model, x_num, x_cat)\n tot_time += used_time\n predictions.append(logits)\n golds.append(y)\n self.model.train()\n predictions = torch.cat(predictions).squeeze(-1)\n golds = torch.cat(golds)\n if return_loss:\n loss = TabModel.compute_loss(predictions, golds, task).cpu().item()\n else:\n loss = None\n if return_probs and task != 'regression':\n predictions = (\n predictions.sigmoid()\n if task == 'binclass'\n else predictions.softmax(-1)\n )\n prediction_type = 'probs'\n elif task == 'regression':\n prediction_type = None\n else:\n prediction_type = 'logits'\n predictions = predictions.cpu().numpy()\n golds = golds.cpu().numpy()\n if return_metric:\n metric = TabModel.calculate_metric(\n golds, predictions,\n task, prediction_type, y_std\n )\n logloss = (\n log_loss(golds, np.stack([1-predictions, predictions], axis=1), labels=[0,1])\n if task == 'binclass'\n else log_loss(golds, predictions, labels=list(range(len(set(golds)))))\n if task == 'multiclass'\n else None\n )\n else:\n metric, logloss = None, None\n results = {'loss': loss, 'metric': metric, 'time': tot_time, 'log_loss': logloss}\n if meta_args is not None:\n self.save_prediction(meta_args['save_path'], results)\n return predictions, results\n \n def gradient_policy(self):\n \"\"\"For post porcess model gradient\"\"\"\n pass\n \n @abstractmethod\n def save(self, output_dir):\n \"\"\"\n Save model weights and configs,\n the following default save functions\n can be combined to override this function\n \"\"\"\n pass\n\n def save_pt_model(self, output_dir):\n print('saving pt model weights...')\n # save model params\n torch.save(self.model.state_dict(), Path(output_dir) / 'final.bin')\n \n def save_tree_model(self, output_dir):\n print('saving tree model...')\n pass\n\n def save_history(self, output_dir):\n # save metrics\n with open(Path(output_dir) / 'results.json', 'w') as f:\n json.dump(self.history, f, indent=4)\n \n def save_prediction(self, output_dir, results, file='prediction'):\n check_dir(output_dir)\n # save test results\n print(\"saving prediction results\")\n saved_results = {\n 'loss': results['loss'], \n 'metric_name': results['metric'][1], \n 'metric': results['metric'][0], \n 'time': results['time'],\n 'log_loss': results['log_loss'],\n }\n with open(Path(output_dir) / f'{file}.json', 'w') as f:\n json.dump(saved_results, f, indent=4)\n \n def save_config(self, output_dir):\n def serialize(config: dict):\n for key in config:\n # serialized object to store yaml or json files \n if any(isinstance(config[key], obj) for obj in [Path, ]):\n config[key] = str(config[key])\n return config\n # save all configs\n with open(Path(output_dir) / 'configs.yaml', 'w') as f:\n configs = {\n 'model': self.saved_model_config, \n 'training': self.training_config,\n 'meta': serialize(self.meta_config)\n }\n yaml.dump(configs, f, indent=2)\n\n @staticmethod\n def make_optimizer(\n model: nn.Module,\n training_args: dict,\n ) -> Tuple[optim.Optimizer, optim.lr_scheduler._LRScheduler]:\n training_args.setdefault('optimizer', 'adamw')\n training_args.setdefault('no_wd_group', None)\n training_args.setdefault('scheduler', None)\n # optimizer\n if training_args['no_wd_group'] is not None:\n assert isinstance(training_args['no_wd_group'], list)\n def needs_wd(name):\n return all(x not in name for x in training_args['no_wd_group'])\n parameters_with_wd = [v for k, v in model.named_parameters() if needs_wd(k)]\n parameters_without_wd = [v for k, v in model.named_parameters() if not needs_wd(k)]\n model_params = [\n {'params': parameters_with_wd},\n {'params': parameters_without_wd, 'weight_decay': 0.0},\n ]\n else:\n model_params = model.parameters()\n optimizer = make_optimizer(\n training_args['optimizer'],\n model_params,\n training_args['lr'],\n training_args['weight_decay'],\n )\n # scheduler\n if training_args['scheduler'] is not None:\n scheduler = None\n else:\n scheduler = None\n\n return optimizer, scheduler\n \n @staticmethod\n def prepare_tensor_loader(\n X_num: Optional[torch.Tensor],\n X_cat: Optional[torch.Tensor],\n ys: torch.Tensor,\n batch_size: int = 64,\n shuffle: bool = False,\n ):\n assert not all(x is None for x in [X_num, X_cat])\n missing_placeholder = 0 if X_num is None else 1 if X_cat is None else -1\n datas = [x for x in [X_num, X_cat, ys] if x is not None]\n tensor_dataset = TensorDataset(*datas)\n tensor_loader = DataLoader(\n tensor_dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n )\n return tensor_loader, missing_placeholder\n \n @staticmethod\n def parse_batch(batch: Tuple[torch.Tensor], missing_idx, device: torch.device):\n if batch[0].device.type != device.type:\n # if batch[0].device != device: # initialize self.device with model.device rather than torch.device()\n # batch = (x.to(device) for x in batch) # generator\n batch = tuple([x.to(device) for x in batch]) # list\n if missing_idx == -1:\n return batch\n else:\n return batch[:missing_idx] + [None,] + batch[missing_idx:]\n \n @staticmethod\n def compute_loss(logits: torch.Tensor, targets: torch.Tensor, task: str, reduction: str = 'mean'):\n loss_fn = {\n 'binclass': F.binary_cross_entropy_with_logits,\n 'multiclass': F.cross_entropy,\n 'regression': F.mse_loss,\n }[task]\n return loss_fn(logits.squeeze(-1), targets, reduction=reduction)\n \n @staticmethod\n def calculate_metric(\n golds,\n predictions,\n task: str,\n prediction_type: Optional[str] = None,\n y_std: Optional[float] = None,\n ):\n \"\"\"Calculate metrics\"\"\"\n metric = {\n 'regression': 'rmse', \n 'binclass': 'roc_auc', \n 'multiclass': 'accuracy'\n }[task]\n \n return calculate_metrics(\n golds, predictions,\n task, prediction_type, y_std\n )[metric], metric\n \n def better_result(self, dev_metric, task, is_loss=False):\n if is_loss: # logloss\n best_dev_metric = self.history['val']['best_log_loss']\n if best_dev_metric is None or best_dev_metric > dev_metric:\n self.history['val']['best_log_loss'] = dev_metric\n return True\n else:\n return False\n best_dev_metric = self.history['val']['best_metric']\n if best_dev_metric is None:\n self.history['val']['best_metric'] = dev_metric\n return True\n elif task == 'regression': # rmse\n if best_dev_metric > dev_metric:\n self.history['val']['best_metric'] = dev_metric\n return True\n else:\n return False\n else:\n if best_dev_metric < dev_metric:\n self.history['val']['best_metric'] = dev_metric\n return True\n else:\n return False\n \n def early_stop_handler(self, epoch, tot_step, dev_metric, task, patience, save_path):\n if task != 'regression' and self.better_result(dev_metric['log_loss'], task, is_loss=True):\n # record best logloss\n torch.save(self.model.state_dict(), Path(save_path) / 'best-logloss.bin')\n if self.better_result(dev_metric['metric'], task):\n print('<<< Best Dev Result', end='')\n torch.save(self.model.state_dict(), Path(save_path) / 'best.bin')\n self.no_improvement = 0\n self.history['val']['best_epoch'] = epoch\n self.history['val']['best_step'] = tot_step\n else:\n self.no_improvement += 1\n print(f'| [no improvement] {self.no_improvement}', end='')\n if patience <= 0:\n return False\n else:\n return self.no_improvement >= patience\n \n def save_evaluate_dnn(\n self, \n # print and saved infos\n tot_step, steps_per_epoch, \n tot_loss, tot_time,\n # evaluate infos\n task, patience, save_path,\n dev_loader, y_std\n ):\n \"\"\"For DNN models\"\"\"\n epoch, step = tot_step // steps_per_epoch, (tot_step - 1) % steps_per_epoch + 1\n avg_loss = tot_loss / step\n self.history['train']['loss'].append(avg_loss)\n self.history['train']['tot_time'] = tot_time\n self.history['train']['avg_step_time'] = tot_time / tot_step\n self.history['train']['avg_epoch_time'] = self.history['train']['avg_step_time'] * steps_per_epoch\n print(f\"[epoch] {epoch} | [step] {step} | [tot_step] {tot_step} | [used time] {tot_time:.4g} | [train_loss] {avg_loss:.4g} \", end='')\n if dev_loader is not None:\n _, results = self.predict(dev_loader=dev_loader, y_std=y_std, task=task, return_metric=True)\n dev_metric, metric_name = results['metric']\n print(f\"| [{metric_name}] {dev_metric:.4g} \", end='')\n if task != 'regression':\n print(f\"| [log-loss] {results['log_loss']:.4g} \", end='')\n self.history['val']['log_loss'].append(results['log_loss'])\n self.history['val']['metric_name'] = metric_name\n self.history['val']['metric'].append(dev_metric)\n self.history['val']['tot_time'] += results['time']\n self.history['val']['avg_step_time'] = self.history['val']['tot_time'] / tot_step\n self.history['val']['avg_epoch_time'] = self.history['val']['avg_step_time'] * steps_per_epoch\n dev_metric = {'metric': dev_metric, 'log_loss': results['log_loss']}\n if self.early_stop_handler(epoch, tot_step, dev_metric, task, patience, save_path):\n print(' <<< Early Stop')\n return True\n print()\n return False\n \n def load_best_dnn(self, save_path, file='best'):\n model_file = Path(save_path) / f\"{file}.bin\"\n if not os.path.exists(model_file):\n print(f'There is no {file} checkpoint, loading the last one...')\n model_file = Path(save_path) / 'final.bin'\n else:\n print(f'Loading {file} model...')\n self.model.load_state_dict(torch.load(model_file))\n print('successfully')"},{"identifier":"check_dir","path":"models/abstract.py","snippet":"def check_dir(dir):\n if not os.path.exists(dir):\n os.makedirs(dir)"},{"identifier":"Dataset","path":"data/utils.py","snippet":"class Dataset:\n X_num: Optional[ArrayDict]\n X_cat: Optional[ArrayDict]\n y: ArrayDict\n y_info: Dict[str, Any]\n task_type: TaskType\n n_classes: Optional[int]\n name: Optional[str]\n\n @classmethod\n def from_dir(cls, dir_: Union[Path, str]) -> 'Dataset':\n dir_ = Path(dir_)\n\n def load(item) -> ArrayDict:\n def _load(file: Path):\n return cast(np.ndarray, np.load(file)) if file.exists() else None\n return {\n x: _load(dir_ / f'{item}_{x}.npy')\n for x in ['train', 'val', 'test']\n }\n\n info = load_json(dir_ / 'info.json')\n\n return Dataset(\n load('X_num') if dir_.joinpath('X_num_train.npy').exists() else None,\n load('X_cat') if dir_.joinpath('X_cat_train.npy').exists() else None,\n load('y'),\n {},\n TaskType(info['task_type']),\n info.get('n_classes'),\n info.get('name'),\n )\n\n @property\n def is_binclass(self) -> bool:\n return self.task_type == TaskType.BINCLASS\n\n @property\n def is_multiclass(self) -> bool:\n return self.task_type == TaskType.MULTICLASS\n\n @property\n def is_regression(self) -> bool:\n return self.task_type == TaskType.REGRESSION\n\n @property\n def n_num_features(self) -> int:\n return 0 if self.X_num is None else self.X_num['train'].shape[1]\n\n @property\n def n_cat_features(self) -> int:\n return 0 if self.X_cat is None else self.X_cat['train'].shape[1]\n\n @property\n def n_features(self) -> int:\n return self.n_num_features + self.n_cat_features\n\n def size(self, part: Optional[str]) -> int:\n return sum(map(len, self.y.values())) if part is None else len(self.y[part])\n\n @property\n def nn_output_dim(self) -> int:\n if self.is_multiclass:\n assert self.n_classes is not None\n return self.n_classes\n else:\n return 1\n\n def get_category_sizes(self, part: str) -> List[int]:\n return [] if self.X_cat is None else get_category_sizes(self.X_cat[part])"},{"identifier":"DataProcessor","path":"data/processor.py","snippet":"class DataProcessor:\n \"\"\"Base class to process a single dataset\"\"\"\n def __init__(\n self, \n normalization: Optional[Normalization] = None,\n num_nan_policy: Optional[NumNanPolicy] = None,\n cat_nan_policy: Optional[CatNanPolicy] = None,\n cat_min_frequency: Optional[float] = None,\n cat_encoding: Optional[CatEncoding] = None,\n y_policy: Optional[YPolicy] = 'default',\n seed: int = 42,\n cache_dir: Optional[str] = None,\n ):\n self.transformation = Transformations(\n seed=seed, \n normalization=normalization, \n num_nan_policy=num_nan_policy,\n cat_nan_policy=cat_nan_policy,\n cat_min_frequency=cat_min_frequency,\n cat_encoding=cat_encoding,\n y_policy=y_policy\n )\n self.cache_dir = cache_dir\n \n def apply(self, dataset: Dataset):\n return transform_dataset(dataset, self.transformation, self.cache_dir)\n \n def save(self, file, **kwargs):\n data_config = {\n 'transformation': vars(self.transformation),\n 'cache_dir': str(self.cache_dir),\n 'meta': kwargs,\n }\n with open(file, 'w') as f:\n yaml.dump(data_config, f, indent=2)\n \n @staticmethod\n def check_splits(dataset: Dataset):\n valid_splits = True\n if 'train' in dataset.y:\n if 'test' not in dataset.y:\n warnings.warn(\"Missing test split, unable to prediction\")\n valid_splits = False\n if 'val' not in dataset.y:\n warnings.warn(\"Missing dev split, unable to early stop, or ignore this message if no early stop needed.\")\n valid_splits = False\n if valid_splits:\n print(\"ready for training!\")\n else:\n raise ValueError(\"Missing training split in the dataset\")\n \n @staticmethod\n def prepare(dataset: Dataset, model: Optional[TabModel] = None, device: str = 'cuda'):\n assert model is not None or device is not None\n def get_spl(X: Optional[Union[ArrayDict, TensorDict]], spl):\n return None if X is None else X[spl]\n if device is not None or isinstance(model.model, nn.Module):\n device = device or model.model.device\n X_num, X_cat, ys = prepare_tensors(dataset, device)\n return {spl: (\n get_spl(X_num, spl), \n get_spl(X_cat, spl), \n get_spl(ys, spl)\n ) for spl in ys}\n else:\n return {spl: (\n get_spl(dataset.X_num, spl), \n get_spl(dataset.X_cat, spl), \n get_spl(dataset.y, spl)\n ) for spl in dataset.y}\n \n @staticmethod\n def load_preproc_default(\n output_dir, # output preprocessing infos\n model_name, \n dataset_name, \n benchmark_name: Optional[str] = None, \n seed: int = 42, \n cache_dir: Optional[str] = None\n ):\n global DATASETS, CUSTOM_DATASETS\n \"\"\"default data preprocessing pipeline\"\"\"\n if dataset_name in DATASETS or dataset_name in CUSTOM_DATASETS:\n data_src = DATASETS if dataset_name in DATASETS else CUSTOM_DATASETS\n data_config = data_src[dataset_name]\n data_path = Path(data_config['path'])\n data_config.setdefault('normalization', 'quantile')\n normalization = data_config['normalization']\n elif benchmark_name is not None:\n assert benchmark_name in BENCHMARKS, f\"Benchmark '{benchmark_name}' is not included, \\\n please choose one of '{list(BENCHMARKS.keys())}', for include your benchmark manually.\"\n benchmark_info = BENCHMARKS[benchmark_name]\n assert dataset_name in benchmark_info['datasets'], f\"dataset '{dataset_name}' not in benchmark '{benchmark_name}'\"\n data_path = Path(benchmark_info['path']) / dataset_name\n normalization = 'quantile'\n else:\n raise ValueError(f\"No dataset '{dataset_name}' is available, \\\n if you want to use a custom dataset (from csv file), using `add_custom_dataset`\")\n \n dataset = Dataset.from_dir(data_path)\n # default preprocess settings\n num_nan_policy = 'mean' if dataset.X_num is not None and \\\n any(np.isnan(dataset.X_num[spl]).any() for spl in dataset.X_num) else None\n cat_nan_policy = None\n if model_name in ['xgboost', 'catboost', 'lightgbm']: # for tree models or other sklearn algorithms\n normalization = None\n cat_min_frequency = None\n cat_encoding = 'one-hot'\n if model_name in ['catboost']:\n cat_encoding = None\n else: # for dnns\n # BUG: (dataset.X_cat[spl] == CAT_MISSING_VALUE).any() has different action\n # dtype: int -> bool, dtype: string -> array[bool], dtype: object -> np.load error\n # CURRENT: uniformly using string type to store catgorical features\n if dataset.X_cat is not None and \\\n any((dataset.X_cat[spl] == CAT_MISSING_VALUE).any() for spl in dataset.X_cat):\n cat_nan_policy = 'most_frequent'\n cat_min_frequency = None\n cat_encoding = None\n cache_dir = cache_dir or data_path\n processor = DataProcessor(\n normalization=normalization,\n num_nan_policy=num_nan_policy,\n cat_nan_policy=cat_nan_policy,\n cat_min_frequency=cat_min_frequency,\n cat_encoding=cat_encoding,\n seed=seed,\n cache_dir=Path(cache_dir),\n )\n dataset = processor.apply(dataset)\n # check train, val, test splits\n DataProcessor.check_splits(dataset)\n # save preprocessing infos\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n processor.save(\n Path(output_dir) / 'data_config.yaml',\n benchmark=str(benchmark_name),\n dataset=dataset_name\n )\n return dataset\n\n @staticmethod\n def split(\n X_num: Optional[np.ndarray] = None, \n X_cat: Optional[np.ndarray] = None, \n ys: np.ndarray = None, \n train_ratio: float = 0.8,\n stratify: bool = True,\n seed: int = 42,\n ):\n assert 0 < train_ratio < 1\n assert ys is not None\n sample_idx = np.arange(len(ys))\n test_ratio = 1 - train_ratio\n _stratify = None if not stratify else ys\n train_idx, test_idx = train_test_split(sample_idx, test_size=test_ratio, random_state=seed, stratify=_stratify)\n _stratify = None if not stratify else ys[train_idx]\n train_idx, val_idx = train_test_split(train_idx, test_size=test_ratio, random_state=seed, stratify=_stratify)\n if X_num is not None:\n X_num = {'train': X_num[train_idx], 'val': X_num[val_idx], 'test': X_num[test_idx]}\n if X_cat is not None:\n X_cat = {'train': X_cat[train_idx], 'val': X_cat[val_idx], 'test': X_cat[test_idx]}\n ys = {'train': ys[train_idx], 'val': ys[val_idx], 'test': ys[test_idx]}\n idx = {'train': train_idx, 'val': val_idx, 'test': test_idx}\n return X_num, X_cat, ys, idx\n \n @staticmethod\n def del_custom_dataset(\n dataset_names: Union[str, List[str]]\n ):\n global DATASETS, CUSTOM_DATASETS\n all_infos = read_custom_infos()\n if isinstance(dataset_names, str):\n dataset_names = [dataset_names]\n for dataset_name in dataset_names:\n if dataset_name not in CUSTOM_DATASETS:\n print(f\"custom dataset: {dataset_name} not exist\")\n continue\n elif dataset_name in DATASETS:\n print(f\"can not delete an in-built dataset: {dataset_name}\")\n continue\n data_info = CUSTOM_DATASETS[dataset_name]\n task = data_info['task_type']\n data_path = data_info['path']\n data_idx = [info['name'] for info in all_infos['data_list']].index(dataset_name)\n all_infos['data_list'].pop(data_idx)\n all_infos['n_datasets'] -= 1\n all_infos[task] -= 1\n shutil.rmtree(data_path)\n print(f\"delete dataset: {dataset_name} successfully\")\n write_custom_infos(all_infos)\n from .env import CUSTOM_DATASETS # BUG: refresh the global variable\n\n @staticmethod\n def add_custom_dataset(\n file: Union[str, Path],\n format: DataFileType = 'csv',\n dataset_name: Optional[str] = None,\n task: Optional[str] = None,\n num_cols: Optional[List[int]] = None,\n cat_cols: Optional[List[int]] = None,\n label_index: int = -1, # label column index\n header: Optional[int] = 0, # header row\n max_cat_num: int = 16,\n train_ratio: float = 0.8, # split train / test, train / val\n seed: float = 42, # random split seed\n ):\n \"\"\"\n Support for adding a custom dataset from a single data file\n ---\n read a raw csv file, process into 3 splits (train, val, test), and add to custom_datasets\n\n TODO: adding a dataset from prepared data split files \n TODO: support no validation split\n \"\"\"\n global DATASETS, CUSTOM_DATASETS\n file_name = Path(file).name\n assert file_name.endswith(format), f'please check if the file \\\n is in {format} format, or add the suffix manually'\n dataset_name = dataset_name or file_name[:-len(format)-1]\n assert dataset_name not in DATASETS, f'same dataset name as an in-built dataset: {dataset_name}'\n assert dataset_name not in CUSTOM_DATASETS, f\"existing custom dataset '{dataset_name}' found\"\n \n if format == 'csv':\n datas: pd.DataFrame = pd.read_csv(file, header=header)\n columns = datas.columns if header is not None else None\n elif format == 'npy':\n header = None # numpy file has no headers\n columns = None\n datas = np.load(file)\n raise NotImplementedError(\"only support load csv file now\")\n else:\n raise ValueError(\"other support format to be add further\")\n \n X_idx = list(range(datas.shape[1]))\n y_idx = X_idx.pop(label_index)\n label_name = columns[y_idx] if columns is not None else None\n # numerical and categorical feature detection\n if num_cols is None or cat_cols is None:\n print('automatically detect column type...')\n print('max category amount: ', max_cat_num)\n num_cols, cat_cols = [], []\n num_names, cat_names = [], []\n for i in X_idx:\n if datas.iloc[:, i].values.dtype == float:\n num_cols.append(i)\n if columns is not None:\n num_names.append(columns[i])\n else: # int or object (str)\n if len(set(datas.iloc[:, i].values)) <= max_cat_num:\n cat_cols.append(i)\n if columns is not None:\n cat_names.append(columns[i])\n elif datas.iloc[:, i].values.dtype == int:\n num_cols.append(i)\n if columns is not None:\n num_names.append(columns[i])\n if not num_names and not cat_names:\n num_names, cat_names = None, None\n elif columns:\n num_names = [columns[i] for i in num_cols]\n cat_names = [columns[i] for i in cat_cols]\n else:\n num_names, cat_names = None, None\n n_num_features = len(num_cols)\n n_cat_features = len(cat_cols)\n # build X_num and X_cat\n X_num, ys = None, datas.iloc[:, y_idx].values\n if len(num_cols) > 0:\n X_num = datas.iloc[:, num_cols].values.astype(np.float32)\n # check data type\n X_cat = []\n for i in cat_cols:\n if datas.iloc[:, i].values.dtype == int:\n x = datas.iloc[:, i].values.astype(np.int64)\n # ordered by value\n # x = OrdinalEncoder(categories=[sorted(list(set(x)))]).fit_transform(x.reshape(-1, 1))\n else: # string object\n x = datas.iloc[:, i].values.astype(object)\n # most_common = [item[0] for item in Counter(x).most_common()]\n # ordered by frequency\n # x = OrdinalEncoder(categories=[most_common]).fit_transform(x.reshape(-1, 1))\n X_cat.append(x.astype(np.str0)) # Encoder Later, compatible with Line 140\n X_cat = np.stack(X_cat, axis=1) if len(X_cat) > 0 else None # if using OrdinalEncoder, np.concatenate\n # detect task type\n def process_non_regression_labels(ys: np.ndarray, task):\n if ys.dtype in [int, float]:\n ys = OrdinalEncoder(categories=[sorted(list(set(ys)))]).fit_transform(ys.reshape(-1, 1))\n else:\n most_common = [item[0] for item in Counter(ys).most_common()]\n ys = OrdinalEncoder(categories=most_common).fit_transform(ys.reshape(-1, 1))\n ys = ys[:, 0]\n return ys.astype(np.float32) if task == 'binclass' else ys.astype(np.int64)\n \n if task is None:\n if ys.dtype in [int, object]:\n task = 'binclass' if len(set(ys)) == 2 else 'multiclass'\n ys = process_non_regression_labels(ys, task)\n elif ys.dtype == float:\n if len(set(ys)) == 2:\n task = 'binclass'\n ys = process_non_regression_labels(ys, task)\n else:\n task = 'regression'\n ys = ys.astype(np.float32)\n else:\n if task == 'regression':\n ys = ys.astype(np.float32)\n else:\n ys = process_non_regression_labels(ys, task)\n\n # split datasets\n stratify = task != 'regression'\n X_num, X_cat, ys, idx = DataProcessor.split(X_num, X_cat, ys, train_ratio, stratify, seed)\n # push to CUSTOM_DATASETS\n data_info = {\n 'name': dataset_name,\n 'id': f'{dataset_name.lower()}--custom',\n 'task_type': task,\n 'label_name': label_name,\n 'n_num_features': n_num_features,\n 'num_feature_names': num_names,\n 'n_cat_features': n_cat_features,\n 'cat_feature_names': cat_names,\n 'test_size': len(ys['test']),\n 'train_size': len(ys['train']),\n 'val_size': len(ys['val'])}\n push_custom_datasets(X_num, X_cat, ys, idx, data_info)\n from .env import CUSTOM_DATASETS # refresh global variable\n print(f'finish, now you can load your dataset with `load_preproc_default({dataset_name})`')"}],"string":"[\n {\n \"identifier\": \"MLP\",\n \"path\": \"models/mlp.py\",\n \"snippet\": \"class MLP(TabModel):\\n def __init__(\\n self,\\n model_config: dict,\\n n_num_features: int,\\n categories: ty.Optional[ty.List[int]],\\n n_labels: int,\\n device: ty.Union[str, torch.device] = 'cuda',\\n ):\\n super().__init__()\\n model_config = self.preproc_config(model_config)\\n self.model = _MLP(\\n d_in=n_num_features,\\n categories=categories,\\n d_out=n_labels,\\n **model_config\\n ).to(device)\\n self.base_name = 'mlp'\\n self.device = torch.device(device)\\n \\n def preproc_config(self, model_config: dict):\\n \\\"\\\"\\\"MLP config preprocessing\\\"\\\"\\\"\\n # process mlp configs\\n self.saved_model_config = model_config.copy()\\n d_layers = []\\n n_layers, first_dim, mid_dim, last_dim = \\\\\\n (\\n model_config.pop('n_layers'), model_config.pop('first_dim'),\\n model_config.pop('mid_dim'), model_config.pop('last_dim')\\n )\\n for i in range(n_layers):\\n if i == 0:\\n d_layers.append(first_dim)\\n elif i == n_layers - 1 and n_layers > 1:\\n d_layers.append(last_dim)\\n else:\\n d_layers.append(mid_dim)\\n model_config['d_layers'] = d_layers\\n return model_config\\n\\n def fit(\\n self,\\n # API for specical sampler like curriculum learning\\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\\n # using normal sampler if is None\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None,\\n y_std: ty.Optional[float] = None, # for RMSE\\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\\n patience: int = 0,\\n task: str = None,\\n training_args: dict = None,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def train_step(model, x_num, x_cat, y): # input is X and y\\n # process input (model-specific)\\n # define your running time calculation\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time # don't forget backward time, calculate in outer loop\\n return logits, used_time\\n \\n # to custom other training paradigm\\n # 1. add self.dnn_fit2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_fit in abstract class\\n self.dnn_fit( # uniform training paradigm\\n dnn_fit_func=train_step,\\n # training data\\n train_loader=train_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\\n # dev data\\n eval_set=eval_set, patience=patience, task=task,\\n # args\\n training_args=training_args,\\n meta_args=meta_args,\\n )\\n \\n def predict(\\n self,\\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None, \\n y_std: ty.Optional[float] = None, # for RMSE\\n task: str = None,\\n return_probs: bool = True,\\n return_metric: bool = False,\\n return_loss: bool = False,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\\n \\\"\\\"\\\"\\n Inference Process\\n `no_grad` will be applied in `dnn_predict'\\n \\\"\\\"\\\"\\n # process input (model-specific)\\n # define your running time calculation\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other inference paradigm\\n # 1. add self.dnn_predict2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_predict in abstract class\\n return self.dnn_predict( # uniform training paradigm\\n dnn_predict_func=inference_step,\\n dev_loader=dev_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\\n meta_args=meta_args\\n )\\n \\n def save(self, output_dir):\\n check_dir(output_dir)\\n self.save_pt_model(output_dir)\\n self.save_history(output_dir)\\n self.save_config(output_dir)\"\n },\n {\n \"identifier\": \"FTTransformer\",\n \"path\": \"models/ft_transformer.py\",\n \"snippet\": \"class FTTransformer(TabModel):\\n def __init__(\\n self,\\n model_config: dict,\\n n_num_features: int,\\n categories: ty.Optional[ty.List[int]],\\n n_labels: int,\\n device: ty.Union[str, torch.device] = 'cuda',\\n ):\\n super().__init__()\\n model_config = self.preproc_config(model_config)\\n self.model = rtdl.FTTransformer.make_baseline(\\n n_num_features=n_num_features,\\n cat_cardinalities=categories,\\n d_out=n_labels,\\n **model_config\\n ).to(device)\\n self.base_name = 'ft-transformer'\\n self.device = torch.device(device)\\n \\n def preproc_config(self, model_config: dict):\\n self.saved_model_config = model_config.copy()\\n # process ftt configs\\n if 'ffn_d_factor' in model_config:\\n model_config['ffn_d_hidden'] = \\\\\\n int(model_config['d_token'] * model_config.pop('ffn_d_factor'))\\n return model_config\\n \\n def fit(\\n self,\\n # API for specical sampler like curriculum learning\\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\\n # using normal sampler if is None\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None,\\n y_std: ty.Optional[float] = None, # for RMSE\\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\\n patience: int = 0,\\n task: str = None,\\n training_args: dict = None,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def train_step(model, x_num, x_cat, y): # input is X and y\\n # process input (model-specific)\\n # define your running time calculation\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time # don't forget backward time, calculate in outer loop\\n return logits, used_time\\n \\n # to custom other training paradigm\\n # 1. add self.dnn_fit2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_fit in abstract class\\n self.dnn_fit( # uniform training paradigm\\n dnn_fit_func=train_step,\\n # training data\\n train_loader=train_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\\n # dev data\\n eval_set=eval_set, patience=patience, task=task,\\n # args\\n training_args=training_args,\\n meta_args=meta_args,\\n )\\n \\n def predict(\\n self,\\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None, \\n y_std: ty.Optional[float] = None, # for RMSE\\n task: str = None,\\n return_probs: bool = True,\\n return_metric: bool = False,\\n return_loss: bool = False,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\\n \\\"\\\"\\\"\\n Inference Process\\n `no_grad` will be applied in `dnn_predict'\\n \\\"\\\"\\\"\\n # process input (model-specific)\\n # define your running time calculation\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other inference paradigm\\n # 1. add self.dnn_predict2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_predict in abstract class\\n return self.dnn_predict( # uniform training paradigm\\n dnn_predict_func=inference_step,\\n dev_loader=dev_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\\n meta_args=meta_args\\n )\\n \\n def save(self, output_dir):\\n check_dir(output_dir)\\n self.save_pt_model(output_dir)\\n self.save_history(output_dir)\\n self.save_config(output_dir)\"\n },\n {\n \"identifier\": \"AutoInt\",\n \"path\": \"models/autoint.py\",\n \"snippet\": \"class AutoInt(TabModel):\\n def __init__(\\n self,\\n model_config: dict,\\n n_num_features: int,\\n categories: ty.Optional[ty.List[int]],\\n n_labels: int,\\n device: ty.Union[str, torch.device] = 'cuda',\\n ):\\n super().__init__()\\n model_config = self.preproc_config(model_config)\\n self.model = _AutoInt(\\n d_numerical=n_num_features,\\n categories=categories,\\n d_out=n_labels,\\n **model_config\\n ).to(device)\\n self.base_name = 'autoint'\\n self.device = torch.device(device)\\n \\n def preproc_config(self, model_config: dict):\\n # process autoint configs\\n self.saved_model_config = model_config.copy()\\n return model_config\\n\\n def fit(\\n self,\\n # API for specical sampler like curriculum learning\\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\\n # using normal sampler if is None\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None,\\n y_std: ty.Optional[float] = None, # for RMSE\\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\\n patience: int = 0,\\n task: str = None,\\n training_args: dict = None,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def train_step(model, x_num, x_cat, y): # input is X and y\\n # process input (model-specific)\\n # define your model API\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other training paradigm\\n # 1. add self.dnn_fit2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_fit in abstract class\\n self.dnn_fit( # uniform training paradigm\\n dnn_fit_func=train_step,\\n # training data\\n train_loader=train_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\\n # dev data\\n eval_set=eval_set, patience=patience, task=task,\\n # args\\n training_args=training_args,\\n meta_args=meta_args,\\n )\\n \\n def predict(\\n self,\\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None, \\n y_std: ty.Optional[float] = None, # for RMSE\\n task: str = None,\\n return_probs: bool = True,\\n return_metric: bool = False,\\n return_loss: bool = False,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\\n \\\"\\\"\\\"\\n Inference Process\\n `no_grad` will be applied in `dnn_predict'\\n \\\"\\\"\\\"\\n # process input (model-specific)\\n # define your model API\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other inference paradigm\\n # 1. add self.dnn_predict2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_predict in abstract class\\n return self.dnn_predict( # uniform training paradigm\\n dnn_predict_func=inference_step,\\n dev_loader=dev_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\\n meta_args=meta_args,\\n )\\n \\n def save(self, output_dir):\\n check_dir(output_dir)\\n self.save_pt_model(output_dir)\\n self.save_history(output_dir)\\n self.save_config(output_dir)\"\n },\n {\n \"identifier\": \"DCNv2\",\n \"path\": \"models/dcnv2.py\",\n \"snippet\": \"class DCNv2(TabModel):\\n def __init__(\\n self,\\n model_config: dict,\\n n_num_features: int,\\n categories: ty.Optional[ty.List[int]],\\n n_labels: int,\\n device: ty.Union[str, torch.device] = 'cuda',\\n ):\\n super().__init__()\\n model_config = self.preproc_config(model_config)\\n self.model = _DCNv2(\\n d_in=n_num_features,\\n categories=categories,\\n d_out=n_labels,\\n **model_config\\n ).to(device)\\n self.base_name = 'dcnv2'\\n self.device = torch.device(device)\\n \\n def preproc_config(self, model_config: dict):\\n # process autoint configs\\n self.saved_model_config = model_config.copy()\\n return model_config\\n\\n def fit(\\n self,\\n # API for specical sampler like curriculum learning\\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\\n # using normal sampler if is None\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None,\\n y_std: ty.Optional[float] = None, # for RMSE\\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\\n patience: int = 0,\\n task: str = None,\\n training_args: dict = None,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def train_step(model, x_num, x_cat, y): # input is X and y\\n # process input (model-specific)\\n # define your model API\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other training paradigm\\n # 1. add self.dnn_fit2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_fit in abstract class\\n self.dnn_fit( # uniform training paradigm\\n dnn_fit_func=train_step,\\n # training data\\n train_loader=train_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\\n # dev data\\n eval_set=eval_set, patience=patience, task=task,\\n # args\\n training_args=training_args,\\n meta_args=meta_args,\\n )\\n \\n def predict(\\n self,\\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None, \\n y_std: ty.Optional[float] = None, # for RMSE\\n task: str = None,\\n return_probs: bool = True,\\n return_metric: bool = False,\\n return_loss: bool = False,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\\n \\\"\\\"\\\"\\n Inference Process\\n `no_grad` will be applied in `dnn_predict'\\n \\\"\\\"\\\"\\n # process input (model-specific)\\n # define your model API\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other inference paradigm\\n # 1. add self.dnn_predict2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_predict in abstract class\\n return self.dnn_predict( # uniform training paradigm\\n dnn_predict_func=inference_step,\\n dev_loader=dev_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\\n meta_args=meta_args\\n )\\n \\n def save(self, output_dir):\\n check_dir(output_dir)\\n self.save_pt_model(output_dir)\\n self.save_history(output_dir)\\n self.save_config(output_dir)\"\n },\n {\n \"identifier\": \"NODE\",\n \"path\": \"models/node_model.py\",\n \"snippet\": \"class NODE(TabModel):\\n def __init__(\\n self,\\n model_config: dict,\\n n_num_features: int,\\n categories: ty.Optional[ty.List[int]],\\n n_labels: int,\\n device: ty.Union[str, torch.device] = 'cuda',\\n ):\\n super().__init__()\\n model_config = self.preproc_config(model_config)\\n self.model = _NODE(\\n d_in=n_num_features,\\n categories=categories,\\n d_out=n_labels,\\n tree_dim=n_labels,\\n **model_config\\n ).to(device)\\n self.base_name = 'node'\\n self.device = torch.device(device)\\n \\n def preproc_config(self, model_config: dict):\\n # process autoint configs\\n self.saved_model_config = model_config.copy()\\n return model_config\\n\\n def fit(\\n self,\\n # API for specical sampler like curriculum learning\\n train_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # (loader, missing_idx)\\n # using normal sampler if is None\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None,\\n y_std: ty.Optional[float] = None, # for RMSE\\n eval_set: ty.Tuple[torch.Tensor, np.ndarray] = None,\\n patience: int = 0,\\n task: str = None,\\n training_args: dict = None,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def train_step(model, x_num, x_cat, y): # input is X and y\\n # process input (model-specific)\\n # define your model API\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other training paradigm\\n # 1. add self.dnn_fit2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_fit in abstract class\\n self.dnn_fit( # uniform training paradigm\\n dnn_fit_func=train_step,\\n # training data\\n train_loader=train_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std,\\n # dev data\\n eval_set=eval_set, patience=patience, task=task,\\n # args\\n training_args=training_args,\\n meta_args=meta_args,\\n )\\n \\n def predict(\\n self,\\n dev_loader: ty.Optional[ty.Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\\n X_num: ty.Optional[torch.Tensor] = None, \\n X_cat: ty.Optional[torch.Tensor] = None, \\n ys: ty.Optional[torch.Tensor] = None, \\n y_std: ty.Optional[float] = None, # for RMSE\\n task: str = None,\\n return_probs: bool = True,\\n return_metric: bool = False,\\n return_loss: bool = False,\\n meta_args: ty.Optional[dict] = None,\\n ):\\n def inference_step(model, x_num, x_cat): # input only X (y inaccessible)\\n \\\"\\\"\\\"\\n Inference Process\\n `no_grad` will be applied in `dnn_predict'\\n \\\"\\\"\\\"\\n # process input (model-specific)\\n # define your running time calculation\\n start_time = time.time()\\n # define your model API\\n logits = model(x_num, x_cat)\\n used_time = time.time() - start_time\\n return logits, used_time\\n \\n # to custom other inference paradigm\\n # 1. add self.dnn_predict2(...) in abstract class for special training process\\n # 2. (recommended) override self.dnn_predict in abstract class\\n return self.dnn_predict( # uniform training paradigm\\n dnn_predict_func=inference_step,\\n dev_loader=dev_loader,\\n X_num=X_num, X_cat=X_cat, ys=ys, y_std=y_std, task=task,\\n return_probs=return_probs, return_metric=return_metric, return_loss=return_loss,\\n meta_args=meta_args\\n )\\n \\n def save(self, output_dir):\\n check_dir(output_dir)\\n self.save_pt_model(output_dir)\\n self.save_history(output_dir)\\n self.save_config(output_dir)\"\n },\n {\n \"identifier\": \"TabModel\",\n \"path\": \"models/abstract.py\",\n \"snippet\": \"class TabModel(ABC):\\n def __init__(self):\\n self.model: Optional[nn.Module] = None # true model\\n self.base_name = None # model type name\\n self.device = None\\n self.saved_model_config = None\\n self.training_config = None\\n self.meta_config = None\\n self.post_init()\\n\\n def post_init(self):\\n self.history = {\\n 'train': {'loss': [], 'tot_time': 0, 'avg_step_time': 0, 'avg_epoch_time': 0}, \\n 'val': {\\n 'metric_name': None, 'metric': [], 'best_metric': None, \\n 'log_loss': [], 'best_log_loss': None,\\n 'best_epoch': None, 'best_step': None,\\n 'tot_time': 0, 'avg_step_time': 0, 'avg_epoch_time': 0\\n }, \\n # 'test': {'loss': [], 'metric': [], 'final_metric': None},\\n 'device': torch.cuda.get_device_name(),\\n } # save metrics\\n self.no_improvement = 0 # for dnn early stop\\n \\n def preproc_config(self, model_config: dict):\\n \\\"\\\"\\\"default preprocessing for model configurations\\\"\\\"\\\"\\n self.saved_model_config = model_config\\n return model_config\\n \\n @abstractmethod\\n def fit(\\n self,\\n X_num: Union[torch.Tensor, np.ndarray], \\n X_cat: Union[torch.Tensor, np.ndarray], \\n ys: Union[torch.Tensor, np.ndarray],\\n y_std: Optional[float],\\n eval_set: Optional[Tuple[Union[torch.Tensor, np.ndarray]]],\\n patience: int,\\n task: str,\\n training_args: dict,\\n meta_args: Optional[dict],\\n ):\\n \\\"\\\"\\\"\\n Training Model with Early Stop(optional)\\n load best weights at the end\\n \\\"\\\"\\\"\\n pass\\n \\n def dnn_fit(\\n self,\\n *,\\n dnn_fit_func: Optional[DNN_FIT_API] = None,\\n # API for specical sampler like curriculum learning\\n train_loader: Optional[Tuple[DataLoader, int]] = None, # (loader, missing_idx)\\n # using normal dataloader sampler if is None\\n X_num: Optional[torch.Tensor] = None, \\n X_cat: Optional[torch.Tensor] = None, \\n ys: Optional[torch.Tensor] = None,\\n y_std: Optional[float] = None, # for RMSE\\n eval_set: Tuple[torch.Tensor, np.ndarray] = None, # similar API as sk-learn\\n patience: int = 0, # <= 0 without early stop\\n task: str,\\n training_args: dict,\\n meta_args: Optional[dict] = None,\\n ):\\n # DONE: move to abstract class (dnn_fit)\\n if dnn_fit_func is None:\\n dnn_fit_func = default_dnn_fit\\n # meta args\\n if meta_args is None:\\n meta_args = {}\\n meta_args.setdefault('save_path', f'results/{self.base_name}')\\n if not os.path.exists(meta_args['save_path']):\\n print('create new results dir: ', meta_args['save_path'])\\n os.makedirs(meta_args['save_path'])\\n self.meta_config = meta_args\\n # optimzier and scheduler\\n training_args.setdefault('optimizer', 'adamw')\\n optimizer, scheduler = TabModel.make_optimizer(self.model, training_args)\\n # data loader\\n training_args.setdefault('batch_size', 64)\\n training_args.setdefault('ghost_batch_size', None)\\n if train_loader is not None:\\n train_loader, missing_idx = train_loader\\n training_args['batch_size'] = train_loader.batch_size\\n else:\\n train_loader, missing_idx = TabModel.prepare_tensor_loader(\\n X_num=X_num, X_cat=X_cat, ys=ys,\\n batch_size=training_args['batch_size'],\\n shuffle=True,\\n )\\n if eval_set is not None:\\n eval_set = eval_set[0] # only use the first dev set\\n dev_loader = TabModel.prepare_tensor_loader(\\n X_num=eval_set[0], X_cat=eval_set[1], ys=eval_set[2],\\n batch_size=training_args['batch_size'],\\n )\\n else:\\n dev_loader = None\\n # training loops\\n training_args.setdefault('max_epochs', 1000)\\n # training_args.setdefault('report_frequency', 100) # same as save_freq\\n # training_args.setdefault('save_frequency', 100) # save per 100 steps\\n training_args.setdefault('patience', patience)\\n training_args.setdefault('save_frequency', 'epoch') # save per epoch\\n self.training_config = training_args\\n\\n steps_per_backward = 1 if training_args['ghost_batch_size'] is None \\\\\\n else training_args['batch_size'] // training_args['ghost_batch_size']\\n steps_per_epoch = len(train_loader)\\n tot_step, tot_time = 0, 0\\n for e in range(training_args['max_epochs']):\\n self.model.train()\\n tot_loss = 0\\n for step, batch in enumerate(train_loader):\\n optimizer.zero_grad()\\n x_num, x_cat, y = TabModel.parse_batch(batch, missing_idx, self.device)\\n logits, forward_time = dnn_fit_func(self.model, x_num, x_cat, y)\\n loss = TabModel.compute_loss(logits, y, task)\\n # backward\\n start_time = time.time()\\n loss.backward()\\n backward_time = time.time() - start_time\\n self.gradient_policy()\\n tot_time += forward_time + backward_time\\n optimizer.step()\\n if scheduler is not None:\\n scheduler.step()\\n # print or save infos\\n tot_step += 1\\n tot_loss += loss.cpu().item()\\n if isinstance(training_args['save_frequency'], int) \\\\\\n and tot_step % training_args['save_frequency'] == 0:\\n is_early_stop = self.save_evaluate_dnn(\\n tot_step, steps_per_epoch, \\n tot_loss, tot_time,\\n task, training_args['patience'], meta_args['save_path'],\\n dev_loader, y_std,\\n )\\n if is_early_stop:\\n self.save(meta_args['save_path'])\\n self.load_best_dnn(meta_args['save_path'])\\n return\\n if training_args['save_frequency'] == 'epoch':\\n if hasattr(self.model, 'layer_masks'):\\n print('layer_mask: ', self.model.layer_masks > 0)\\n is_early_stop = self.save_evaluate_dnn(\\n tot_step, steps_per_epoch, \\n tot_loss, tot_time,\\n task, training_args['patience'], meta_args['save_path'],\\n dev_loader, y_std,\\n )\\n if is_early_stop:\\n self.save(meta_args['save_path'])\\n self.load_best_dnn(meta_args['save_path'])\\n return\\n self.save(meta_args['save_path'])\\n self.load_best_dnn(meta_args['save_path'])\\n \\n @abstractmethod\\n def predict(\\n self,\\n dev_loader: Optional[DataLoader],\\n X_num: Union[torch.Tensor, np.ndarray], \\n X_cat: Union[torch.Tensor, np.ndarray], \\n ys: Union[torch.Tensor, np.ndarray],\\n y_std: Optional[float],\\n task: str,\\n return_probs: bool = True,\\n return_metric: bool = True,\\n return_loss: bool = True,\\n meta_args: Optional[dict] = None,\\n ):\\n \\\"\\\"\\\"\\n Prediction\\n \\\"\\\"\\\"\\n pass\\n \\n def dnn_predict(\\n self,\\n *,\\n dnn_predict_func: Optional[DNN_PREDICT_API] = None,\\n dev_loader: Optional[Tuple[DataLoader, int]] = None, # reuse, (loader, missing_idx)\\n X_num: Optional[torch.Tensor] = None, \\n X_cat: Optional[torch.Tensor] = None, \\n ys: Optional[torch.Tensor] = None, \\n y_std: Optional[float] = None, # for RMSE\\n task: str,\\n return_probs: bool = True,\\n return_metric: bool = False,\\n return_loss: bool = False,\\n meta_args: Optional[dict] = None,\\n ):\\n # DONE: move to abstract class (dnn_predict)\\n if dnn_predict_func is None:\\n dnn_predict_func = default_dnn_predict\\n if dev_loader is None:\\n dev_loader, missing_idx = TabModel.prepare_tensor_loader(\\n X_num=X_num, X_cat=X_cat, ys=ys,\\n batch_size=128,\\n )\\n else:\\n dev_loader, missing_idx = dev_loader\\n # print(\\\"Evaluate...\\\")\\n predictions, golds = [], []\\n tot_time = 0\\n self.model.eval()\\n for batch in dev_loader:\\n x_num, x_cat, y = TabModel.parse_batch(batch, missing_idx, self.device)\\n with torch.no_grad():\\n logits, used_time = dnn_predict_func(self.model, x_num, x_cat)\\n tot_time += used_time\\n predictions.append(logits)\\n golds.append(y)\\n self.model.train()\\n predictions = torch.cat(predictions).squeeze(-1)\\n golds = torch.cat(golds)\\n if return_loss:\\n loss = TabModel.compute_loss(predictions, golds, task).cpu().item()\\n else:\\n loss = None\\n if return_probs and task != 'regression':\\n predictions = (\\n predictions.sigmoid()\\n if task == 'binclass'\\n else predictions.softmax(-1)\\n )\\n prediction_type = 'probs'\\n elif task == 'regression':\\n prediction_type = None\\n else:\\n prediction_type = 'logits'\\n predictions = predictions.cpu().numpy()\\n golds = golds.cpu().numpy()\\n if return_metric:\\n metric = TabModel.calculate_metric(\\n golds, predictions,\\n task, prediction_type, y_std\\n )\\n logloss = (\\n log_loss(golds, np.stack([1-predictions, predictions], axis=1), labels=[0,1])\\n if task == 'binclass'\\n else log_loss(golds, predictions, labels=list(range(len(set(golds)))))\\n if task == 'multiclass'\\n else None\\n )\\n else:\\n metric, logloss = None, None\\n results = {'loss': loss, 'metric': metric, 'time': tot_time, 'log_loss': logloss}\\n if meta_args is not None:\\n self.save_prediction(meta_args['save_path'], results)\\n return predictions, results\\n \\n def gradient_policy(self):\\n \\\"\\\"\\\"For post porcess model gradient\\\"\\\"\\\"\\n pass\\n \\n @abstractmethod\\n def save(self, output_dir):\\n \\\"\\\"\\\"\\n Save model weights and configs,\\n the following default save functions\\n can be combined to override this function\\n \\\"\\\"\\\"\\n pass\\n\\n def save_pt_model(self, output_dir):\\n print('saving pt model weights...')\\n # save model params\\n torch.save(self.model.state_dict(), Path(output_dir) / 'final.bin')\\n \\n def save_tree_model(self, output_dir):\\n print('saving tree model...')\\n pass\\n\\n def save_history(self, output_dir):\\n # save metrics\\n with open(Path(output_dir) / 'results.json', 'w') as f:\\n json.dump(self.history, f, indent=4)\\n \\n def save_prediction(self, output_dir, results, file='prediction'):\\n check_dir(output_dir)\\n # save test results\\n print(\\\"saving prediction results\\\")\\n saved_results = {\\n 'loss': results['loss'], \\n 'metric_name': results['metric'][1], \\n 'metric': results['metric'][0], \\n 'time': results['time'],\\n 'log_loss': results['log_loss'],\\n }\\n with open(Path(output_dir) / f'{file}.json', 'w') as f:\\n json.dump(saved_results, f, indent=4)\\n \\n def save_config(self, output_dir):\\n def serialize(config: dict):\\n for key in config:\\n # serialized object to store yaml or json files \\n if any(isinstance(config[key], obj) for obj in [Path, ]):\\n config[key] = str(config[key])\\n return config\\n # save all configs\\n with open(Path(output_dir) / 'configs.yaml', 'w') as f:\\n configs = {\\n 'model': self.saved_model_config, \\n 'training': self.training_config,\\n 'meta': serialize(self.meta_config)\\n }\\n yaml.dump(configs, f, indent=2)\\n\\n @staticmethod\\n def make_optimizer(\\n model: nn.Module,\\n training_args: dict,\\n ) -> Tuple[optim.Optimizer, optim.lr_scheduler._LRScheduler]:\\n training_args.setdefault('optimizer', 'adamw')\\n training_args.setdefault('no_wd_group', None)\\n training_args.setdefault('scheduler', None)\\n # optimizer\\n if training_args['no_wd_group'] is not None:\\n assert isinstance(training_args['no_wd_group'], list)\\n def needs_wd(name):\\n return all(x not in name for x in training_args['no_wd_group'])\\n parameters_with_wd = [v for k, v in model.named_parameters() if needs_wd(k)]\\n parameters_without_wd = [v for k, v in model.named_parameters() if not needs_wd(k)]\\n model_params = [\\n {'params': parameters_with_wd},\\n {'params': parameters_without_wd, 'weight_decay': 0.0},\\n ]\\n else:\\n model_params = model.parameters()\\n optimizer = make_optimizer(\\n training_args['optimizer'],\\n model_params,\\n training_args['lr'],\\n training_args['weight_decay'],\\n )\\n # scheduler\\n if training_args['scheduler'] is not None:\\n scheduler = None\\n else:\\n scheduler = None\\n\\n return optimizer, scheduler\\n \\n @staticmethod\\n def prepare_tensor_loader(\\n X_num: Optional[torch.Tensor],\\n X_cat: Optional[torch.Tensor],\\n ys: torch.Tensor,\\n batch_size: int = 64,\\n shuffle: bool = False,\\n ):\\n assert not all(x is None for x in [X_num, X_cat])\\n missing_placeholder = 0 if X_num is None else 1 if X_cat is None else -1\\n datas = [x for x in [X_num, X_cat, ys] if x is not None]\\n tensor_dataset = TensorDataset(*datas)\\n tensor_loader = DataLoader(\\n tensor_dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n )\\n return tensor_loader, missing_placeholder\\n \\n @staticmethod\\n def parse_batch(batch: Tuple[torch.Tensor], missing_idx, device: torch.device):\\n if batch[0].device.type != device.type:\\n # if batch[0].device != device: # initialize self.device with model.device rather than torch.device()\\n # batch = (x.to(device) for x in batch) # generator\\n batch = tuple([x.to(device) for x in batch]) # list\\n if missing_idx == -1:\\n return batch\\n else:\\n return batch[:missing_idx] + [None,] + batch[missing_idx:]\\n \\n @staticmethod\\n def compute_loss(logits: torch.Tensor, targets: torch.Tensor, task: str, reduction: str = 'mean'):\\n loss_fn = {\\n 'binclass': F.binary_cross_entropy_with_logits,\\n 'multiclass': F.cross_entropy,\\n 'regression': F.mse_loss,\\n }[task]\\n return loss_fn(logits.squeeze(-1), targets, reduction=reduction)\\n \\n @staticmethod\\n def calculate_metric(\\n golds,\\n predictions,\\n task: str,\\n prediction_type: Optional[str] = None,\\n y_std: Optional[float] = None,\\n ):\\n \\\"\\\"\\\"Calculate metrics\\\"\\\"\\\"\\n metric = {\\n 'regression': 'rmse', \\n 'binclass': 'roc_auc', \\n 'multiclass': 'accuracy'\\n }[task]\\n \\n return calculate_metrics(\\n golds, predictions,\\n task, prediction_type, y_std\\n )[metric], metric\\n \\n def better_result(self, dev_metric, task, is_loss=False):\\n if is_loss: # logloss\\n best_dev_metric = self.history['val']['best_log_loss']\\n if best_dev_metric is None or best_dev_metric > dev_metric:\\n self.history['val']['best_log_loss'] = dev_metric\\n return True\\n else:\\n return False\\n best_dev_metric = self.history['val']['best_metric']\\n if best_dev_metric is None:\\n self.history['val']['best_metric'] = dev_metric\\n return True\\n elif task == 'regression': # rmse\\n if best_dev_metric > dev_metric:\\n self.history['val']['best_metric'] = dev_metric\\n return True\\n else:\\n return False\\n else:\\n if best_dev_metric < dev_metric:\\n self.history['val']['best_metric'] = dev_metric\\n return True\\n else:\\n return False\\n \\n def early_stop_handler(self, epoch, tot_step, dev_metric, task, patience, save_path):\\n if task != 'regression' and self.better_result(dev_metric['log_loss'], task, is_loss=True):\\n # record best logloss\\n torch.save(self.model.state_dict(), Path(save_path) / 'best-logloss.bin')\\n if self.better_result(dev_metric['metric'], task):\\n print('<<< Best Dev Result', end='')\\n torch.save(self.model.state_dict(), Path(save_path) / 'best.bin')\\n self.no_improvement = 0\\n self.history['val']['best_epoch'] = epoch\\n self.history['val']['best_step'] = tot_step\\n else:\\n self.no_improvement += 1\\n print(f'| [no improvement] {self.no_improvement}', end='')\\n if patience <= 0:\\n return False\\n else:\\n return self.no_improvement >= patience\\n \\n def save_evaluate_dnn(\\n self, \\n # print and saved infos\\n tot_step, steps_per_epoch, \\n tot_loss, tot_time,\\n # evaluate infos\\n task, patience, save_path,\\n dev_loader, y_std\\n ):\\n \\\"\\\"\\\"For DNN models\\\"\\\"\\\"\\n epoch, step = tot_step // steps_per_epoch, (tot_step - 1) % steps_per_epoch + 1\\n avg_loss = tot_loss / step\\n self.history['train']['loss'].append(avg_loss)\\n self.history['train']['tot_time'] = tot_time\\n self.history['train']['avg_step_time'] = tot_time / tot_step\\n self.history['train']['avg_epoch_time'] = self.history['train']['avg_step_time'] * steps_per_epoch\\n print(f\\\"[epoch] {epoch} | [step] {step} | [tot_step] {tot_step} | [used time] {tot_time:.4g} | [train_loss] {avg_loss:.4g} \\\", end='')\\n if dev_loader is not None:\\n _, results = self.predict(dev_loader=dev_loader, y_std=y_std, task=task, return_metric=True)\\n dev_metric, metric_name = results['metric']\\n print(f\\\"| [{metric_name}] {dev_metric:.4g} \\\", end='')\\n if task != 'regression':\\n print(f\\\"| [log-loss] {results['log_loss']:.4g} \\\", end='')\\n self.history['val']['log_loss'].append(results['log_loss'])\\n self.history['val']['metric_name'] = metric_name\\n self.history['val']['metric'].append(dev_metric)\\n self.history['val']['tot_time'] += results['time']\\n self.history['val']['avg_step_time'] = self.history['val']['tot_time'] / tot_step\\n self.history['val']['avg_epoch_time'] = self.history['val']['avg_step_time'] * steps_per_epoch\\n dev_metric = {'metric': dev_metric, 'log_loss': results['log_loss']}\\n if self.early_stop_handler(epoch, tot_step, dev_metric, task, patience, save_path):\\n print(' <<< Early Stop')\\n return True\\n print()\\n return False\\n \\n def load_best_dnn(self, save_path, file='best'):\\n model_file = Path(save_path) / f\\\"{file}.bin\\\"\\n if not os.path.exists(model_file):\\n print(f'There is no {file} checkpoint, loading the last one...')\\n model_file = Path(save_path) / 'final.bin'\\n else:\\n print(f'Loading {file} model...')\\n self.model.load_state_dict(torch.load(model_file))\\n print('successfully')\"\n },\n {\n \"identifier\": \"check_dir\",\n \"path\": \"models/abstract.py\",\n \"snippet\": \"def check_dir(dir):\\n if not os.path.exists(dir):\\n os.makedirs(dir)\"\n },\n {\n \"identifier\": \"Dataset\",\n \"path\": \"data/utils.py\",\n \"snippet\": \"class Dataset:\\n X_num: Optional[ArrayDict]\\n X_cat: Optional[ArrayDict]\\n y: ArrayDict\\n y_info: Dict[str, Any]\\n task_type: TaskType\\n n_classes: Optional[int]\\n name: Optional[str]\\n\\n @classmethod\\n def from_dir(cls, dir_: Union[Path, str]) -> 'Dataset':\\n dir_ = Path(dir_)\\n\\n def load(item) -> ArrayDict:\\n def _load(file: Path):\\n return cast(np.ndarray, np.load(file)) if file.exists() else None\\n return {\\n x: _load(dir_ / f'{item}_{x}.npy')\\n for x in ['train', 'val', 'test']\\n }\\n\\n info = load_json(dir_ / 'info.json')\\n\\n return Dataset(\\n load('X_num') if dir_.joinpath('X_num_train.npy').exists() else None,\\n load('X_cat') if dir_.joinpath('X_cat_train.npy').exists() else None,\\n load('y'),\\n {},\\n TaskType(info['task_type']),\\n info.get('n_classes'),\\n info.get('name'),\\n )\\n\\n @property\\n def is_binclass(self) -> bool:\\n return self.task_type == TaskType.BINCLASS\\n\\n @property\\n def is_multiclass(self) -> bool:\\n return self.task_type == TaskType.MULTICLASS\\n\\n @property\\n def is_regression(self) -> bool:\\n return self.task_type == TaskType.REGRESSION\\n\\n @property\\n def n_num_features(self) -> int:\\n return 0 if self.X_num is None else self.X_num['train'].shape[1]\\n\\n @property\\n def n_cat_features(self) -> int:\\n return 0 if self.X_cat is None else self.X_cat['train'].shape[1]\\n\\n @property\\n def n_features(self) -> int:\\n return self.n_num_features + self.n_cat_features\\n\\n def size(self, part: Optional[str]) -> int:\\n return sum(map(len, self.y.values())) if part is None else len(self.y[part])\\n\\n @property\\n def nn_output_dim(self) -> int:\\n if self.is_multiclass:\\n assert self.n_classes is not None\\n return self.n_classes\\n else:\\n return 1\\n\\n def get_category_sizes(self, part: str) -> List[int]:\\n return [] if self.X_cat is None else get_category_sizes(self.X_cat[part])\"\n },\n {\n \"identifier\": \"DataProcessor\",\n \"path\": \"data/processor.py\",\n \"snippet\": \"class DataProcessor:\\n \\\"\\\"\\\"Base class to process a single dataset\\\"\\\"\\\"\\n def __init__(\\n self, \\n normalization: Optional[Normalization] = None,\\n num_nan_policy: Optional[NumNanPolicy] = None,\\n cat_nan_policy: Optional[CatNanPolicy] = None,\\n cat_min_frequency: Optional[float] = None,\\n cat_encoding: Optional[CatEncoding] = None,\\n y_policy: Optional[YPolicy] = 'default',\\n seed: int = 42,\\n cache_dir: Optional[str] = None,\\n ):\\n self.transformation = Transformations(\\n seed=seed, \\n normalization=normalization, \\n num_nan_policy=num_nan_policy,\\n cat_nan_policy=cat_nan_policy,\\n cat_min_frequency=cat_min_frequency,\\n cat_encoding=cat_encoding,\\n y_policy=y_policy\\n )\\n self.cache_dir = cache_dir\\n \\n def apply(self, dataset: Dataset):\\n return transform_dataset(dataset, self.transformation, self.cache_dir)\\n \\n def save(self, file, **kwargs):\\n data_config = {\\n 'transformation': vars(self.transformation),\\n 'cache_dir': str(self.cache_dir),\\n 'meta': kwargs,\\n }\\n with open(file, 'w') as f:\\n yaml.dump(data_config, f, indent=2)\\n \\n @staticmethod\\n def check_splits(dataset: Dataset):\\n valid_splits = True\\n if 'train' in dataset.y:\\n if 'test' not in dataset.y:\\n warnings.warn(\\\"Missing test split, unable to prediction\\\")\\n valid_splits = False\\n if 'val' not in dataset.y:\\n warnings.warn(\\\"Missing dev split, unable to early stop, or ignore this message if no early stop needed.\\\")\\n valid_splits = False\\n if valid_splits:\\n print(\\\"ready for training!\\\")\\n else:\\n raise ValueError(\\\"Missing training split in the dataset\\\")\\n \\n @staticmethod\\n def prepare(dataset: Dataset, model: Optional[TabModel] = None, device: str = 'cuda'):\\n assert model is not None or device is not None\\n def get_spl(X: Optional[Union[ArrayDict, TensorDict]], spl):\\n return None if X is None else X[spl]\\n if device is not None or isinstance(model.model, nn.Module):\\n device = device or model.model.device\\n X_num, X_cat, ys = prepare_tensors(dataset, device)\\n return {spl: (\\n get_spl(X_num, spl), \\n get_spl(X_cat, spl), \\n get_spl(ys, spl)\\n ) for spl in ys}\\n else:\\n return {spl: (\\n get_spl(dataset.X_num, spl), \\n get_spl(dataset.X_cat, spl), \\n get_spl(dataset.y, spl)\\n ) for spl in dataset.y}\\n \\n @staticmethod\\n def load_preproc_default(\\n output_dir, # output preprocessing infos\\n model_name, \\n dataset_name, \\n benchmark_name: Optional[str] = None, \\n seed: int = 42, \\n cache_dir: Optional[str] = None\\n ):\\n global DATASETS, CUSTOM_DATASETS\\n \\\"\\\"\\\"default data preprocessing pipeline\\\"\\\"\\\"\\n if dataset_name in DATASETS or dataset_name in CUSTOM_DATASETS:\\n data_src = DATASETS if dataset_name in DATASETS else CUSTOM_DATASETS\\n data_config = data_src[dataset_name]\\n data_path = Path(data_config['path'])\\n data_config.setdefault('normalization', 'quantile')\\n normalization = data_config['normalization']\\n elif benchmark_name is not None:\\n assert benchmark_name in BENCHMARKS, f\\\"Benchmark '{benchmark_name}' is not included, \\\\\\n please choose one of '{list(BENCHMARKS.keys())}', for include your benchmark manually.\\\"\\n benchmark_info = BENCHMARKS[benchmark_name]\\n assert dataset_name in benchmark_info['datasets'], f\\\"dataset '{dataset_name}' not in benchmark '{benchmark_name}'\\\"\\n data_path = Path(benchmark_info['path']) / dataset_name\\n normalization = 'quantile'\\n else:\\n raise ValueError(f\\\"No dataset '{dataset_name}' is available, \\\\\\n if you want to use a custom dataset (from csv file), using `add_custom_dataset`\\\")\\n \\n dataset = Dataset.from_dir(data_path)\\n # default preprocess settings\\n num_nan_policy = 'mean' if dataset.X_num is not None and \\\\\\n any(np.isnan(dataset.X_num[spl]).any() for spl in dataset.X_num) else None\\n cat_nan_policy = None\\n if model_name in ['xgboost', 'catboost', 'lightgbm']: # for tree models or other sklearn algorithms\\n normalization = None\\n cat_min_frequency = None\\n cat_encoding = 'one-hot'\\n if model_name in ['catboost']:\\n cat_encoding = None\\n else: # for dnns\\n # BUG: (dataset.X_cat[spl] == CAT_MISSING_VALUE).any() has different action\\n # dtype: int -> bool, dtype: string -> array[bool], dtype: object -> np.load error\\n # CURRENT: uniformly using string type to store catgorical features\\n if dataset.X_cat is not None and \\\\\\n any((dataset.X_cat[spl] == CAT_MISSING_VALUE).any() for spl in dataset.X_cat):\\n cat_nan_policy = 'most_frequent'\\n cat_min_frequency = None\\n cat_encoding = None\\n cache_dir = cache_dir or data_path\\n processor = DataProcessor(\\n normalization=normalization,\\n num_nan_policy=num_nan_policy,\\n cat_nan_policy=cat_nan_policy,\\n cat_min_frequency=cat_min_frequency,\\n cat_encoding=cat_encoding,\\n seed=seed,\\n cache_dir=Path(cache_dir),\\n )\\n dataset = processor.apply(dataset)\\n # check train, val, test splits\\n DataProcessor.check_splits(dataset)\\n # save preprocessing infos\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n processor.save(\\n Path(output_dir) / 'data_config.yaml',\\n benchmark=str(benchmark_name),\\n dataset=dataset_name\\n )\\n return dataset\\n\\n @staticmethod\\n def split(\\n X_num: Optional[np.ndarray] = None, \\n X_cat: Optional[np.ndarray] = None, \\n ys: np.ndarray = None, \\n train_ratio: float = 0.8,\\n stratify: bool = True,\\n seed: int = 42,\\n ):\\n assert 0 < train_ratio < 1\\n assert ys is not None\\n sample_idx = np.arange(len(ys))\\n test_ratio = 1 - train_ratio\\n _stratify = None if not stratify else ys\\n train_idx, test_idx = train_test_split(sample_idx, test_size=test_ratio, random_state=seed, stratify=_stratify)\\n _stratify = None if not stratify else ys[train_idx]\\n train_idx, val_idx = train_test_split(train_idx, test_size=test_ratio, random_state=seed, stratify=_stratify)\\n if X_num is not None:\\n X_num = {'train': X_num[train_idx], 'val': X_num[val_idx], 'test': X_num[test_idx]}\\n if X_cat is not None:\\n X_cat = {'train': X_cat[train_idx], 'val': X_cat[val_idx], 'test': X_cat[test_idx]}\\n ys = {'train': ys[train_idx], 'val': ys[val_idx], 'test': ys[test_idx]}\\n idx = {'train': train_idx, 'val': val_idx, 'test': test_idx}\\n return X_num, X_cat, ys, idx\\n \\n @staticmethod\\n def del_custom_dataset(\\n dataset_names: Union[str, List[str]]\\n ):\\n global DATASETS, CUSTOM_DATASETS\\n all_infos = read_custom_infos()\\n if isinstance(dataset_names, str):\\n dataset_names = [dataset_names]\\n for dataset_name in dataset_names:\\n if dataset_name not in CUSTOM_DATASETS:\\n print(f\\\"custom dataset: {dataset_name} not exist\\\")\\n continue\\n elif dataset_name in DATASETS:\\n print(f\\\"can not delete an in-built dataset: {dataset_name}\\\")\\n continue\\n data_info = CUSTOM_DATASETS[dataset_name]\\n task = data_info['task_type']\\n data_path = data_info['path']\\n data_idx = [info['name'] for info in all_infos['data_list']].index(dataset_name)\\n all_infos['data_list'].pop(data_idx)\\n all_infos['n_datasets'] -= 1\\n all_infos[task] -= 1\\n shutil.rmtree(data_path)\\n print(f\\\"delete dataset: {dataset_name} successfully\\\")\\n write_custom_infos(all_infos)\\n from .env import CUSTOM_DATASETS # BUG: refresh the global variable\\n\\n @staticmethod\\n def add_custom_dataset(\\n file: Union[str, Path],\\n format: DataFileType = 'csv',\\n dataset_name: Optional[str] = None,\\n task: Optional[str] = None,\\n num_cols: Optional[List[int]] = None,\\n cat_cols: Optional[List[int]] = None,\\n label_index: int = -1, # label column index\\n header: Optional[int] = 0, # header row\\n max_cat_num: int = 16,\\n train_ratio: float = 0.8, # split train / test, train / val\\n seed: float = 42, # random split seed\\n ):\\n \\\"\\\"\\\"\\n Support for adding a custom dataset from a single data file\\n ---\\n read a raw csv file, process into 3 splits (train, val, test), and add to custom_datasets\\n\\n TODO: adding a dataset from prepared data split files \\n TODO: support no validation split\\n \\\"\\\"\\\"\\n global DATASETS, CUSTOM_DATASETS\\n file_name = Path(file).name\\n assert file_name.endswith(format), f'please check if the file \\\\\\n is in {format} format, or add the suffix manually'\\n dataset_name = dataset_name or file_name[:-len(format)-1]\\n assert dataset_name not in DATASETS, f'same dataset name as an in-built dataset: {dataset_name}'\\n assert dataset_name not in CUSTOM_DATASETS, f\\\"existing custom dataset '{dataset_name}' found\\\"\\n \\n if format == 'csv':\\n datas: pd.DataFrame = pd.read_csv(file, header=header)\\n columns = datas.columns if header is not None else None\\n elif format == 'npy':\\n header = None # numpy file has no headers\\n columns = None\\n datas = np.load(file)\\n raise NotImplementedError(\\\"only support load csv file now\\\")\\n else:\\n raise ValueError(\\\"other support format to be add further\\\")\\n \\n X_idx = list(range(datas.shape[1]))\\n y_idx = X_idx.pop(label_index)\\n label_name = columns[y_idx] if columns is not None else None\\n # numerical and categorical feature detection\\n if num_cols is None or cat_cols is None:\\n print('automatically detect column type...')\\n print('max category amount: ', max_cat_num)\\n num_cols, cat_cols = [], []\\n num_names, cat_names = [], []\\n for i in X_idx:\\n if datas.iloc[:, i].values.dtype == float:\\n num_cols.append(i)\\n if columns is not None:\\n num_names.append(columns[i])\\n else: # int or object (str)\\n if len(set(datas.iloc[:, i].values)) <= max_cat_num:\\n cat_cols.append(i)\\n if columns is not None:\\n cat_names.append(columns[i])\\n elif datas.iloc[:, i].values.dtype == int:\\n num_cols.append(i)\\n if columns is not None:\\n num_names.append(columns[i])\\n if not num_names and not cat_names:\\n num_names, cat_names = None, None\\n elif columns:\\n num_names = [columns[i] for i in num_cols]\\n cat_names = [columns[i] for i in cat_cols]\\n else:\\n num_names, cat_names = None, None\\n n_num_features = len(num_cols)\\n n_cat_features = len(cat_cols)\\n # build X_num and X_cat\\n X_num, ys = None, datas.iloc[:, y_idx].values\\n if len(num_cols) > 0:\\n X_num = datas.iloc[:, num_cols].values.astype(np.float32)\\n # check data type\\n X_cat = []\\n for i in cat_cols:\\n if datas.iloc[:, i].values.dtype == int:\\n x = datas.iloc[:, i].values.astype(np.int64)\\n # ordered by value\\n # x = OrdinalEncoder(categories=[sorted(list(set(x)))]).fit_transform(x.reshape(-1, 1))\\n else: # string object\\n x = datas.iloc[:, i].values.astype(object)\\n # most_common = [item[0] for item in Counter(x).most_common()]\\n # ordered by frequency\\n # x = OrdinalEncoder(categories=[most_common]).fit_transform(x.reshape(-1, 1))\\n X_cat.append(x.astype(np.str0)) # Encoder Later, compatible with Line 140\\n X_cat = np.stack(X_cat, axis=1) if len(X_cat) > 0 else None # if using OrdinalEncoder, np.concatenate\\n # detect task type\\n def process_non_regression_labels(ys: np.ndarray, task):\\n if ys.dtype in [int, float]:\\n ys = OrdinalEncoder(categories=[sorted(list(set(ys)))]).fit_transform(ys.reshape(-1, 1))\\n else:\\n most_common = [item[0] for item in Counter(ys).most_common()]\\n ys = OrdinalEncoder(categories=most_common).fit_transform(ys.reshape(-1, 1))\\n ys = ys[:, 0]\\n return ys.astype(np.float32) if task == 'binclass' else ys.astype(np.int64)\\n \\n if task is None:\\n if ys.dtype in [int, object]:\\n task = 'binclass' if len(set(ys)) == 2 else 'multiclass'\\n ys = process_non_regression_labels(ys, task)\\n elif ys.dtype == float:\\n if len(set(ys)) == 2:\\n task = 'binclass'\\n ys = process_non_regression_labels(ys, task)\\n else:\\n task = 'regression'\\n ys = ys.astype(np.float32)\\n else:\\n if task == 'regression':\\n ys = ys.astype(np.float32)\\n else:\\n ys = process_non_regression_labels(ys, task)\\n\\n # split datasets\\n stratify = task != 'regression'\\n X_num, X_cat, ys, idx = DataProcessor.split(X_num, X_cat, ys, train_ratio, stratify, seed)\\n # push to CUSTOM_DATASETS\\n data_info = {\\n 'name': dataset_name,\\n 'id': f'{dataset_name.lower()}--custom',\\n 'task_type': task,\\n 'label_name': label_name,\\n 'n_num_features': n_num_features,\\n 'num_feature_names': num_names,\\n 'n_cat_features': n_cat_features,\\n 'cat_feature_names': cat_names,\\n 'test_size': len(ys['test']),\\n 'train_size': len(ys['train']),\\n 'val_size': len(ys['val'])}\\n push_custom_datasets(X_num, X_cat, ys, idx, data_info)\\n from .env import CUSTOM_DATASETS # refresh global variable\\n print(f'finish, now you can load your dataset with `load_preproc_default({dataset_name})`')\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import os\nimport time\nimport json\nimport yaml\nimport shutil\nimport random\nimport datetime\nimport numpy as np\nimport torch\nimport optuna\nfrom pathlib import Path\nfrom typing import Dict, List, Tuple, Union, Optional, Literal\nfrom models import MLP, FTTransformer, AutoInt, DCNv2, NODE\nfrom models.abstract import TabModel, check_dir\nfrom data.utils import Dataset\nfrom data.processor import DataProcessor"},"token_num":{"kind":"number","value":15711,"string":"15,711"},"cropped_code":{"kind":"string","value":"\n\n\n\n\nMODEL_CARDS = {\n 'xgboost': None, 'catboost': None, 'lightgbm': None,\n 'mlp': MLP, 'autoint': AutoInt, 'dcnv2': DCNv2, 'node': NODE,\n 'ft-transformer': FTTransformer, 'saint': None, \n 't2g-former': None, 'excel-former': None,\n}\nHPOLib = Literal['optuna', 'hyperopt'] # TODO: add 'hyperopt' support\n\ndef get_model_cards():\n return {\n 'ready': sorted(list([key for key, value in MODEL_CARDS.items() if value])),\n 'comming soon': sorted(list([key for key, value in MODEL_CARDS.items() if not value]))\n }\n\ndef seed_everything(seed=42):\n '''\n Sets the seed of the entire notebook so results are the same every time we run.\n This is for REPRODUCIBILITY.\n '''\n random.seed(seed)\n # Set a fixed value for the hash seed\n os.environ['PYTHONHASHSEED'] = str(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n \n if torch.cuda.is_available():\n torch.cuda.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n # When running on the CuDNN backend, two further options must be set\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\ndef load_config_from_file(file):\n file = str(file)\n if file.endswith('.yaml'):\n with open(file, 'r') as f:\n cfg = yaml.safe_load(f)\n elif file.endswith('.json'):\n with open(file, 'r') as f:\n cfg = json.load(f)\n else:\n raise AssertionError('Config files only support yaml or json format now.')\n return cfg\n\ndef extract_config(model_config: dict, is_large_data: bool = False):\n \"\"\"selection of different search spaces\"\"\"\n used_cfgs = {\"model\": {}, \"training\": {}, 'meta': model_config.get('meta', {})}\n for field in ['model', 'training']:\n for k in model_config[field]:\n cfgs = model_config[field][k]\n if 'type2' not in cfgs:\n used_cfg = cfgs\n else:\n if not is_large_data:\n used_cfg = {k: v for k, v in cfgs.items() if not k.endswith('2')}\n else:\n used_cfg = {k[:-1]: v for k, v in cfgs.items() if k.endswith('2')}\n used_cfgs[field][k] = used_cfg\n return used_cfgs\n\ndef make_baseline(\n model_name, \n model_config: Union[dict, str], \n n_num: int, \n cat_card: Optional[List[int]],\n n_labels: int,\n sparsity_scheme: Optional[str] = None,\n device: Union[str, torch.device] = 'cuda',\n) -> TabModel:\n \"\"\"Process Model Configs and Call Specific Model APIs\"\"\"\n assert model_name in MODEL_CARDS, f\"unrecognized `{model_name}` model name, choose one of valid models in {MODEL_CARDS}\"\n if isinstance(model_config, str):\n model_config = load_config_from_file(model_config)['model']\n if MODEL_CARDS[model_name] is None:\n raise NotImplementedError(\"Please add corresponding model implementation to `models` module\")\n if sparsity_scheme is not None:\n assert 'mlp' in model_name\n return MODEL_CARDS[model_name](\n model_config=model_config, \n n_num_features=n_num, categories=cat_card, n_labels=n_labels, \n sparsity_scheme=sparsity_scheme)\n return MODEL_CARDS[model_name](\n model_config=model_config, \n n_num_features=n_num, categories=cat_card, n_labels=n_labels)\n\ndef tune(\n model_name: str = None,\n search_config: Union[dict, str] = None, \n"},"all_code":{"kind":"string","value":"\n\n\n\n\nMODEL_CARDS = {\n 'xgboost': None, 'catboost': None, 'lightgbm': None,\n 'mlp': MLP, 'autoint': AutoInt, 'dcnv2': DCNv2, 'node': NODE,\n 'ft-transformer': FTTransformer, 'saint': None, \n 't2g-former': None, 'excel-former': None,\n}\nHPOLib = Literal['optuna', 'hyperopt'] # TODO: add 'hyperopt' support\n\ndef get_model_cards():\n return {\n 'ready': sorted(list([key for key, value in MODEL_CARDS.items() if value])),\n 'comming soon': sorted(list([key for key, value in MODEL_CARDS.items() if not value]))\n }\n\ndef seed_everything(seed=42):\n '''\n Sets the seed of the entire notebook so results are the same every time we run.\n This is for REPRODUCIBILITY.\n '''\n random.seed(seed)\n # Set a fixed value for the hash seed\n os.environ['PYTHONHASHSEED'] = str(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n \n if torch.cuda.is_available():\n torch.cuda.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n # When running on the CuDNN backend, two further options must be set\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\ndef load_config_from_file(file):\n file = str(file)\n if file.endswith('.yaml'):\n with open(file, 'r') as f:\n cfg = yaml.safe_load(f)\n elif file.endswith('.json'):\n with open(file, 'r') as f:\n cfg = json.load(f)\n else:\n raise AssertionError('Config files only support yaml or json format now.')\n return cfg\n\ndef extract_config(model_config: dict, is_large_data: bool = False):\n \"\"\"selection of different search spaces\"\"\"\n used_cfgs = {\"model\": {}, \"training\": {}, 'meta': model_config.get('meta', {})}\n for field in ['model', 'training']:\n for k in model_config[field]:\n cfgs = model_config[field][k]\n if 'type2' not in cfgs:\n used_cfg = cfgs\n else:\n if not is_large_data:\n used_cfg = {k: v for k, v in cfgs.items() if not k.endswith('2')}\n else:\n used_cfg = {k[:-1]: v for k, v in cfgs.items() if k.endswith('2')}\n used_cfgs[field][k] = used_cfg\n return used_cfgs\n\ndef make_baseline(\n model_name, \n model_config: Union[dict, str], \n n_num: int, \n cat_card: Optional[List[int]],\n n_labels: int,\n sparsity_scheme: Optional[str] = None,\n device: Union[str, torch.device] = 'cuda',\n) -> TabModel:\n \"\"\"Process Model Configs and Call Specific Model APIs\"\"\"\n assert model_name in MODEL_CARDS, f\"unrecognized `{model_name}` model name, choose one of valid models in {MODEL_CARDS}\"\n if isinstance(model_config, str):\n model_config = load_config_from_file(model_config)['model']\n if MODEL_CARDS[model_name] is None:\n raise NotImplementedError(\"Please add corresponding model implementation to `models` module\")\n if sparsity_scheme is not None:\n assert 'mlp' in model_name\n return MODEL_CARDS[model_name](\n model_config=model_config, \n n_num_features=n_num, categories=cat_card, n_labels=n_labels, \n sparsity_scheme=sparsity_scheme)\n return MODEL_CARDS[model_name](\n model_config=model_config, \n n_num_features=n_num, categories=cat_card, n_labels=n_labels)\n\ndef tune(\n model_name: str = None,\n search_config: Union[dict, str] = None, "},"next_line":{"kind":"string","value":" dataset: Dataset = None,"},"gold_snippet_index":{"kind":"number","value":7,"string":"7"},"created_at":{"kind":"string","value":"2023-10-30 14:55:44+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5694,"cells":{"repo_name":{"kind":"string","value":"hyperspy/exspy"},"file_path":{"kind":"string","value":"exspy/tests/models/test_eelsmodel.py"},"context":{"kind":"list like","value":[{"identifier":"elements_db","path":"exspy/misc/elements.py","snippet":""},{"identifier":"_GOSH_URL","path":"exspy/misc/eels/gosh_gos.py","snippet":"_GOSH_URL = f\"doi:{_GOSH_DOI}/Segger_Guzzinati_Kohl_1.5.0.gosh\""},{"identifier":"_GOSH_KNOWN_HASH","path":"exspy/misc/eels/gosh_gos.py","snippet":"_GOSH_KNOWN_HASH = \"md5:7fee8891c147a4f769668403b54c529b\""},{"identifier":"EELSSpectrum","path":"exspy/signals/eels.py","snippet":"class EELSSpectrum(Signal1D):\n\n \"\"\"Signal class for EELS spectra.\"\"\"\n\n _signal_type = \"EELS\"\n _alias_signal_types = [\"TEM EELS\"]\n\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n # Attributes defaults\n self.subshells = set()\n self.elements = set()\n self.edges = list()\n if hasattr(self.metadata, \"Sample\") and hasattr(\n self.metadata.Sample, \"elements\"\n ):\n self.add_elements(self.metadata.Sample.elements)\n self.axes_manager.signal_axes[0].is_binned = True\n self._edge_markers = {\"names\": [], \"lines\": None, \"texts\": None}\n\n def add_elements(self, elements, include_pre_edges=False):\n \"\"\"Declare the elemental composition of the sample.\n\n The ionisation edges of the elements present in the current\n energy range will be added automatically.\n\n Parameters\n ----------\n elements : tuple of strings\n The symbol of the elements. Note this input must always be\n in the form of a tuple. Meaning: add_elements(('C',)) will\n work, while add_elements(('C')) will NOT work.\n include_pre_edges : bool\n If True, the ionization edges with an onset below the lower\n energy limit of the SI will be included\n\n Examples\n --------\n\n >>> s = hs.signals.EELSSpectrum(np.arange(1024))\n >>> s.add_elements(('C', 'O'))\n\n Raises\n ------\n ValueError\n\n \"\"\"\n if not isiterable(elements) or isinstance(elements, str):\n raise ValueError(\n \"Input must be in the form of a tuple. For example, \"\n \"if `s` is the variable containing this EELS spectrum:\\n \"\n \">>> s.add_elements(('C',))\\n\"\n \"See the docstring for more information.\"\n )\n\n for element in elements:\n if isinstance(element, bytes):\n element = element.decode()\n if element in elements_db:\n self.elements.add(element)\n else:\n raise ValueError(\n \"%s is not a valid symbol of a chemical element\" % element\n )\n if not hasattr(self.metadata, \"Sample\"):\n self.metadata.add_node(\"Sample\")\n self.metadata.Sample.elements = list(self.elements)\n if self.elements:\n self.generate_subshells(include_pre_edges)\n\n def generate_subshells(self, include_pre_edges=False):\n \"\"\"Calculate the subshells for the current energy range for the\n elements present in self.elements\n\n Parameters\n ----------\n include_pre_edges : bool\n If True, the ionization edges with an onset below the lower\n energy limit of the SI will be included\n\n \"\"\"\n Eaxis = self.axes_manager.signal_axes[0].axis\n if not include_pre_edges:\n start_energy = Eaxis[0]\n else:\n start_energy = 0.0\n end_energy = Eaxis[-1]\n for element in self.elements:\n e_shells = list()\n for shell in elements_db[element][\"Atomic_properties\"][\"Binding_energies\"]:\n if shell[-1] != \"a\":\n energy = elements_db[element][\"Atomic_properties\"][\n \"Binding_energies\"\n ][shell][\"onset_energy (eV)\"]\n if start_energy <= energy <= end_energy:\n subshell = \"%s_%s\" % (element, shell)\n if subshell not in self.subshells:\n self.subshells.add(\"%s_%s\" % (element, shell))\n e_shells.append(subshell)\n\n def edges_at_energy(\n self,\n energy=\"interactive\",\n width=10,\n only_major=False,\n order=\"closest\",\n display=True,\n toolkit=None,\n ):\n \"\"\"Show EELS edges according to an energy range selected from the\n spectrum or within a provided energy window\n\n Parameters\n ----------\n energy : 'interactive' or float\n If it is 'interactive', a table with edges are shown and it depends\n on the energy range selected in the spectrum. If it is a float, a\n table with edges are shown and it depends on the energy window\n defined by energy +/- (width/2). The default is 'interactive'.\n width : float\n Width of window, in eV, around energy in which to find nearby\n energies, i.e. a value of 10 eV (the default) means to\n search +/- 5 eV. The default is 10.\n only_major : bool\n Whether to show only the major edges. The default is False.\n order : str\n Sort the edges, if 'closest', return in the order of energy\n difference, if 'ascending', return in ascending order, similarly\n for 'descending'. The default is 'closest'.\n\n Returns\n -------\n An interactive widget if energy is 'interactive', or a html-format\n table or ASCII table, depends on the environment.\n \"\"\"\n\n if energy == \"interactive\":\n er = EdgesRange(self, interactive=True)\n return er.gui(display=display, toolkit=toolkit)\n else:\n self.print_edges_near_energy(energy, width, only_major, order)\n\n @staticmethod\n def print_edges_near_energy(\n energy=None, width=10, only_major=False, order=\"closest\", edges=None\n ):\n \"\"\"Find and print a table of edges near a given energy that are within\n the given energy window.\n\n Parameters\n ----------\n energy : float\n Energy to search, in eV\n width : float\n Width of window, in eV, around energy in which to find nearby\n energies, i.e. a value of 10 eV (the default) means to\n search +/- 5 eV. The default is 10.\n only_major : bool\n Whether to show only the major edges. The default is False.\n order : str\n Sort the edges, if 'closest', return in the order of energy\n difference, if 'ascending', return in ascending order, similarly\n for 'descending'. The default is 'closest'.\n edges : iterable\n A sequence of edges, if provided, it overrides energy, width,\n only_major and order.\n\n Returns\n -------\n A PrettyText object where its representation is ASCII in terminal and\n html-formatted in Jupyter notebook\n \"\"\"\n\n if edges is None and energy is not None:\n edges = get_edges_near_energy(\n energy=energy, width=width, only_major=only_major, order=order\n )\n elif edges is None and energy is None:\n raise ValueError(\"Either energy or edges should be provided.\")\n\n table = PrettyTable()\n table.field_names = [\"edge\", \"onset energy (eV)\", \"relevance\", \"description\"]\n\n for edge in edges:\n element, shell = edge.split(\"_\")\n shell_dict = elements_db[element][\"Atomic_properties\"][\"Binding_energies\"][\n shell\n ]\n\n onset = shell_dict[\"onset_energy (eV)\"]\n relevance = shell_dict[\"relevance\"]\n threshold = shell_dict[\"threshold\"]\n edge_ = shell_dict[\"edge\"]\n description = threshold + \". \" * (threshold != \"\" and edge_ != \"\") + edge_\n\n table.add_row([edge, onset, relevance, description])\n\n # this ensures the html version try its best to mimick the ASCII one\n table.format = True\n\n display(table)\n\n def estimate_zero_loss_peak_centre(self, mask=None):\n \"\"\"Estimate the position of the zero-loss peak.\n\n This function provides just a coarse estimation of the position\n of the zero-loss peak centre by computing the position of the maximum\n of the spectra. For subpixel accuracy use `estimate_shift1D`.\n\n Parameters\n ----------\n mask : Signal1D of bool data type or bool array\n It must have signal_dimension = 0 and navigation_shape equal to the\n navigation shape of the current signal. Where mask is True the\n shift is not computed and set to nan.\n\n Returns\n -------\n zlpc : Signal1D subclass\n The estimated position of the maximum of the ZLP peak.\n\n Notes\n -----\n This function only works when the zero-loss peak is the most\n intense feature in the spectrum. If it is not in most cases\n the spectrum can be cropped to meet this criterion.\n Alternatively use `estimate_shift1D`.\n\n See Also\n --------\n estimate_shift1D, align_zero_loss_peak\n\n \"\"\"\n self._check_signal_dimension_equals_one()\n self._check_navigation_mask(mask)\n if isinstance(mask, BaseSignal):\n mask = mask.data\n zlpc = self.valuemax(-1)\n if mask is not None:\n zlpc.data = np.where(mask, np.nan, zlpc.data)\n zlpc.set_signal_type(\"\")\n title = self.metadata.General.title\n zlpc.metadata.General.title = \"ZLP(%s)\" % title\n return zlpc\n\n def align_zero_loss_peak(\n self,\n calibrate=True,\n also_align=[],\n print_stats=True,\n subpixel=True,\n mask=None,\n signal_range=None,\n show_progressbar=None,\n crop=True,\n **kwargs,\n ):\n \"\"\"Align the zero-loss peak.\n\n This function first aligns the spectra using the result of\n `estimate_zero_loss_peak_centre` which finds the maximum in the\n given energy range, then if subpixel is True,\n proceeds to align with subpixel accuracy using `align1D`. The offset\n is automatically correct if `calibrate` is True.\n\n Parameters\n ----------\n calibrate : bool\n If True, set the offset of the spectral axis so that the\n zero-loss peak is at position zero.\n also_align : list of signals\n A list containing other spectra of identical dimensions to\n align using the shifts applied to the current spectrum.\n If `calibrate` is True, the calibration is also applied to\n the spectra in the list.\n print_stats : bool\n If True, print summary statistics of the ZLP maximum before\n the alignment.\n subpixel : bool\n If True, perform the alignment with subpixel accuracy\n using cross-correlation.\n mask : Signal1D of bool data type or bool array.\n It must have signal_dimension = 0 and navigation_shape equal to\n the shape of the current signal. Where mask is True the shift is\n not computed and set to nan.\n signal_range : tuple of integers, tuple of floats. Optional\n Will only search for the ZLP within the signal_range. If given\n in integers, the range will be in index values. If given floats,\n the range will be in spectrum values. Useful if there are features\n in the spectrum which are more intense than the ZLP.\n Default is searching in the whole signal. Note that ROIs can be used\n in place of a tuple.\n %s\n %s\n\n Raises\n ------\n NotImplementedError\n If the signal axis is a non-uniform axis.\n\n Examples\n --------\n >>> s_ll = hs.signals.EELSSpectrum(np.zeros(1000))\n >>> s_ll.data[100] = 100\n >>> s_ll.align_zero_loss_peak()\n\n Aligning both the lowloss signal and another signal\n\n >>> s = hs.signals.EELSSpectrum(np.range(1000))\n >>> s_ll.align_zero_loss_peak(also_align=[s])\n\n Aligning within a narrow range of the lowloss signal\n\n >>> s_ll.align_zero_loss_peak(signal_range=(-10.,10.))\n\n\n See Also\n --------\n estimate_zero_loss_peak_centre, align1D, estimate_shift1D.\n\n Notes\n -----\n Any extra keyword arguments are passed to `align1D`. For\n more information read its docstring.\n\n \"\"\"\n\n def substract_from_offset(value, signals):\n # Test that axes is uniform\n if not self.axes_manager[-1].is_uniform:\n raise NotImplementedError(\n \"Support for EELS signals with \"\n \"non-uniform signal axes is not yet implemented.\"\n )\n if isinstance(value, da.Array):\n value = value.compute()\n for signal in signals:\n signal.axes_manager[-1].offset -= value\n signal.events.data_changed.trigger(signal)\n\n def estimate_zero_loss_peak_centre(s, mask, signal_range):\n if signal_range:\n zlpc = s.isig[\n signal_range[0] : signal_range[1]\n ].estimate_zero_loss_peak_centre(mask=mask)\n else:\n zlpc = s.estimate_zero_loss_peak_centre(mask=mask)\n return zlpc\n\n zlpc = estimate_zero_loss_peak_centre(\n self, mask=mask, signal_range=signal_range\n )\n\n mean_ = np.nanmean(zlpc.data)\n\n if print_stats is True:\n print(underline(\"Initial ZLP position statistics\"))\n zlpc.print_summary_statistics()\n\n for signal in also_align + [self]:\n shift_array = -zlpc.data + mean_\n if zlpc._lazy:\n # We must compute right now because otherwise any changes to the\n # axes_manager of the signal later in the workflow may result in\n # a wrong shift_array\n shift_array = shift_array.compute()\n signal.shift1D(shift_array, crop=crop, show_progressbar=show_progressbar)\n\n if calibrate is True:\n zlpc = estimate_zero_loss_peak_centre(\n self, mask=mask, signal_range=signal_range\n )\n substract_from_offset(np.nanmean(zlpc.data), also_align + [self])\n\n if subpixel is False:\n return\n\n start, end = signal_range or (-3.0, 3.0)\n\n if calibrate is False:\n start += mean_\n end += mean_\n\n start = (\n start\n if start > self.axes_manager[-1].axis[0]\n else self.axes_manager[-1].axis[0]\n )\n end = (\n end\n if end < self.axes_manager[-1].axis[-1]\n else self.axes_manager[-1].axis[-1]\n )\n\n if self.axes_manager.navigation_size > 1:\n self.align1D(\n start,\n end,\n also_align=also_align,\n show_progressbar=show_progressbar,\n mask=mask,\n crop=crop,\n **kwargs,\n )\n if calibrate is True:\n zlpc = estimate_zero_loss_peak_centre(\n self, mask=mask, signal_range=signal_range\n )\n substract_from_offset(np.nanmean(zlpc.data), also_align + [self])\n\n align_zero_loss_peak.__doc__ %= (SHOW_PROGRESSBAR_ARG, CROP_PARAMETER_DOC)\n\n def get_zero_loss_peak_mask(self, zero_loss_peak_mask_width=5.0, signal_mask=None):\n \"\"\"Return boolean array with True value at the position of the zero\n loss peak. This mask can be used to restrict operation to the signal\n locations not marked as True (masked).\n\n Parameters\n ----------\n zero_loss_peak_mask_width: float\n Width of the zero loss peak mask.\n %s\n\n Returns\n -------\n bool array\n \"\"\"\n zlpc = self.estimate_zero_loss_peak_centre()\n (signal_axis,) = self.axes_manager[self.axes_manager.signal_axes]\n axis = signal_axis.axis\n mini_value = zlpc.data.mean() - zero_loss_peak_mask_width / 2\n maxi_value = zlpc.data.mean() + zero_loss_peak_mask_width / 2\n mask = np.logical_and(mini_value <= axis, axis <= maxi_value)\n if signal_mask is not None:\n signal_mask = np.logical_or(mask, signal_mask)\n else:\n signal_mask = mask\n return signal_mask\n\n get_zero_loss_peak_mask.__doc__ %= SIGNAL_MASK_ARG\n\n def spikes_diagnosis(\n self,\n signal_mask=None,\n navigation_mask=None,\n zero_loss_peak_mask_width=None,\n **kwargs,\n ):\n if zero_loss_peak_mask_width is not None:\n signal_mask = self.get_zero_loss_peak_mask(\n zero_loss_peak_mask_width, signal_mask\n )\n super().spikes_diagnosis(\n signal_mask=signal_mask, navigation_mask=None, **kwargs\n )\n\n spikes_diagnosis.__doc__ = SPIKES_DIAGNOSIS_DOCSTRING % MASK_ZERO_LOSS_PEAK_WIDTH\n\n def spikes_removal_tool(\n self,\n signal_mask=None,\n navigation_mask=None,\n threshold=\"auto\",\n zero_loss_peak_mask_width=None,\n interactive=True,\n display=True,\n toolkit=None,\n ):\n if zero_loss_peak_mask_width is not None:\n axis = self.axes_manager.signal_axes[0].axis\n # check the zero_loss is in the signal\n if (\n axis[0] - zero_loss_peak_mask_width / 2 > 0\n or axis[-1] + zero_loss_peak_mask_width / 2 < 0\n ):\n raise ValueError(\"The zero loss peaks isn't in the energy range.\")\n signal_mask = self.get_zero_loss_peak_mask(\n zero_loss_peak_mask_width, signal_mask\n )\n super().spikes_removal_tool(\n signal_mask=signal_mask,\n navigation_mask=navigation_mask,\n threshold=threshold,\n interactive=interactive,\n display=display,\n toolkit=toolkit,\n )\n\n spikes_removal_tool.__doc__ = SPIKES_REMOVAL_TOOL_DOCSTRING % (\n SIGNAL_MASK_ARG,\n NAVIGATION_MASK_ARG,\n MASK_ZERO_LOSS_PEAK_WIDTH,\n DISPLAY_DT,\n TOOLKIT_DT,\n )\n\n def estimate_elastic_scattering_intensity(self, threshold, show_progressbar=None):\n \"\"\"Rough estimation of the elastic scattering intensity by\n truncation of a EELS low-loss spectrum.\n\n Parameters\n ----------\n threshold : {Signal1D, float, int}\n Truncation energy to estimate the intensity of the elastic\n scattering. The threshold can be provided as a signal of the same\n dimension as the input spectrum navigation space containing the\n threshold value in the energy units. Alternatively a constant\n threshold can be specified in energy/index units by passing\n float/int.\n %s\n\n Returns\n -------\n I0: Signal1D\n The elastic scattering intensity.\n\n See Also\n --------\n estimate_elastic_scattering_threshold\n\n \"\"\"\n # TODO: Write units tests\n self._check_signal_dimension_equals_one()\n\n if show_progressbar is None:\n show_progressbar = hs.preferences.General.show_progressbar\n\n if isinstance(threshold, numbers.Number):\n I0 = self.isig[:threshold].integrate1D(-1)\n else:\n ax = self.axes_manager.signal_axes[0]\n # I0 = self._get_navigation_signal()\n # I0 = I0.transpose(signal_axes=[])\n threshold = threshold.transpose(signal_axes=[])\n binned = ax.is_binned\n\n def estimating_function(data, threshold=None):\n if np.isnan(threshold):\n return np.nan\n else:\n # the object is just an array, so have to reimplement\n # integrate1D. However can make certain assumptions, for\n # example 1D signal and pretty much always binned. Should\n # probably at some point be joint\n ind = ax.value2index(threshold)\n data = data[:ind]\n if binned:\n return data.sum()\n else:\n from scipy.integrate import simps\n\n axis = ax.axis[:ind]\n return simps(y=data, x=axis)\n\n I0 = self.map(\n estimating_function,\n threshold=threshold,\n ragged=False,\n show_progressbar=show_progressbar,\n inplace=False,\n )\n I0.metadata.General.title = self.metadata.General.title + \" elastic intensity\"\n I0.set_signal_type(\"\")\n if self.tmp_parameters.has_item(\"filename\"):\n I0.tmp_parameters.filename = (\n self.tmp_parameters.filename + \"_elastic_intensity\"\n )\n I0.tmp_parameters.folder = self.tmp_parameters.folder\n I0.tmp_parameters.extension = self.tmp_parameters.extension\n return I0\n\n estimate_elastic_scattering_intensity.__doc__ %= SHOW_PROGRESSBAR_ARG\n\n def estimate_elastic_scattering_threshold(\n self, window=10.0, tol=None, window_length=5, polynomial_order=3, start=1.0\n ):\n \"\"\"Calculate the first inflexion point of the spectrum derivative\n within a window.\n\n This method assumes that the zero-loss peak is located at position zero\n in all the spectra. Currently it looks for an inflexion point, that can\n be a local maximum or minimum. Therefore, to estimate the elastic\n scattering threshold `start` + `window` must be less than the first\n maximum for all spectra (often the bulk plasmon maximum). If there is\n more than one inflexion point in energy the window it selects the\n smoother one what, often, but not always, is a good choice in this\n case.\n\n Parameters\n ----------\n window : {None, float}\n If None, the search for the local inflexion point is performed\n using the full energy range. A positive float will restrict\n the search to the (0,window] energy window, where window is given\n in the axis units. If no inflexion point is found in this\n spectral range the window value is returned instead.\n tol : {None, float}\n The threshold tolerance for the derivative. If \"auto\" it is\n automatically calculated as the minimum value that guarantees\n finding an inflexion point in all the spectra in given energy\n range.\n window_length : int\n If non zero performs order three Savitzky-Golay smoothing\n to the data to avoid falling in local minima caused by\n the noise. It must be an odd integer.\n polynomial_order : int\n Savitzky-Golay filter polynomial order.\n start : float\n Position from the zero-loss peak centre from where to start\n looking for the inflexion point.\n\n\n Returns\n -------\n\n threshold : Signal1D\n A Signal1D of the same dimension as the input spectrum\n navigation space containing the estimated threshold. Where the\n threshold couldn't be estimated the value is set to nan.\n\n See Also\n --------\n\n estimate_elastic_scattering_intensity,align_zero_loss_peak,\n find_peaks1D_ohaver, fourier_ratio_deconvolution.\n\n Notes\n -----\n\n The main purpose of this method is to be used as input for\n `estimate_elastic_scattering_intensity`. Indeed, for currently\n achievable energy resolutions, there is not such a thing as a elastic\n scattering threshold. Therefore, please be aware of the limitations of\n this method when using it.\n\n \"\"\"\n self._check_signal_dimension_equals_one()\n # Create threshold with the same shape as the navigation dims.\n threshold = self._get_navigation_signal().transpose(signal_axes=0)\n\n # Progress Bar\n axis = self.axes_manager.signal_axes[0]\n min_index, max_index = axis.value_range_to_indices(start, start + window)\n if max_index < min_index + 10:\n raise ValueError(\"Please select a bigger window\")\n s = self.isig[min_index:max_index].deepcopy()\n if window_length:\n s.smooth_savitzky_golay(\n polynomial_order=polynomial_order,\n window_length=window_length,\n differential_order=1,\n )\n else:\n s = s.derivative(-1)\n if tol is None:\n tol = np.max(abs(s.data).min(axis.index_in_array))\n saxis = s.axes_manager[-1]\n inflexion = (abs(s.data) <= tol).argmax(saxis.index_in_array)\n if isinstance(inflexion, da.Array):\n inflexion = inflexion.compute()\n threshold.data[:] = saxis.index2value(inflexion)\n if isinstance(inflexion, np.ndarray):\n threshold.data[inflexion == 0] = np.nan\n else: # Single spectrum\n if inflexion == 0:\n threshold.data[:] = np.nan\n del s\n if np.isnan(threshold.data).any():\n _logger.warning(\n \"No inflexion point could be found in some positions \"\n \"that have been marked with nans.\"\n )\n # Create spectrum image, stop and return value\n threshold.metadata.General.title = (\n self.metadata.General.title + \" elastic scattering threshold\"\n )\n if self.tmp_parameters.has_item(\"filename\"):\n threshold.tmp_parameters.filename = (\n self.tmp_parameters.filename + \"_elastic_scattering_threshold\"\n )\n threshold.tmp_parameters.folder = self.tmp_parameters.folder\n threshold.tmp_parameters.extension = self.tmp_parameters.extension\n threshold.set_signal_type(\"\")\n return threshold\n\n def estimate_thickness(\n self,\n threshold=None,\n zlp=None,\n density=None,\n mean_free_path=None,\n ):\n \"\"\"Estimates the thickness (relative and absolute)\n of a sample using the log-ratio method.\n\n The current EELS spectrum must be a low-loss spectrum containing\n the zero-loss peak. The hyperspectrum must be well calibrated\n and aligned. To obtain the thickness relative to the mean free path\n don't set the `density` and the `mean_free_path`.\n\n Parameters\n ----------\n threshold : {BaseSignal, float}, optional\n If the zero-loss-peak is not provided, use this energy threshold\n to roughly estimate its intensity by truncation.\n If the threshold is constant across the dataset use a float. Otherwise,\n provide a signal of\n the same dimension as the input spectrum navigation space\n containing the threshold value in the energy units.\n zlp : BaseSignal, optional\n If not None the zero-loss peak intensity is calculated from the ZLP\n spectrum supplied by integration.\n mean_free_path : float, optional\n The mean free path of the material in nanometers.\n If not provided, the thickness\n is given relative to the mean free path.\n density : float, optional\n The density of the material in g/cm**3. This is used to estimate the mean\n free path when the mean free path is not known and to perform the\n angular corrections.\n\n Returns\n -------\n s : BaseSignal\n The thickness relative to the MFP. It returns a Signal1D,\n Signal2D or a BaseSignal, depending on the current navigation\n dimensions.\n\n Notes\n -----\n For details see Egerton, R. Electron Energy-Loss Spectroscopy in the Electron\n Microscope. Springer-Verlag, 2011.\n \"\"\"\n axis = self.axes_manager.signal_axes[0]\n total_intensity = self.integrate1D(axis.index_in_array).data\n if threshold is None and zlp is None:\n raise ValueError(\n \"Please provide one of the following keywords: \" \"`threshold`, `zlp`\"\n )\n if zlp is not None:\n I0 = zlp.integrate1D(axis.index_in_array).data\n else:\n I0 = self.estimate_elastic_scattering_intensity(\n threshold=threshold,\n ).data\n\n t_over_lambda = np.log(total_intensity / I0)\n\n if density is not None:\n if self._are_microscope_parameters_missing():\n raise RuntimeError(\n \"Some microscope parameters are missing. Please use the \"\n \"`set_microscope_parameters()` method to set them. \"\n \"If you don't know them, don't set the `density` keyword.\"\n )\n else:\n md = self.metadata.Acquisition_instrument.TEM\n t_over_lambda *= iMFP_angular_correction(\n beam_energy=md.beam_energy,\n alpha=md.convergence_angle,\n beta=md.Detector.EELS.collection_angle,\n density=density,\n )\n if mean_free_path is None:\n mean_free_path = iMFP_Iakoubovskii(\n electron_energy=self.metadata.Acquisition_instrument.TEM.beam_energy,\n density=density,\n )\n _logger.info(f\"The estimated iMFP is {mean_free_path} nm\")\n else:\n _logger.warning(\n \"Computing the thickness without taking into account the effect of \"\n \"the limited collection angle, what usually leads to underestimating \"\n \"the thickness. To perform the angular corrections you must provide \"\n \"the density of the material.\"\n )\n\n s = self._get_navigation_signal(data=t_over_lambda)\n if mean_free_path is not None:\n s.data *= mean_free_path\n s.metadata.General.title = self.metadata.General.title + \" thickness (nm)\"\n s.metadata.Signal.quantity = \"thickness (nm)\"\n else:\n _logger.warning(\n \"Computing the relative thickness. To compute the absolute \"\n \"thickness provide the `mean_free_path` and/or the `density`\"\n )\n s.metadata.General.title = (\n self.metadata.General.title + \" $\\\\frac{t}{\\\\lambda}$\"\n )\n s.metadata.Signal.quantity = \"$\\\\frac{t}{\\\\lambda}$\"\n if self.tmp_parameters.has_item(\"filename\"):\n s.tmp_parameters.filename = self.tmp_parameters.filename + \"_thickness\"\n s.tmp_parameters.folder = self.tmp_parameters.folder\n s.tmp_parameters.extension = self.tmp_parameters.extension\n s = s.transpose(signal_axes=[])\n s.set_signal_type(\"\")\n return s\n\n def fourier_log_deconvolution(self, zlp, add_zlp=False, crop=False):\n \"\"\"Performs fourier-log deconvolution.\n\n Parameters\n ----------\n zlp : EELSSpectrum\n The corresponding zero-loss peak.\n\n add_zlp : bool\n If True, adds the ZLP to the deconvolved spectrum\n crop : bool\n If True crop the spectrum to leave out the channels that\n have been modified to decay smoothly to zero at the sides\n of the spectrum.\n\n Returns\n -------\n An EELSSpectrum containing the current data deconvolved.\n\n Raises\n ------\n NotImplementedError\n If the signal axis is a non-uniform axis.\n\n Notes\n -----\n For details see: Egerton, R. Electron Energy-Loss\n Spectroscopy in the Electron Microscope. Springer-Verlag, 2011.\n\n \"\"\"\n self._check_signal_dimension_equals_one()\n if not self.axes_manager.signal_axes[0].is_uniform:\n raise NotImplementedError(\n \"This operation is not yet implemented for non-uniform energy axes\"\n )\n s = self.deepcopy()\n zlp_size = zlp.axes_manager.signal_axes[0].size\n self_size = self.axes_manager.signal_axes[0].size\n tapped_channels = s.hanning_taper()\n # Conservative new size to solve the wrap-around problem\n size = zlp_size + self_size - 1\n # Calculate optimal FFT padding for performance\n complex_result = zlp.data.dtype.kind == \"c\" or s.data.dtype.kind == \"c\"\n size = optimal_fft_size(size, not complex_result)\n\n axis = self.axes_manager.signal_axes[0]\n\n z = np.fft.rfft(zlp.data, n=size, axis=axis.index_in_array)\n j = np.fft.rfft(s.data, n=size, axis=axis.index_in_array)\n if self._lazy or zlp._lazy:\n j1 = z * da.log(j / z).map_blocks(np.nan_to_num)\n else:\n j1 = z * np.nan_to_num(np.log(j / z))\n sdata = np.fft.irfft(j1, axis=axis.index_in_array)\n\n s.data = sdata[\n s.axes_manager._get_data_slice(\n [\n (axis.index_in_array, slice(None, self_size)),\n ]\n )\n ]\n if add_zlp is True:\n if self_size >= zlp_size:\n if self._lazy:\n _slices_before = s.axes_manager._get_data_slice(\n [\n (axis.index_in_array, slice(None, zlp_size)),\n ]\n )\n _slices_after = s.axes_manager._get_data_slice(\n [\n (axis.index_in_array, slice(zlp_size, None)),\n ]\n )\n s.data = da.stack(\n (s.data[_slices_before] + zlp.data, s.data[_slices_after]),\n axis=axis.index_in_array,\n )\n else:\n s.data[\n s.axes_manager._get_data_slice(\n [\n (axis.index_in_array, slice(None, zlp_size)),\n ]\n )\n ] += zlp.data\n else:\n s.data += zlp.data[\n s.axes_manager._get_data_slice(\n [\n (axis.index_in_array, slice(None, self_size)),\n ]\n )\n ]\n\n s.metadata.General.title = (\n s.metadata.General.title + \" after Fourier-log deconvolution\"\n )\n if s.tmp_parameters.has_item(\"filename\"):\n s.tmp_parameters.filename = (\n self.tmp_parameters.filename + \"_after_fourier_log_deconvolution\"\n )\n if crop is True:\n s.crop(axis.index_in_axes_manager, None, int(-tapped_channels))\n return s\n\n def fourier_ratio_deconvolution(\n self,\n ll,\n fwhm=None,\n threshold=None,\n extrapolate_lowloss=True,\n extrapolate_coreloss=True,\n ):\n \"\"\"Performs Fourier-ratio deconvolution.\n\n The core-loss should have the background removed. To reduce the noise\n amplification the result is convolved with a Gaussian function.\n\n Parameters\n ----------\n ll: EELSSpectrum\n The corresponding low-loss (ll) EELSSpectrum.\n fwhm : float or None\n Full-width half-maximum of the Gaussian function by which\n the result of the deconvolution is convolved. It can be\n used to select the final SNR and spectral resolution. If\n None, the FWHM of the zero-loss peak of the low-loss is\n estimated and used.\n threshold : {None, float}\n Truncation energy to estimate the intensity of the\n elastic scattering. If None the threshold is taken as the\n first minimum after the ZLP centre.\n extrapolate_lowloss, extrapolate_coreloss : bool\n If True the signals are extrapolated using a power law,\n\n Raises\n ------\n NotImplementedError\n If the signal axis is a non-uniform axis.\n\n Notes\n -----\n For details see: Egerton, R. Electron Energy-Loss\n Spectroscopy in the Electron Microscope. Springer-Verlag, 2011.\n\n \"\"\"\n self._check_signal_dimension_equals_one()\n if not self.axes_manager.signal_axes[0].is_uniform:\n raise NotImplementedError(\n \"This operation is not yet implemented for non-uniform energy axes.\"\n )\n if not ll.axes_manager.signal_axes[0].is_uniform:\n raise NotImplementedError(\n \"The low-loss energy axis is non-uniform. \"\n \"This operation is not yet implemented for non-uniform energy axes\"\n )\n orig_cl_size = self.axes_manager.signal_axes[0].size\n\n if threshold is None:\n threshold = ll.estimate_elastic_scattering_threshold()\n\n if extrapolate_coreloss is True:\n cl = self.power_law_extrapolation(window_size=20, extrapolation_size=100)\n else:\n cl = self.deepcopy()\n\n if extrapolate_lowloss is True:\n ll = ll.power_law_extrapolation(window_size=100, extrapolation_size=100)\n else:\n ll = ll.deepcopy()\n\n ll.hanning_taper()\n cl.hanning_taper()\n\n ll_size = ll.axes_manager.signal_axes[0].size\n cl_size = self.axes_manager.signal_axes[0].size\n # Conservative new size to solve the wrap-around problem\n size = ll_size + cl_size - 1\n # Calculate the optimal FFT size\n size = optimal_fft_size(size)\n\n axis = ll.axes_manager.signal_axes[0]\n if fwhm is None:\n fwhm = float(\n ll.get_current_signal().estimate_peak_width()._get_current_data()\n )\n _logger.info(\"FWHM = %1.2f\" % fwhm)\n\n I0 = ll.estimate_elastic_scattering_intensity(threshold=threshold)\n I0 = I0.data\n if ll.axes_manager.navigation_size > 0:\n I0_shape = list(I0.shape)\n I0_shape.insert(axis.index_in_array, 1)\n I0 = I0.reshape(I0_shape)\n\n from hyperspy.components1d import Gaussian\n\n g = Gaussian()\n g.sigma.value = fwhm / 2.3548\n g.A.value = 1\n g.centre.value = 0\n zl = g.function(\n np.linspace(axis.offset, axis.offset + axis.scale * (size - 1), size)\n )\n z = np.fft.rfft(zl)\n jk = np.fft.rfft(cl.data, n=size, axis=axis.index_in_array)\n jl = np.fft.rfft(ll.data, n=size, axis=axis.index_in_array)\n zshape = [\n 1,\n ] * len(cl.data.shape)\n zshape[axis.index_in_array] = jk.shape[axis.index_in_array]\n cl.data = np.fft.irfft(z.reshape(zshape) * jk / jl, axis=axis.index_in_array)\n cl.data *= I0\n cl.crop(-1, None, int(orig_cl_size))\n cl.metadata.General.title = (\n self.metadata.General.title + \" after Fourier-ratio deconvolution\"\n )\n if cl.tmp_parameters.has_item(\"filename\"):\n cl.tmp_parameters.filename = (\n self.tmp_parameters.filename + \"after_fourier_ratio_deconvolution\"\n )\n return cl\n\n def richardson_lucy_deconvolution(\n self, psf, iterations=15, show_progressbar=None, num_workers=None\n ):\n \"\"\"1D Richardson-Lucy Poissonian deconvolution of\n the spectrum by the given kernel.\n\n Parameters\n ----------\n psf : EELSSpectrum\n It must have the same signal dimension as the current\n spectrum and a spatial dimension of 0 or the same as the\n current spectrum.\n iterations : int\n Number of iterations of the deconvolution. Note that\n increasing the value will increase the noise amplification.\n %s\n %s\n\n Raises\n ------\n NotImplementedError\n If the signal axis is a non-uniform axis.\n\n Notes\n -----\n For details on the algorithm see Gloter, A., A. Douiri,\n M. Tence, and C. Colliex. “Improving Energy Resolution of\n EELS Spectra: An Alternative to the Monochromator Solution.”\n Ultramicroscopy 96, no. 3–4 (September 2003): 385–400.\n\n \"\"\"\n if not self.axes_manager.signal_axes[0].is_uniform:\n raise NotImplementedError(\n \"This operation is not yet implemented for non-uniform energy axes.\"\n )\n if show_progressbar is None:\n show_progressbar = hs.preferences.General.show_progressbar\n self._check_signal_dimension_equals_one()\n psf_size = psf.axes_manager.signal_axes[0].size\n maxval = self.axes_manager.navigation_size\n show_progressbar = show_progressbar and (maxval > 0)\n\n def deconv_function(signal, kernel=None, iterations=15, psf_size=None):\n imax = kernel.argmax()\n result = np.array(signal).copy()\n mimax = psf_size - 1 - imax\n for _ in range(iterations):\n first = np.convolve(kernel, result)[imax : imax + psf_size]\n result *= np.convolve(kernel[::-1], signal / first)[\n mimax : mimax + psf_size\n ]\n return result\n\n ds = self.map(\n deconv_function,\n kernel=psf,\n iterations=iterations,\n psf_size=psf_size,\n show_progressbar=show_progressbar,\n num_workers=num_workers,\n ragged=False,\n inplace=False,\n )\n\n ds.metadata.General.title += (\n \" after Richardson-Lucy deconvolution %i iterations\" % iterations\n )\n if ds.tmp_parameters.has_item(\"filename\"):\n ds.tmp_parameters.filename += \"_after_R-L_deconvolution_%iiter\" % iterations\n return ds\n\n richardson_lucy_deconvolution.__doc__ %= (SHOW_PROGRESSBAR_ARG, NUM_WORKERS_ARG)\n\n def _are_microscope_parameters_missing(self, ignore_parameters=[]):\n \"\"\"\n Check if the EELS parameters necessary to calculate the GOS\n are defined in metadata. If not, in interactive mode\n raises an UI item to fill the values.\n The `ignore_parameters` list can be to ignore parameters.\n \"\"\"\n must_exist = (\n \"Acquisition_instrument.TEM.convergence_angle\",\n \"Acquisition_instrument.TEM.beam_energy\",\n \"Acquisition_instrument.TEM.Detector.EELS.collection_angle\",\n )\n missing_parameters = []\n for item in must_exist:\n exists = self.metadata.has_item(item)\n if exists is False and item.split(\".\")[-1] not in ignore_parameters:\n missing_parameters.append(item)\n if missing_parameters:\n _logger.info(\"Missing parameters {}\".format(missing_parameters))\n return True\n else:\n return False\n\n def set_microscope_parameters(\n self,\n beam_energy=None,\n convergence_angle=None,\n collection_angle=None,\n toolkit=None,\n display=True,\n ):\n if set((beam_energy, convergence_angle, collection_angle)) == {None}:\n tem_par = EELSTEMParametersUI(self)\n return tem_par.gui(toolkit=toolkit, display=display)\n mp = self.metadata\n if beam_energy is not None:\n mp.set_item(\"Acquisition_instrument.TEM.beam_energy\", beam_energy)\n if convergence_angle is not None:\n mp.set_item(\n \"Acquisition_instrument.TEM.convergence_angle\", convergence_angle\n )\n if collection_angle is not None:\n mp.set_item(\n \"Acquisition_instrument.TEM.Detector.EELS.collection_angle\",\n collection_angle,\n )\n\n set_microscope_parameters.__doc__ = \"\"\"\n Set the microscope parameters that are necessary to calculate\n the GOS.\n\n If not all of them are defined, in interactive mode\n raises an UI item to fill the values.\n\n beam_energy: float\n The energy of the electron beam in keV.\n convergence_angle : float\n The microscope convergence semi-angle in mrad.\n collection_angle : float\n The collection semi-angle in mrad.\n {}\n {}\n \"\"\".format(\n TOOLKIT_DT, DISPLAY_DT\n )\n\n def power_law_extrapolation(\n self, window_size=20, extrapolation_size=1024, add_noise=False, fix_neg_r=False\n ):\n \"\"\"\n Extrapolate the spectrum to the right using a powerlaw.\n\n Parameters\n ----------\n window_size : int\n The number of channels from the right side of the\n spectrum that are used to estimate the power law\n parameters.\n extrapolation_size : int\n Size of the extrapolation in number of channels\n add_noise : bool\n If True, add poissonian noise to the extrapolated spectrum.\n fix_neg_r : bool\n If True, the negative values for the \"components.PowerLaw\"\n parameter r will be flagged and the extrapolation will be\n done with a constant zero-value.\n\n Returns\n -------\n A new spectrum, with the extrapolation.\n\n \"\"\"\n self._check_signal_dimension_equals_one()\n axis = self.axes_manager.signal_axes[0]\n s = self.deepcopy()\n s.metadata.General.title += \" %i channels extrapolated\" % extrapolation_size\n if s.tmp_parameters.has_item(\"filename\"):\n s.tmp_parameters.filename += (\n \"_%i_channels_extrapolated\" % extrapolation_size\n )\n new_shape = list(self.data.shape)\n new_shape[axis.index_in_array] += extrapolation_size\n if self._lazy:\n left_data = s.data\n right_shape = list(self.data.shape)\n right_shape[axis.index_in_array] = extrapolation_size\n right_chunks = list(self.data.chunks)\n right_chunks[axis.index_in_array] = (extrapolation_size,)\n right_data = da.zeros(\n shape=tuple(right_shape),\n chunks=tuple(right_chunks),\n dtype=self.data.dtype,\n )\n s.data = da.concatenate([left_data, right_data], axis=axis.index_in_array)\n else:\n # just old code\n s.data = np.zeros(new_shape)\n s.data[..., : axis.size] = self.data\n s.get_dimensions_from_data()\n pl = PowerLaw()\n pl._axes_manager = self.axes_manager\n A, r = pl.estimate_parameters(\n s,\n axis.index2value(axis.size - window_size),\n axis.index2value(axis.size - 1),\n out=True,\n )\n if fix_neg_r is True:\n A = np.where(r <= 0, 0, A)\n # If the signal is binned we need to bin the extrapolated power law\n # what, in a first approximation, can be done by multiplying by the\n # axis step size.\n if self.axes_manager[-1].is_binned:\n factor = s.axes_manager[-1].scale\n else:\n factor = 1\n if self._lazy:\n # only need new axes if the navigation dimension is not 0\n if s.axes_manager.navigation_dimension:\n rightslice = (..., None)\n axisslice = (None, slice(axis.size, None))\n else:\n rightslice = (...,)\n axisslice = (slice(axis.size, None),)\n right_chunks[axis.index_in_array] = 1\n x = da.from_array(\n s.axes_manager.signal_axes[0].axis[axisslice],\n chunks=(extrapolation_size,),\n )\n A = A[rightslice]\n r = r[rightslice]\n right_data = factor * A * x ** (-r)\n s.data = da.concatenate([left_data, right_data], axis=axis.index_in_array)\n else:\n s.data[..., axis.size :] = (\n factor\n * A[..., np.newaxis]\n * s.axes_manager.signal_axes[0].axis[np.newaxis, axis.size :]\n ** (-r[..., np.newaxis])\n )\n return s\n\n def kramers_kronig_analysis(\n self, zlp=None, iterations=1, n=None, t=None, delta=0.5, full_output=False\n ):\n r\"\"\"\n Calculate the complex dielectric function from a single scattering\n distribution (SSD) using the Kramers-Kronig relations.\n\n It uses the FFT method as in [1]_. The SSD is an\n EELSSpectrum instance containing SSD low-loss EELS with no zero-loss\n peak. The internal loop is devised to approximately subtract the\n surface plasmon contribution supposing an unoxidized planar surface and\n neglecting coupling between the surfaces. This method does not account\n for retardation effects, instrumental broadening and surface plasmon\n excitation in particles.\n\n Note that either refractive index or thickness are required.\n If both are None or if both are provided an exception is raised.\n\n Parameters\n ----------\n zlp : {None, number, Signal1D}\n ZLP intensity. It is optional (can be None) if `t` is None and `n`\n is not None and the thickness estimation is not required. If `t`\n is not None, the ZLP is required to perform the normalization and\n if `t` is not None, the ZLP is required to calculate the thickness.\n If the ZLP is the same for all spectra, the integral of the ZLP\n can be provided as a number. Otherwise, if the ZLP intensity is not\n the same for all spectra, it can be provided as i) a Signal1D\n of the same dimensions as the current signal containing the ZLP\n spectra for each location ii) a BaseSignal of signal dimension 0\n and navigation_dimension equal to the current signal containing the\n integrated ZLP intensity.\n iterations : int\n Number of the iterations for the internal loop to remove the\n surface plasmon contribution. If 1 the surface plasmon contribution\n is not estimated and subtracted (the default is 1).\n n : {None, float}\n The medium refractive index. Used for normalization of the\n SSD to obtain the energy loss function. If given the thickness\n is estimated and returned. It is only required when `t` is None.\n t : {None, number, Signal1D}\n The sample thickness in nm. Used for normalization of the SSD\n to obtain the energy loss function. It is only required when\n `n` is None. If the thickness is the same for all spectra it can be\n given by a number. Otherwise, it can be provided as a BaseSignal\n with signal dimension 0 and navigation_dimension equal to the\n current signal.\n delta : float\n A small number (0.1-0.5 eV) added to the energy axis in\n specific steps of the calculation the surface loss correction to\n improve stability.\n full_output : bool\n If True, return a dictionary that contains the estimated\n thickness if `t` is None and the estimated surface plasmon\n excitation and the spectrum corrected from surface plasmon\n excitations if `iterations` > 1.\n\n Returns\n -------\n eps: DielectricFunction instance\n The complex dielectric function results,\n\n .. math::\n \\epsilon = \\epsilon_1 + i*\\epsilon_2,\n\n contained in an DielectricFunction instance.\n output: Dictionary (optional)\n A dictionary of optional outputs with the following keys\n\n * ``thickness``: the estimated thickness in nm calculated by\n normalization of the SSD (only when ``t`` is None)\n * ``surface plasmon estimation``: the estimated surface plasmon\n excitation (only if ``iterations`` > 1.)\n\n Raises\n ------\n ValueError\n If both `n` and `t` are undefined (None).\n AttributeError\n If the beam_energy or the collection semi-angle are not defined in\n metadata.\n NotImplementedError\n If the signal axis is a non-uniform axis.\n\n Notes\n -----\n This method is based in Egerton's Matlab code [1]_ with a\n minor difference: the wrap-around problem when computing the FFTs is\n workarounded by padding the signal instead of subtracting the\n reflected tail.\n\n .. [1] Ray Egerton, \"Electron Energy-Loss Spectroscopy in the Electron\n Microscope\", Springer-Verlag, 2011.\n\n \"\"\"\n if not self.axes_manager.signal_axes[0].is_uniform:\n raise NotImplementedError(\n \"This operation is not yet implemented for non-uniform energy axes.\"\n )\n output = {}\n if iterations == 1:\n # In this case s.data is not modified so there is no need to make\n # a deep copy.\n s = self.isig[0.0:]\n else:\n s = self.isig[0.0:].deepcopy()\n\n sorig = self.isig[0.0:]\n # Avoid singularity at 0\n if s.axes_manager.signal_axes[0].axis[0] == 0:\n s = s.isig[1:]\n sorig = self.isig[1:]\n\n # Constants and units\n me = constants.value(\"electron mass energy equivalent in MeV\") * 1e3 # keV\n\n # Mapped parameters\n self._are_microscope_parameters_missing(ignore_parameters=[\"convergence_angle\"])\n e0 = s.metadata.Acquisition_instrument.TEM.beam_energy\n beta = s.metadata.Acquisition_instrument.TEM.Detector.EELS.collection_angle\n\n axis = s.axes_manager.signal_axes[0]\n eaxis = axis.axis.copy()\n\n if isinstance(zlp, hyperspy.signal.BaseSignal):\n if (\n zlp.axes_manager.navigation_dimension\n == self.axes_manager.navigation_dimension\n ):\n if zlp.axes_manager.signal_dimension == 0:\n i0 = zlp.data\n else:\n i0 = zlp.integrate1D(axis.index_in_axes_manager).data\n else:\n raise ValueError(\n \"The ZLP signal dimensions are not \"\n \"compatible with the dimensions of the \"\n \"low-loss signal\"\n )\n # The following prevents errors if the signal is a single spectrum\n if len(i0) != 1:\n i0 = i0.reshape(np.insert(i0.shape, axis.index_in_array, 1))\n elif isinstance(zlp, numbers.Number):\n i0 = zlp\n else:\n raise ValueError(\n \"The zero-loss peak input is not valid, it must be\\\n in the BaseSignal class or a Number.\"\n )\n\n if isinstance(t, hyperspy.signal.BaseSignal):\n if (\n t.axes_manager.navigation_dimension\n == self.axes_manager.navigation_dimension\n ) and (t.axes_manager.signal_dimension == 0):\n t = t.data\n t = t.reshape(np.insert(t.shape, axis.index_in_array, 1))\n else:\n raise ValueError(\n \"The thickness signal dimensions are not \"\n \"compatible with the dimensions of the \"\n \"low-loss signal\"\n )\n elif isinstance(t, np.ndarray) and t.shape and t.shape != (1,):\n raise ValueError(\n \"thickness must be a HyperSpy signal or a number,\" \" not a NumPy array.\"\n )\n\n # Slicer to get the signal data from 0 to axis.size\n slicer = s.axes_manager._get_data_slice(\n [\n (axis.index_in_array, slice(None, axis.size)),\n ]\n )\n\n # Kinetic definitions\n ke = e0 * (1 + e0 / 2.0 / me) / (1 + e0 / me) ** 2\n tgt = e0 * (2 * me + e0) / (me + e0)\n rk0 = 2590 * (1 + e0 / me) * np.sqrt(2 * ke / me)\n\n for io in range(iterations):\n # Calculation of the ELF by normalization of the SSD\n # Norm(SSD) = Imag(-1/epsilon) (Energy Loss Function, ELF)\n\n # We start by the \"angular corrections\"\n Im = s.data / (np.log(1 + (beta * tgt / eaxis) ** 2)) / axis.scale\n if n is None and t is None:\n raise ValueError(\n \"The thickness and the refractive index are \"\n \"not defined. Please provide one of them.\"\n )\n elif n is not None and t is not None:\n raise ValueError(\n \"Please provide the refractive index OR the \"\n \"thickness information, not both\"\n )\n elif n is not None:\n # normalize using the refractive index.\n K = (Im / eaxis).sum(\n axis=axis.index_in_array, keepdims=True\n ) * axis.scale\n K = K / (np.pi / 2) / (1 - 1.0 / n**2)\n # K = (K / (np.pi / 2) / (1 - 1. / n ** 2)).reshape(\n # np.insert(K.shape, axis.index_in_array, 1))\n # Calculate the thickness only if possible and required\n if zlp is not None and (full_output is True or iterations > 1):\n te = 332.5 * K * ke / i0\n if full_output is True:\n output[\"thickness\"] = te\n elif t is not None:\n if zlp is None:\n raise ValueError(\n \"The ZLP must be provided when the \"\n \"thickness is used for normalization.\"\n )\n # normalize using the thickness\n K = t * i0 / (332.5 * ke)\n te = t\n Im = Im / K\n\n # Kramers Kronig Transform:\n # We calculate KKT(Im(-1/epsilon))=1+Re(1/epsilon) with FFT\n # Follows: D W Johnson 1975 J. Phys. A: Math. Gen. 8 490\n # Use an optimal FFT size to speed up the calculation, and\n # make it double the closest upper value to workaround the\n # wrap-around problem.\n esize = optimal_fft_size(2 * axis.size)\n q = -2 * np.fft.fft(Im, esize, axis.index_in_array).imag / esize\n\n q[slicer] *= -1\n q = np.fft.fft(q, axis=axis.index_in_array)\n # Final touch, we have Re(1/eps)\n Re = q[slicer].real + 1\n\n # Egerton does this to correct the wrap-around problem, but in our\n # case this is not necessary because we compute the fft on an\n # extended and padded spectrum to avoid this problem.\n # Re=real(q)\n # Tail correction\n # vm=Re[axis.size-1]\n # Re[:(axis.size-1)]=Re[:(axis.size-1)]+1-(0.5*vm*((axis.size-1) /\n # (axis.size*2-arange(0,axis.size-1)))**2)\n # Re[axis.size:]=1+(0.5*vm*((axis.size-1) /\n # (axis.size+arange(0,axis.size)))**2)\n\n # Epsilon appears:\n # We calculate the real and imaginary parts of the CDF\n e1 = Re / (Re**2 + Im**2)\n e2 = Im / (Re**2 + Im**2)\n\n if iterations > 1 and zlp is not None:\n # Surface losses correction:\n # Calculates the surface ELF from a vacuum border effect\n # A simulated surface plasmon is subtracted from the ELF\n Srfelf = 4 * e2 / ((e1 + 1) ** 2 + e2**2) - Im\n adep = tgt / (eaxis + delta) * np.arctan(\n beta * tgt / axis.axis\n ) - beta / 1000.0 / (beta**2 + axis.axis**2.0 / tgt**2)\n Srfint = 2000 * K * adep * Srfelf / rk0 / te * axis.scale\n s.data = sorig.data - Srfint\n _logger.debug(\"Iteration number: %d / %d\", io + 1, iterations)\n if iterations == io + 1 and full_output is True:\n sp = sorig._deepcopy_with_new_data(Srfint)\n sp.metadata.General.title += (\n \" estimated surface plasmon excitation.\"\n )\n output[\"surface plasmon estimation\"] = sp\n del sp\n del Srfint\n\n eps = s._deepcopy_with_new_data(e1 + e2 * 1j)\n del s\n eps.set_signal_type(\"DielectricFunction\")\n eps.metadata.General.title = (\n self.metadata.General.title + \"dielectric function \"\n \"(from Kramers-Kronig analysis)\"\n )\n if eps.tmp_parameters.has_item(\"filename\"):\n eps.tmp_parameters.filename = (\n self.tmp_parameters.filename + \"_CDF_after_Kramers_Kronig_transform\"\n )\n if \"thickness\" in output:\n # As above,prevent errors if the signal is a single spectrum\n if len(te) != 1:\n te = te[self.axes_manager._get_data_slice([(axis.index_in_array, 0)])]\n thickness = eps._get_navigation_signal(data=te)\n thickness.metadata.General.title = (\n self.metadata.General.title + \" thickness \"\n \"(calculated using Kramers-Kronig analysis)\"\n )\n output[\"thickness\"] = thickness\n if full_output is False:\n return eps\n else:\n return eps, output\n\n def create_model(\n self,\n low_loss=None,\n auto_background=True,\n auto_add_edges=True,\n GOS=\"gosh\",\n gos_file_path=None,\n dictionary=None,\n ):\n \"\"\"Create a model for the current EELS data.\n\n Parameters\n ----------\n %s\n\n Returns\n -------\n model : :class:`~.models.eelsmodel.EELSModel` instance.\n\n Raises\n ------\n NotImplementedError\n If the signal axis is a non-uniform axis.\n \"\"\"\n from exspy.models.eelsmodel import EELSModel\n\n if low_loss is not None and not self.axes_manager.signal_axes[0].is_uniform:\n raise NotImplementedError(\n \"Multiple scattering is not implemented for spectra with a \"\n \"non-uniform energy axis. To create a model that does not \"\n \"account for multiple-scattering do not set the `ll` keyword.\"\n )\n model = EELSModel(\n self,\n low_loss=low_loss,\n auto_background=auto_background,\n auto_add_edges=auto_add_edges,\n GOS=GOS,\n dictionary=dictionary,\n )\n return model\n\n create_model.__doc__ %= EELSMODEL_PARAMETERS\n\n def plot(self, plot_edges=False, only_edges=(\"Major\", \"Minor\"), **kwargs):\n \"\"\"\n Plot the EELS spectrum. Markers indicating the position of the\n EELS edges can be added.\n\n Parameters\n ----------\n plot_edges : {False, True, list of string or string}\n If True, draws on s.metadata.Sample.elements for edges.\n Alternatively, provide a string of a single edge, or an iterable\n containing a list of valid elements, EELS families or edges. For\n example, an element should be 'Zr', an element edge family should\n be 'Zr_L' or an EELS edge 'Zr_L3'.\n only_edges : tuple of string\n Either 'Major' or 'Minor'. Defaults to both.\n kwargs\n The extra keyword arguments for plot()\n \"\"\"\n\n super().plot(**kwargs)\n\n if plot_edges:\n # edges is a mapping {edge_name:edge_energy}\n edges = self._get_edges_to_plot(plot_edges, only_edges)\n self._plot_edge_labels(edges)\n\n self._plot.signal_plot.events.closed.connect(self._on_signal_plot_closing, [])\n\n def _on_signal_plot_closing(self):\n self._edge_markers = {\"lines\": None, \"texts\": None, \"names\": []}\n\n def _get_offsets_and_segments(self, edges):\n index = np.array([float(v) for v in edges.values()]) # dictionaries\n segments = np.empty((len(index), 2, 2))\n offsets = np.empty((len(index), 2))\n for i, ind in enumerate(index):\n segments[i] = [[ind, 1], [ind, 1.1]]\n offsets[i] = [ind, 1.1]\n return offsets, segments\n\n def _initialise_markers(self):\n self._edge_markers[\"lines\"] = Lines(\n segments=np.empty((0, 2, 2)),\n transform=\"relative\",\n color=\"black\",\n shift=np.array([0.0, 0.19]),\n )\n self._edge_markers[\"texts\"] = Texts(\n offsets=np.empty((0, 2)),\n texts=np.empty((0,)),\n offset_transform=\"relative\",\n rotation=np.pi / 2,\n horizontalalignment=\"left\",\n verticalalignment=\"bottom\",\n facecolor=\"black\",\n shift=0.2,\n )\n for key in [\"lines\", \"texts\"]:\n self.add_marker(self._edge_markers[key], render_figure=False)\n\n def _plot_edge_labels(self, edges):\n \"\"\"\n Plot the EELS edge label (vertical line segment and text box) on\n the signal\n\n Parameters\n ----------\n edges : dictionary\n A dictionary with the labels as keys and their energies as values.\n For example, {'Fe_L2': 721.0, 'O_K': 532.0}\n\n \"\"\"\n # the object is needed to connect replot method when axes_manager\n # indices changed\n _ = EdgesRange(self, interactive=False)\n self._add_edge_labels(edges)\n\n def _get_edges_to_plot(self, plot_edges, only_edges):\n # get the dictionary of the edge to be shown\n extra_element_edge_family = []\n if plot_edges is True:\n try:\n elements = self.metadata.Sample.elements\n except AttributeError:\n raise ValueError(\n \"No elements defined. Add them with \"\n \"s.add_elements, or specify elements, edge \"\n \"families or edges directly\"\n )\n else:\n extra_element_edge_family.extend(np.atleast_1d(plot_edges))\n try:\n elements = self.metadata.Sample.elements\n except:\n elements = []\n\n element_edge_family = elements + extra_element_edge_family\n edges_dict = self._get_edges(element_edge_family, only_edges)\n\n return edges_dict\n\n def _get_edges(self, element_edge_family, only_edges):\n # get corresponding information depending on whether it is an element\n # a particular edge or a family of edge\n axis_min = self.axes_manager[-1].low_value\n axis_max = self.axes_manager[-1].high_value\n\n names_and_energies = {}\n shells = [\"K\", \"L\", \"M\", \"N\", \"O\"]\n\n errmsg = \"Edge family '{}' is not supported. Supported edge family \" \"is {}.\"\n for member in element_edge_family:\n try:\n element, ss = member.split(\"_\")\n\n if len(ss) == 1:\n memtype = \"family\"\n if ss not in shells:\n raise AttributeError(errmsg.format(ss, shells))\n if len(ss) == 2:\n memtype = \"edge\"\n if ss[0] not in shells:\n raise AttributeError(errmsg.format(ss[0], shells))\n except ValueError:\n element = member\n ss = \"\"\n memtype = \"element\"\n\n try:\n Binding_energies = elements_db[element][\"Atomic_properties\"][\n \"Binding_energies\"\n ]\n except KeyError as err:\n raise ValueError(\"'{}' is not a valid element\".format(element)) from err\n\n for edge in Binding_energies.keys():\n relevance = Binding_energies[edge][\"relevance\"]\n energy = Binding_energies[edge][\"onset_energy (eV)\"]\n\n isInRel = relevance in only_edges\n isInRng = axis_min < energy < axis_max\n isSameFamily = ss in edge\n\n if memtype == \"element\":\n flag = isInRel & isInRng\n edge_key = element + \"_\" + edge\n elif memtype == \"edge\":\n flag = isInRng & (edge == ss)\n edge_key = member\n elif memtype == \"family\":\n flag = isInRel & isInRng & isSameFamily\n edge_key = element + \"_\" + edge\n\n if flag:\n names_and_energies[edge_key] = energy\n\n return names_and_energies\n\n def _remove_edge_labels(self, edge_names=None, render_figure=True):\n \"\"\"\n Remove EELS edges markers to the signal\n\n Parameters\n ----------\n edge_names : str, list of str or None\n The string must be the name of edges, e. g. 'Fe_L2'.\n If ``None`` (default), remove all edges.\n render_figure : bool\n If True, render the figure after adding the markers\n \"\"\"\n if edge_names is None:\n edge_names = self._edge_markers[\"names\"]\n if isinstance(edge_names, set):\n # convert to list to find the index\n edge_names = list(edge_names)\n if not isinstance(edge_names, (list, tuple, np.ndarray)):\n edge_names = [edge_names]\n\n ind = np.where(np.isin(self._edge_markers[\"names\"], edge_names))\n\n if self._edge_markers[\"lines\"] is not None:\n self._edge_markers[\"lines\"].remove_items(ind)\n if self._edge_markers[\"texts\"] is not None:\n self._edge_markers[\"texts\"].remove_items(ind)\n if self._edge_markers[\"names\"] is not []:\n self._edge_markers[\"names\"] = np.delete(self._edge_markers[\"names\"], ind)\n\n if render_figure:\n self._render_figure(plot=[\"signal_plot\"])\n\n def _add_edge_labels(self, edges, render_figure=True):\n \"\"\"\n Add EELS edges markers to the signal\n\n Parameters\n ----------\n edge_name : dictionary or set\n If dictionary must be the name of edge as key and energy as values,\n e.g. {'Cr_L2': 584.0}. If list or set, must the name of the edge,\n e.g. set('Cr_L2', )\n render_figure : bool\n If True, render the figure after adding the markers\n \"\"\"\n if isinstance(edges, set):\n edges_dict = {}\n for edge in edges:\n element, ss = edge.split(\"_\")\n Binding_energies = elements_db[element][\"Atomic_properties\"][\n \"Binding_energies\"\n ]\n edges_dict[edge] = Binding_energies[ss][\"onset_energy (eV)\"]\n edges = edges_dict\n\n offsets, segments = self._get_offsets_and_segments(edges)\n names = list(edges.keys())\n\n self._edge_markers[\"lines\"].add_items(segments=segments)\n self._edge_markers[\"lines\"].update()\n self._edge_markers[\"texts\"].add_items(offsets=offsets, texts=names)\n self._edge_markers[\"lines\"].update()\n self._edge_markers[\"names\"] = np.append(self._edge_markers[\"names\"], names)\n\n if render_figure:\n self._render_figure(plot=[\"signal_plot\"])\n\n def _get_complementary_edges(self, edges, only_major=False):\n \"\"\"\n Get other edges of the same element present within the energy\n range of the axis\n\n Parameters\n ----------\n edges : iterable\n A sequence of strings contains edges in the format of\n element_subshell for EELS. For example, ['Fe_L2', 'O_K']\n only_major : bool\n Whether to show only the major edges. The default is False.\n\n Returns\n -------\n complmt_edges : list\n A list containing all the complementary edges of the same element\n present within the energy range of the axis\n \"\"\"\n\n emin = self.axes_manager[-1].low_value\n emax = self.axes_manager[-1].high_value\n complmt_edges = []\n\n elements = set()\n for edge in edges:\n element, _ = edge.split(\"_\")\n elements.update([element])\n\n for element in elements:\n ss_info = elements_db[element][\"Atomic_properties\"][\"Binding_energies\"]\n\n for subshell in ss_info:\n sse = ss_info[subshell][\"onset_energy (eV)\"]\n ssr = ss_info[subshell][\"relevance\"]\n\n if only_major:\n if ssr != \"Major\":\n continue\n\n edge = element + \"_\" + subshell\n if (\n (emin <= sse <= emax)\n and (subshell[-1] != \"a\")\n and (edge not in edges)\n ):\n complmt_edges.append(edge)\n\n return complmt_edges\n\n def rebin(self, new_shape=None, scale=None, crop=True, dtype=None, out=None):\n factors = self._validate_rebin_args_and_get_factors(\n new_shape=new_shape, scale=scale\n )\n m = super().rebin(\n new_shape=new_shape, scale=scale, crop=crop, dtype=dtype, out=out\n )\n m = out or m\n time_factor = np.prod(\n [factors[axis.index_in_array] for axis in m.axes_manager.navigation_axes]\n )\n mdeels = m.metadata\n m.get_dimensions_from_data()\n if m.metadata.get_item(\"Acquisition_instrument.TEM.Detector.EELS\"):\n mdeels = m.metadata.Acquisition_instrument.TEM.Detector.EELS\n if \"dwell_time\" in mdeels:\n mdeels.dwell_time *= time_factor\n if \"exposure\" in mdeels:\n mdeels.exposure *= time_factor\n else:\n _logger.info(\n \"No dwell_time could be found in the metadata so \"\n \"this has not been updated.\"\n )\n if out is None:\n return m\n else:\n out.events.data_changed.trigger(obj=out)\n return m\n\n rebin.__doc__ = hyperspy.signal.BaseSignal.rebin.__doc__\n\n def vacuum_mask(\n self, threshold=10.0, start_energy=None, closing=True, opening=False\n ):\n \"\"\"\n Generate mask of the vacuum region\n\n Parameters\n ----------\n threshold: float\n For a given navigation coordinate, mean value in the energy axis\n below which the pixel is considered as vacuum.\n start_energy: float, None\n Minimum energy included in the calculation of the mean intensity.\n If None, consider only the last quarter of the spectrum to\n calculate the mask.\n closing: bool\n If True, a morphological closing is applied to the mask.\n opening: bool\n If True, a morphological opening is applied to the mask.\n\n Returns\n -------\n mask: signal\n The mask of the region.\n \"\"\"\n if self.axes_manager.navigation_dimension == 0:\n raise RuntimeError(\n \"Navigation dimenstion must be higher than 0 \"\n \"to estimate a vacuum mask.\"\n )\n signal_axis = self.axes_manager.signal_axes[0]\n if start_energy is None:\n start_energy = 0.75 * signal_axis.high_value\n\n mask = self.isig[start_energy:].mean(-1) <= threshold\n\n from scipy.ndimage import binary_dilation, binary_erosion\n\n if closing:\n mask.data = binary_dilation(mask.data, border_value=0)\n mask.data = binary_erosion(mask.data, border_value=1)\n if opening:\n mask.data = binary_erosion(mask.data, border_value=1)\n mask.data = binary_dilation(mask.data, border_value=0)\n return mask"}],"string":"[\n {\n \"identifier\": \"elements_db\",\n \"path\": \"exspy/misc/elements.py\",\n \"snippet\": \"\"\n },\n {\n \"identifier\": \"_GOSH_URL\",\n \"path\": \"exspy/misc/eels/gosh_gos.py\",\n \"snippet\": \"_GOSH_URL = f\\\"doi:{_GOSH_DOI}/Segger_Guzzinati_Kohl_1.5.0.gosh\\\"\"\n },\n {\n \"identifier\": \"_GOSH_KNOWN_HASH\",\n \"path\": \"exspy/misc/eels/gosh_gos.py\",\n \"snippet\": \"_GOSH_KNOWN_HASH = \\\"md5:7fee8891c147a4f769668403b54c529b\\\"\"\n },\n {\n \"identifier\": \"EELSSpectrum\",\n \"path\": \"exspy/signals/eels.py\",\n \"snippet\": \"class EELSSpectrum(Signal1D):\\n\\n \\\"\\\"\\\"Signal class for EELS spectra.\\\"\\\"\\\"\\n\\n _signal_type = \\\"EELS\\\"\\n _alias_signal_types = [\\\"TEM EELS\\\"]\\n\\n def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n # Attributes defaults\\n self.subshells = set()\\n self.elements = set()\\n self.edges = list()\\n if hasattr(self.metadata, \\\"Sample\\\") and hasattr(\\n self.metadata.Sample, \\\"elements\\\"\\n ):\\n self.add_elements(self.metadata.Sample.elements)\\n self.axes_manager.signal_axes[0].is_binned = True\\n self._edge_markers = {\\\"names\\\": [], \\\"lines\\\": None, \\\"texts\\\": None}\\n\\n def add_elements(self, elements, include_pre_edges=False):\\n \\\"\\\"\\\"Declare the elemental composition of the sample.\\n\\n The ionisation edges of the elements present in the current\\n energy range will be added automatically.\\n\\n Parameters\\n ----------\\n elements : tuple of strings\\n The symbol of the elements. Note this input must always be\\n in the form of a tuple. Meaning: add_elements(('C',)) will\\n work, while add_elements(('C')) will NOT work.\\n include_pre_edges : bool\\n If True, the ionization edges with an onset below the lower\\n energy limit of the SI will be included\\n\\n Examples\\n --------\\n\\n >>> s = hs.signals.EELSSpectrum(np.arange(1024))\\n >>> s.add_elements(('C', 'O'))\\n\\n Raises\\n ------\\n ValueError\\n\\n \\\"\\\"\\\"\\n if not isiterable(elements) or isinstance(elements, str):\\n raise ValueError(\\n \\\"Input must be in the form of a tuple. For example, \\\"\\n \\\"if `s` is the variable containing this EELS spectrum:\\\\n \\\"\\n \\\">>> s.add_elements(('C',))\\\\n\\\"\\n \\\"See the docstring for more information.\\\"\\n )\\n\\n for element in elements:\\n if isinstance(element, bytes):\\n element = element.decode()\\n if element in elements_db:\\n self.elements.add(element)\\n else:\\n raise ValueError(\\n \\\"%s is not a valid symbol of a chemical element\\\" % element\\n )\\n if not hasattr(self.metadata, \\\"Sample\\\"):\\n self.metadata.add_node(\\\"Sample\\\")\\n self.metadata.Sample.elements = list(self.elements)\\n if self.elements:\\n self.generate_subshells(include_pre_edges)\\n\\n def generate_subshells(self, include_pre_edges=False):\\n \\\"\\\"\\\"Calculate the subshells for the current energy range for the\\n elements present in self.elements\\n\\n Parameters\\n ----------\\n include_pre_edges : bool\\n If True, the ionization edges with an onset below the lower\\n energy limit of the SI will be included\\n\\n \\\"\\\"\\\"\\n Eaxis = self.axes_manager.signal_axes[0].axis\\n if not include_pre_edges:\\n start_energy = Eaxis[0]\\n else:\\n start_energy = 0.0\\n end_energy = Eaxis[-1]\\n for element in self.elements:\\n e_shells = list()\\n for shell in elements_db[element][\\\"Atomic_properties\\\"][\\\"Binding_energies\\\"]:\\n if shell[-1] != \\\"a\\\":\\n energy = elements_db[element][\\\"Atomic_properties\\\"][\\n \\\"Binding_energies\\\"\\n ][shell][\\\"onset_energy (eV)\\\"]\\n if start_energy <= energy <= end_energy:\\n subshell = \\\"%s_%s\\\" % (element, shell)\\n if subshell not in self.subshells:\\n self.subshells.add(\\\"%s_%s\\\" % (element, shell))\\n e_shells.append(subshell)\\n\\n def edges_at_energy(\\n self,\\n energy=\\\"interactive\\\",\\n width=10,\\n only_major=False,\\n order=\\\"closest\\\",\\n display=True,\\n toolkit=None,\\n ):\\n \\\"\\\"\\\"Show EELS edges according to an energy range selected from the\\n spectrum or within a provided energy window\\n\\n Parameters\\n ----------\\n energy : 'interactive' or float\\n If it is 'interactive', a table with edges are shown and it depends\\n on the energy range selected in the spectrum. If it is a float, a\\n table with edges are shown and it depends on the energy window\\n defined by energy +/- (width/2). The default is 'interactive'.\\n width : float\\n Width of window, in eV, around energy in which to find nearby\\n energies, i.e. a value of 10 eV (the default) means to\\n search +/- 5 eV. The default is 10.\\n only_major : bool\\n Whether to show only the major edges. The default is False.\\n order : str\\n Sort the edges, if 'closest', return in the order of energy\\n difference, if 'ascending', return in ascending order, similarly\\n for 'descending'. The default is 'closest'.\\n\\n Returns\\n -------\\n An interactive widget if energy is 'interactive', or a html-format\\n table or ASCII table, depends on the environment.\\n \\\"\\\"\\\"\\n\\n if energy == \\\"interactive\\\":\\n er = EdgesRange(self, interactive=True)\\n return er.gui(display=display, toolkit=toolkit)\\n else:\\n self.print_edges_near_energy(energy, width, only_major, order)\\n\\n @staticmethod\\n def print_edges_near_energy(\\n energy=None, width=10, only_major=False, order=\\\"closest\\\", edges=None\\n ):\\n \\\"\\\"\\\"Find and print a table of edges near a given energy that are within\\n the given energy window.\\n\\n Parameters\\n ----------\\n energy : float\\n Energy to search, in eV\\n width : float\\n Width of window, in eV, around energy in which to find nearby\\n energies, i.e. a value of 10 eV (the default) means to\\n search +/- 5 eV. The default is 10.\\n only_major : bool\\n Whether to show only the major edges. The default is False.\\n order : str\\n Sort the edges, if 'closest', return in the order of energy\\n difference, if 'ascending', return in ascending order, similarly\\n for 'descending'. The default is 'closest'.\\n edges : iterable\\n A sequence of edges, if provided, it overrides energy, width,\\n only_major and order.\\n\\n Returns\\n -------\\n A PrettyText object where its representation is ASCII in terminal and\\n html-formatted in Jupyter notebook\\n \\\"\\\"\\\"\\n\\n if edges is None and energy is not None:\\n edges = get_edges_near_energy(\\n energy=energy, width=width, only_major=only_major, order=order\\n )\\n elif edges is None and energy is None:\\n raise ValueError(\\\"Either energy or edges should be provided.\\\")\\n\\n table = PrettyTable()\\n table.field_names = [\\\"edge\\\", \\\"onset energy (eV)\\\", \\\"relevance\\\", \\\"description\\\"]\\n\\n for edge in edges:\\n element, shell = edge.split(\\\"_\\\")\\n shell_dict = elements_db[element][\\\"Atomic_properties\\\"][\\\"Binding_energies\\\"][\\n shell\\n ]\\n\\n onset = shell_dict[\\\"onset_energy (eV)\\\"]\\n relevance = shell_dict[\\\"relevance\\\"]\\n threshold = shell_dict[\\\"threshold\\\"]\\n edge_ = shell_dict[\\\"edge\\\"]\\n description = threshold + \\\". \\\" * (threshold != \\\"\\\" and edge_ != \\\"\\\") + edge_\\n\\n table.add_row([edge, onset, relevance, description])\\n\\n # this ensures the html version try its best to mimick the ASCII one\\n table.format = True\\n\\n display(table)\\n\\n def estimate_zero_loss_peak_centre(self, mask=None):\\n \\\"\\\"\\\"Estimate the position of the zero-loss peak.\\n\\n This function provides just a coarse estimation of the position\\n of the zero-loss peak centre by computing the position of the maximum\\n of the spectra. For subpixel accuracy use `estimate_shift1D`.\\n\\n Parameters\\n ----------\\n mask : Signal1D of bool data type or bool array\\n It must have signal_dimension = 0 and navigation_shape equal to the\\n navigation shape of the current signal. Where mask is True the\\n shift is not computed and set to nan.\\n\\n Returns\\n -------\\n zlpc : Signal1D subclass\\n The estimated position of the maximum of the ZLP peak.\\n\\n Notes\\n -----\\n This function only works when the zero-loss peak is the most\\n intense feature in the spectrum. If it is not in most cases\\n the spectrum can be cropped to meet this criterion.\\n Alternatively use `estimate_shift1D`.\\n\\n See Also\\n --------\\n estimate_shift1D, align_zero_loss_peak\\n\\n \\\"\\\"\\\"\\n self._check_signal_dimension_equals_one()\\n self._check_navigation_mask(mask)\\n if isinstance(mask, BaseSignal):\\n mask = mask.data\\n zlpc = self.valuemax(-1)\\n if mask is not None:\\n zlpc.data = np.where(mask, np.nan, zlpc.data)\\n zlpc.set_signal_type(\\\"\\\")\\n title = self.metadata.General.title\\n zlpc.metadata.General.title = \\\"ZLP(%s)\\\" % title\\n return zlpc\\n\\n def align_zero_loss_peak(\\n self,\\n calibrate=True,\\n also_align=[],\\n print_stats=True,\\n subpixel=True,\\n mask=None,\\n signal_range=None,\\n show_progressbar=None,\\n crop=True,\\n **kwargs,\\n ):\\n \\\"\\\"\\\"Align the zero-loss peak.\\n\\n This function first aligns the spectra using the result of\\n `estimate_zero_loss_peak_centre` which finds the maximum in the\\n given energy range, then if subpixel is True,\\n proceeds to align with subpixel accuracy using `align1D`. The offset\\n is automatically correct if `calibrate` is True.\\n\\n Parameters\\n ----------\\n calibrate : bool\\n If True, set the offset of the spectral axis so that the\\n zero-loss peak is at position zero.\\n also_align : list of signals\\n A list containing other spectra of identical dimensions to\\n align using the shifts applied to the current spectrum.\\n If `calibrate` is True, the calibration is also applied to\\n the spectra in the list.\\n print_stats : bool\\n If True, print summary statistics of the ZLP maximum before\\n the alignment.\\n subpixel : bool\\n If True, perform the alignment with subpixel accuracy\\n using cross-correlation.\\n mask : Signal1D of bool data type or bool array.\\n It must have signal_dimension = 0 and navigation_shape equal to\\n the shape of the current signal. Where mask is True the shift is\\n not computed and set to nan.\\n signal_range : tuple of integers, tuple of floats. Optional\\n Will only search for the ZLP within the signal_range. If given\\n in integers, the range will be in index values. If given floats,\\n the range will be in spectrum values. Useful if there are features\\n in the spectrum which are more intense than the ZLP.\\n Default is searching in the whole signal. Note that ROIs can be used\\n in place of a tuple.\\n %s\\n %s\\n\\n Raises\\n ------\\n NotImplementedError\\n If the signal axis is a non-uniform axis.\\n\\n Examples\\n --------\\n >>> s_ll = hs.signals.EELSSpectrum(np.zeros(1000))\\n >>> s_ll.data[100] = 100\\n >>> s_ll.align_zero_loss_peak()\\n\\n Aligning both the lowloss signal and another signal\\n\\n >>> s = hs.signals.EELSSpectrum(np.range(1000))\\n >>> s_ll.align_zero_loss_peak(also_align=[s])\\n\\n Aligning within a narrow range of the lowloss signal\\n\\n >>> s_ll.align_zero_loss_peak(signal_range=(-10.,10.))\\n\\n\\n See Also\\n --------\\n estimate_zero_loss_peak_centre, align1D, estimate_shift1D.\\n\\n Notes\\n -----\\n Any extra keyword arguments are passed to `align1D`. For\\n more information read its docstring.\\n\\n \\\"\\\"\\\"\\n\\n def substract_from_offset(value, signals):\\n # Test that axes is uniform\\n if not self.axes_manager[-1].is_uniform:\\n raise NotImplementedError(\\n \\\"Support for EELS signals with \\\"\\n \\\"non-uniform signal axes is not yet implemented.\\\"\\n )\\n if isinstance(value, da.Array):\\n value = value.compute()\\n for signal in signals:\\n signal.axes_manager[-1].offset -= value\\n signal.events.data_changed.trigger(signal)\\n\\n def estimate_zero_loss_peak_centre(s, mask, signal_range):\\n if signal_range:\\n zlpc = s.isig[\\n signal_range[0] : signal_range[1]\\n ].estimate_zero_loss_peak_centre(mask=mask)\\n else:\\n zlpc = s.estimate_zero_loss_peak_centre(mask=mask)\\n return zlpc\\n\\n zlpc = estimate_zero_loss_peak_centre(\\n self, mask=mask, signal_range=signal_range\\n )\\n\\n mean_ = np.nanmean(zlpc.data)\\n\\n if print_stats is True:\\n print(underline(\\\"Initial ZLP position statistics\\\"))\\n zlpc.print_summary_statistics()\\n\\n for signal in also_align + [self]:\\n shift_array = -zlpc.data + mean_\\n if zlpc._lazy:\\n # We must compute right now because otherwise any changes to the\\n # axes_manager of the signal later in the workflow may result in\\n # a wrong shift_array\\n shift_array = shift_array.compute()\\n signal.shift1D(shift_array, crop=crop, show_progressbar=show_progressbar)\\n\\n if calibrate is True:\\n zlpc = estimate_zero_loss_peak_centre(\\n self, mask=mask, signal_range=signal_range\\n )\\n substract_from_offset(np.nanmean(zlpc.data), also_align + [self])\\n\\n if subpixel is False:\\n return\\n\\n start, end = signal_range or (-3.0, 3.0)\\n\\n if calibrate is False:\\n start += mean_\\n end += mean_\\n\\n start = (\\n start\\n if start > self.axes_manager[-1].axis[0]\\n else self.axes_manager[-1].axis[0]\\n )\\n end = (\\n end\\n if end < self.axes_manager[-1].axis[-1]\\n else self.axes_manager[-1].axis[-1]\\n )\\n\\n if self.axes_manager.navigation_size > 1:\\n self.align1D(\\n start,\\n end,\\n also_align=also_align,\\n show_progressbar=show_progressbar,\\n mask=mask,\\n crop=crop,\\n **kwargs,\\n )\\n if calibrate is True:\\n zlpc = estimate_zero_loss_peak_centre(\\n self, mask=mask, signal_range=signal_range\\n )\\n substract_from_offset(np.nanmean(zlpc.data), also_align + [self])\\n\\n align_zero_loss_peak.__doc__ %= (SHOW_PROGRESSBAR_ARG, CROP_PARAMETER_DOC)\\n\\n def get_zero_loss_peak_mask(self, zero_loss_peak_mask_width=5.0, signal_mask=None):\\n \\\"\\\"\\\"Return boolean array with True value at the position of the zero\\n loss peak. This mask can be used to restrict operation to the signal\\n locations not marked as True (masked).\\n\\n Parameters\\n ----------\\n zero_loss_peak_mask_width: float\\n Width of the zero loss peak mask.\\n %s\\n\\n Returns\\n -------\\n bool array\\n \\\"\\\"\\\"\\n zlpc = self.estimate_zero_loss_peak_centre()\\n (signal_axis,) = self.axes_manager[self.axes_manager.signal_axes]\\n axis = signal_axis.axis\\n mini_value = zlpc.data.mean() - zero_loss_peak_mask_width / 2\\n maxi_value = zlpc.data.mean() + zero_loss_peak_mask_width / 2\\n mask = np.logical_and(mini_value <= axis, axis <= maxi_value)\\n if signal_mask is not None:\\n signal_mask = np.logical_or(mask, signal_mask)\\n else:\\n signal_mask = mask\\n return signal_mask\\n\\n get_zero_loss_peak_mask.__doc__ %= SIGNAL_MASK_ARG\\n\\n def spikes_diagnosis(\\n self,\\n signal_mask=None,\\n navigation_mask=None,\\n zero_loss_peak_mask_width=None,\\n **kwargs,\\n ):\\n if zero_loss_peak_mask_width is not None:\\n signal_mask = self.get_zero_loss_peak_mask(\\n zero_loss_peak_mask_width, signal_mask\\n )\\n super().spikes_diagnosis(\\n signal_mask=signal_mask, navigation_mask=None, **kwargs\\n )\\n\\n spikes_diagnosis.__doc__ = SPIKES_DIAGNOSIS_DOCSTRING % MASK_ZERO_LOSS_PEAK_WIDTH\\n\\n def spikes_removal_tool(\\n self,\\n signal_mask=None,\\n navigation_mask=None,\\n threshold=\\\"auto\\\",\\n zero_loss_peak_mask_width=None,\\n interactive=True,\\n display=True,\\n toolkit=None,\\n ):\\n if zero_loss_peak_mask_width is not None:\\n axis = self.axes_manager.signal_axes[0].axis\\n # check the zero_loss is in the signal\\n if (\\n axis[0] - zero_loss_peak_mask_width / 2 > 0\\n or axis[-1] + zero_loss_peak_mask_width / 2 < 0\\n ):\\n raise ValueError(\\\"The zero loss peaks isn't in the energy range.\\\")\\n signal_mask = self.get_zero_loss_peak_mask(\\n zero_loss_peak_mask_width, signal_mask\\n )\\n super().spikes_removal_tool(\\n signal_mask=signal_mask,\\n navigation_mask=navigation_mask,\\n threshold=threshold,\\n interactive=interactive,\\n display=display,\\n toolkit=toolkit,\\n )\\n\\n spikes_removal_tool.__doc__ = SPIKES_REMOVAL_TOOL_DOCSTRING % (\\n SIGNAL_MASK_ARG,\\n NAVIGATION_MASK_ARG,\\n MASK_ZERO_LOSS_PEAK_WIDTH,\\n DISPLAY_DT,\\n TOOLKIT_DT,\\n )\\n\\n def estimate_elastic_scattering_intensity(self, threshold, show_progressbar=None):\\n \\\"\\\"\\\"Rough estimation of the elastic scattering intensity by\\n truncation of a EELS low-loss spectrum.\\n\\n Parameters\\n ----------\\n threshold : {Signal1D, float, int}\\n Truncation energy to estimate the intensity of the elastic\\n scattering. The threshold can be provided as a signal of the same\\n dimension as the input spectrum navigation space containing the\\n threshold value in the energy units. Alternatively a constant\\n threshold can be specified in energy/index units by passing\\n float/int.\\n %s\\n\\n Returns\\n -------\\n I0: Signal1D\\n The elastic scattering intensity.\\n\\n See Also\\n --------\\n estimate_elastic_scattering_threshold\\n\\n \\\"\\\"\\\"\\n # TODO: Write units tests\\n self._check_signal_dimension_equals_one()\\n\\n if show_progressbar is None:\\n show_progressbar = hs.preferences.General.show_progressbar\\n\\n if isinstance(threshold, numbers.Number):\\n I0 = self.isig[:threshold].integrate1D(-1)\\n else:\\n ax = self.axes_manager.signal_axes[0]\\n # I0 = self._get_navigation_signal()\\n # I0 = I0.transpose(signal_axes=[])\\n threshold = threshold.transpose(signal_axes=[])\\n binned = ax.is_binned\\n\\n def estimating_function(data, threshold=None):\\n if np.isnan(threshold):\\n return np.nan\\n else:\\n # the object is just an array, so have to reimplement\\n # integrate1D. However can make certain assumptions, for\\n # example 1D signal and pretty much always binned. Should\\n # probably at some point be joint\\n ind = ax.value2index(threshold)\\n data = data[:ind]\\n if binned:\\n return data.sum()\\n else:\\n from scipy.integrate import simps\\n\\n axis = ax.axis[:ind]\\n return simps(y=data, x=axis)\\n\\n I0 = self.map(\\n estimating_function,\\n threshold=threshold,\\n ragged=False,\\n show_progressbar=show_progressbar,\\n inplace=False,\\n )\\n I0.metadata.General.title = self.metadata.General.title + \\\" elastic intensity\\\"\\n I0.set_signal_type(\\\"\\\")\\n if self.tmp_parameters.has_item(\\\"filename\\\"):\\n I0.tmp_parameters.filename = (\\n self.tmp_parameters.filename + \\\"_elastic_intensity\\\"\\n )\\n I0.tmp_parameters.folder = self.tmp_parameters.folder\\n I0.tmp_parameters.extension = self.tmp_parameters.extension\\n return I0\\n\\n estimate_elastic_scattering_intensity.__doc__ %= SHOW_PROGRESSBAR_ARG\\n\\n def estimate_elastic_scattering_threshold(\\n self, window=10.0, tol=None, window_length=5, polynomial_order=3, start=1.0\\n ):\\n \\\"\\\"\\\"Calculate the first inflexion point of the spectrum derivative\\n within a window.\\n\\n This method assumes that the zero-loss peak is located at position zero\\n in all the spectra. Currently it looks for an inflexion point, that can\\n be a local maximum or minimum. Therefore, to estimate the elastic\\n scattering threshold `start` + `window` must be less than the first\\n maximum for all spectra (often the bulk plasmon maximum). If there is\\n more than one inflexion point in energy the window it selects the\\n smoother one what, often, but not always, is a good choice in this\\n case.\\n\\n Parameters\\n ----------\\n window : {None, float}\\n If None, the search for the local inflexion point is performed\\n using the full energy range. A positive float will restrict\\n the search to the (0,window] energy window, where window is given\\n in the axis units. If no inflexion point is found in this\\n spectral range the window value is returned instead.\\n tol : {None, float}\\n The threshold tolerance for the derivative. If \\\"auto\\\" it is\\n automatically calculated as the minimum value that guarantees\\n finding an inflexion point in all the spectra in given energy\\n range.\\n window_length : int\\n If non zero performs order three Savitzky-Golay smoothing\\n to the data to avoid falling in local minima caused by\\n the noise. It must be an odd integer.\\n polynomial_order : int\\n Savitzky-Golay filter polynomial order.\\n start : float\\n Position from the zero-loss peak centre from where to start\\n looking for the inflexion point.\\n\\n\\n Returns\\n -------\\n\\n threshold : Signal1D\\n A Signal1D of the same dimension as the input spectrum\\n navigation space containing the estimated threshold. Where the\\n threshold couldn't be estimated the value is set to nan.\\n\\n See Also\\n --------\\n\\n estimate_elastic_scattering_intensity,align_zero_loss_peak,\\n find_peaks1D_ohaver, fourier_ratio_deconvolution.\\n\\n Notes\\n -----\\n\\n The main purpose of this method is to be used as input for\\n `estimate_elastic_scattering_intensity`. Indeed, for currently\\n achievable energy resolutions, there is not such a thing as a elastic\\n scattering threshold. Therefore, please be aware of the limitations of\\n this method when using it.\\n\\n \\\"\\\"\\\"\\n self._check_signal_dimension_equals_one()\\n # Create threshold with the same shape as the navigation dims.\\n threshold = self._get_navigation_signal().transpose(signal_axes=0)\\n\\n # Progress Bar\\n axis = self.axes_manager.signal_axes[0]\\n min_index, max_index = axis.value_range_to_indices(start, start + window)\\n if max_index < min_index + 10:\\n raise ValueError(\\\"Please select a bigger window\\\")\\n s = self.isig[min_index:max_index].deepcopy()\\n if window_length:\\n s.smooth_savitzky_golay(\\n polynomial_order=polynomial_order,\\n window_length=window_length,\\n differential_order=1,\\n )\\n else:\\n s = s.derivative(-1)\\n if tol is None:\\n tol = np.max(abs(s.data).min(axis.index_in_array))\\n saxis = s.axes_manager[-1]\\n inflexion = (abs(s.data) <= tol).argmax(saxis.index_in_array)\\n if isinstance(inflexion, da.Array):\\n inflexion = inflexion.compute()\\n threshold.data[:] = saxis.index2value(inflexion)\\n if isinstance(inflexion, np.ndarray):\\n threshold.data[inflexion == 0] = np.nan\\n else: # Single spectrum\\n if inflexion == 0:\\n threshold.data[:] = np.nan\\n del s\\n if np.isnan(threshold.data).any():\\n _logger.warning(\\n \\\"No inflexion point could be found in some positions \\\"\\n \\\"that have been marked with nans.\\\"\\n )\\n # Create spectrum image, stop and return value\\n threshold.metadata.General.title = (\\n self.metadata.General.title + \\\" elastic scattering threshold\\\"\\n )\\n if self.tmp_parameters.has_item(\\\"filename\\\"):\\n threshold.tmp_parameters.filename = (\\n self.tmp_parameters.filename + \\\"_elastic_scattering_threshold\\\"\\n )\\n threshold.tmp_parameters.folder = self.tmp_parameters.folder\\n threshold.tmp_parameters.extension = self.tmp_parameters.extension\\n threshold.set_signal_type(\\\"\\\")\\n return threshold\\n\\n def estimate_thickness(\\n self,\\n threshold=None,\\n zlp=None,\\n density=None,\\n mean_free_path=None,\\n ):\\n \\\"\\\"\\\"Estimates the thickness (relative and absolute)\\n of a sample using the log-ratio method.\\n\\n The current EELS spectrum must be a low-loss spectrum containing\\n the zero-loss peak. The hyperspectrum must be well calibrated\\n and aligned. To obtain the thickness relative to the mean free path\\n don't set the `density` and the `mean_free_path`.\\n\\n Parameters\\n ----------\\n threshold : {BaseSignal, float}, optional\\n If the zero-loss-peak is not provided, use this energy threshold\\n to roughly estimate its intensity by truncation.\\n If the threshold is constant across the dataset use a float. Otherwise,\\n provide a signal of\\n the same dimension as the input spectrum navigation space\\n containing the threshold value in the energy units.\\n zlp : BaseSignal, optional\\n If not None the zero-loss peak intensity is calculated from the ZLP\\n spectrum supplied by integration.\\n mean_free_path : float, optional\\n The mean free path of the material in nanometers.\\n If not provided, the thickness\\n is given relative to the mean free path.\\n density : float, optional\\n The density of the material in g/cm**3. This is used to estimate the mean\\n free path when the mean free path is not known and to perform the\\n angular corrections.\\n\\n Returns\\n -------\\n s : BaseSignal\\n The thickness relative to the MFP. It returns a Signal1D,\\n Signal2D or a BaseSignal, depending on the current navigation\\n dimensions.\\n\\n Notes\\n -----\\n For details see Egerton, R. Electron Energy-Loss Spectroscopy in the Electron\\n Microscope. Springer-Verlag, 2011.\\n \\\"\\\"\\\"\\n axis = self.axes_manager.signal_axes[0]\\n total_intensity = self.integrate1D(axis.index_in_array).data\\n if threshold is None and zlp is None:\\n raise ValueError(\\n \\\"Please provide one of the following keywords: \\\" \\\"`threshold`, `zlp`\\\"\\n )\\n if zlp is not None:\\n I0 = zlp.integrate1D(axis.index_in_array).data\\n else:\\n I0 = self.estimate_elastic_scattering_intensity(\\n threshold=threshold,\\n ).data\\n\\n t_over_lambda = np.log(total_intensity / I0)\\n\\n if density is not None:\\n if self._are_microscope_parameters_missing():\\n raise RuntimeError(\\n \\\"Some microscope parameters are missing. Please use the \\\"\\n \\\"`set_microscope_parameters()` method to set them. \\\"\\n \\\"If you don't know them, don't set the `density` keyword.\\\"\\n )\\n else:\\n md = self.metadata.Acquisition_instrument.TEM\\n t_over_lambda *= iMFP_angular_correction(\\n beam_energy=md.beam_energy,\\n alpha=md.convergence_angle,\\n beta=md.Detector.EELS.collection_angle,\\n density=density,\\n )\\n if mean_free_path is None:\\n mean_free_path = iMFP_Iakoubovskii(\\n electron_energy=self.metadata.Acquisition_instrument.TEM.beam_energy,\\n density=density,\\n )\\n _logger.info(f\\\"The estimated iMFP is {mean_free_path} nm\\\")\\n else:\\n _logger.warning(\\n \\\"Computing the thickness without taking into account the effect of \\\"\\n \\\"the limited collection angle, what usually leads to underestimating \\\"\\n \\\"the thickness. To perform the angular corrections you must provide \\\"\\n \\\"the density of the material.\\\"\\n )\\n\\n s = self._get_navigation_signal(data=t_over_lambda)\\n if mean_free_path is not None:\\n s.data *= mean_free_path\\n s.metadata.General.title = self.metadata.General.title + \\\" thickness (nm)\\\"\\n s.metadata.Signal.quantity = \\\"thickness (nm)\\\"\\n else:\\n _logger.warning(\\n \\\"Computing the relative thickness. To compute the absolute \\\"\\n \\\"thickness provide the `mean_free_path` and/or the `density`\\\"\\n )\\n s.metadata.General.title = (\\n self.metadata.General.title + \\\" $\\\\\\\\frac{t}{\\\\\\\\lambda}$\\\"\\n )\\n s.metadata.Signal.quantity = \\\"$\\\\\\\\frac{t}{\\\\\\\\lambda}$\\\"\\n if self.tmp_parameters.has_item(\\\"filename\\\"):\\n s.tmp_parameters.filename = self.tmp_parameters.filename + \\\"_thickness\\\"\\n s.tmp_parameters.folder = self.tmp_parameters.folder\\n s.tmp_parameters.extension = self.tmp_parameters.extension\\n s = s.transpose(signal_axes=[])\\n s.set_signal_type(\\\"\\\")\\n return s\\n\\n def fourier_log_deconvolution(self, zlp, add_zlp=False, crop=False):\\n \\\"\\\"\\\"Performs fourier-log deconvolution.\\n\\n Parameters\\n ----------\\n zlp : EELSSpectrum\\n The corresponding zero-loss peak.\\n\\n add_zlp : bool\\n If True, adds the ZLP to the deconvolved spectrum\\n crop : bool\\n If True crop the spectrum to leave out the channels that\\n have been modified to decay smoothly to zero at the sides\\n of the spectrum.\\n\\n Returns\\n -------\\n An EELSSpectrum containing the current data deconvolved.\\n\\n Raises\\n ------\\n NotImplementedError\\n If the signal axis is a non-uniform axis.\\n\\n Notes\\n -----\\n For details see: Egerton, R. Electron Energy-Loss\\n Spectroscopy in the Electron Microscope. Springer-Verlag, 2011.\\n\\n \\\"\\\"\\\"\\n self._check_signal_dimension_equals_one()\\n if not self.axes_manager.signal_axes[0].is_uniform:\\n raise NotImplementedError(\\n \\\"This operation is not yet implemented for non-uniform energy axes\\\"\\n )\\n s = self.deepcopy()\\n zlp_size = zlp.axes_manager.signal_axes[0].size\\n self_size = self.axes_manager.signal_axes[0].size\\n tapped_channels = s.hanning_taper()\\n # Conservative new size to solve the wrap-around problem\\n size = zlp_size + self_size - 1\\n # Calculate optimal FFT padding for performance\\n complex_result = zlp.data.dtype.kind == \\\"c\\\" or s.data.dtype.kind == \\\"c\\\"\\n size = optimal_fft_size(size, not complex_result)\\n\\n axis = self.axes_manager.signal_axes[0]\\n\\n z = np.fft.rfft(zlp.data, n=size, axis=axis.index_in_array)\\n j = np.fft.rfft(s.data, n=size, axis=axis.index_in_array)\\n if self._lazy or zlp._lazy:\\n j1 = z * da.log(j / z).map_blocks(np.nan_to_num)\\n else:\\n j1 = z * np.nan_to_num(np.log(j / z))\\n sdata = np.fft.irfft(j1, axis=axis.index_in_array)\\n\\n s.data = sdata[\\n s.axes_manager._get_data_slice(\\n [\\n (axis.index_in_array, slice(None, self_size)),\\n ]\\n )\\n ]\\n if add_zlp is True:\\n if self_size >= zlp_size:\\n if self._lazy:\\n _slices_before = s.axes_manager._get_data_slice(\\n [\\n (axis.index_in_array, slice(None, zlp_size)),\\n ]\\n )\\n _slices_after = s.axes_manager._get_data_slice(\\n [\\n (axis.index_in_array, slice(zlp_size, None)),\\n ]\\n )\\n s.data = da.stack(\\n (s.data[_slices_before] + zlp.data, s.data[_slices_after]),\\n axis=axis.index_in_array,\\n )\\n else:\\n s.data[\\n s.axes_manager._get_data_slice(\\n [\\n (axis.index_in_array, slice(None, zlp_size)),\\n ]\\n )\\n ] += zlp.data\\n else:\\n s.data += zlp.data[\\n s.axes_manager._get_data_slice(\\n [\\n (axis.index_in_array, slice(None, self_size)),\\n ]\\n )\\n ]\\n\\n s.metadata.General.title = (\\n s.metadata.General.title + \\\" after Fourier-log deconvolution\\\"\\n )\\n if s.tmp_parameters.has_item(\\\"filename\\\"):\\n s.tmp_parameters.filename = (\\n self.tmp_parameters.filename + \\\"_after_fourier_log_deconvolution\\\"\\n )\\n if crop is True:\\n s.crop(axis.index_in_axes_manager, None, int(-tapped_channels))\\n return s\\n\\n def fourier_ratio_deconvolution(\\n self,\\n ll,\\n fwhm=None,\\n threshold=None,\\n extrapolate_lowloss=True,\\n extrapolate_coreloss=True,\\n ):\\n \\\"\\\"\\\"Performs Fourier-ratio deconvolution.\\n\\n The core-loss should have the background removed. To reduce the noise\\n amplification the result is convolved with a Gaussian function.\\n\\n Parameters\\n ----------\\n ll: EELSSpectrum\\n The corresponding low-loss (ll) EELSSpectrum.\\n fwhm : float or None\\n Full-width half-maximum of the Gaussian function by which\\n the result of the deconvolution is convolved. It can be\\n used to select the final SNR and spectral resolution. If\\n None, the FWHM of the zero-loss peak of the low-loss is\\n estimated and used.\\n threshold : {None, float}\\n Truncation energy to estimate the intensity of the\\n elastic scattering. If None the threshold is taken as the\\n first minimum after the ZLP centre.\\n extrapolate_lowloss, extrapolate_coreloss : bool\\n If True the signals are extrapolated using a power law,\\n\\n Raises\\n ------\\n NotImplementedError\\n If the signal axis is a non-uniform axis.\\n\\n Notes\\n -----\\n For details see: Egerton, R. Electron Energy-Loss\\n Spectroscopy in the Electron Microscope. Springer-Verlag, 2011.\\n\\n \\\"\\\"\\\"\\n self._check_signal_dimension_equals_one()\\n if not self.axes_manager.signal_axes[0].is_uniform:\\n raise NotImplementedError(\\n \\\"This operation is not yet implemented for non-uniform energy axes.\\\"\\n )\\n if not ll.axes_manager.signal_axes[0].is_uniform:\\n raise NotImplementedError(\\n \\\"The low-loss energy axis is non-uniform. \\\"\\n \\\"This operation is not yet implemented for non-uniform energy axes\\\"\\n )\\n orig_cl_size = self.axes_manager.signal_axes[0].size\\n\\n if threshold is None:\\n threshold = ll.estimate_elastic_scattering_threshold()\\n\\n if extrapolate_coreloss is True:\\n cl = self.power_law_extrapolation(window_size=20, extrapolation_size=100)\\n else:\\n cl = self.deepcopy()\\n\\n if extrapolate_lowloss is True:\\n ll = ll.power_law_extrapolation(window_size=100, extrapolation_size=100)\\n else:\\n ll = ll.deepcopy()\\n\\n ll.hanning_taper()\\n cl.hanning_taper()\\n\\n ll_size = ll.axes_manager.signal_axes[0].size\\n cl_size = self.axes_manager.signal_axes[0].size\\n # Conservative new size to solve the wrap-around problem\\n size = ll_size + cl_size - 1\\n # Calculate the optimal FFT size\\n size = optimal_fft_size(size)\\n\\n axis = ll.axes_manager.signal_axes[0]\\n if fwhm is None:\\n fwhm = float(\\n ll.get_current_signal().estimate_peak_width()._get_current_data()\\n )\\n _logger.info(\\\"FWHM = %1.2f\\\" % fwhm)\\n\\n I0 = ll.estimate_elastic_scattering_intensity(threshold=threshold)\\n I0 = I0.data\\n if ll.axes_manager.navigation_size > 0:\\n I0_shape = list(I0.shape)\\n I0_shape.insert(axis.index_in_array, 1)\\n I0 = I0.reshape(I0_shape)\\n\\n from hyperspy.components1d import Gaussian\\n\\n g = Gaussian()\\n g.sigma.value = fwhm / 2.3548\\n g.A.value = 1\\n g.centre.value = 0\\n zl = g.function(\\n np.linspace(axis.offset, axis.offset + axis.scale * (size - 1), size)\\n )\\n z = np.fft.rfft(zl)\\n jk = np.fft.rfft(cl.data, n=size, axis=axis.index_in_array)\\n jl = np.fft.rfft(ll.data, n=size, axis=axis.index_in_array)\\n zshape = [\\n 1,\\n ] * len(cl.data.shape)\\n zshape[axis.index_in_array] = jk.shape[axis.index_in_array]\\n cl.data = np.fft.irfft(z.reshape(zshape) * jk / jl, axis=axis.index_in_array)\\n cl.data *= I0\\n cl.crop(-1, None, int(orig_cl_size))\\n cl.metadata.General.title = (\\n self.metadata.General.title + \\\" after Fourier-ratio deconvolution\\\"\\n )\\n if cl.tmp_parameters.has_item(\\\"filename\\\"):\\n cl.tmp_parameters.filename = (\\n self.tmp_parameters.filename + \\\"after_fourier_ratio_deconvolution\\\"\\n )\\n return cl\\n\\n def richardson_lucy_deconvolution(\\n self, psf, iterations=15, show_progressbar=None, num_workers=None\\n ):\\n \\\"\\\"\\\"1D Richardson-Lucy Poissonian deconvolution of\\n the spectrum by the given kernel.\\n\\n Parameters\\n ----------\\n psf : EELSSpectrum\\n It must have the same signal dimension as the current\\n spectrum and a spatial dimension of 0 or the same as the\\n current spectrum.\\n iterations : int\\n Number of iterations of the deconvolution. Note that\\n increasing the value will increase the noise amplification.\\n %s\\n %s\\n\\n Raises\\n ------\\n NotImplementedError\\n If the signal axis is a non-uniform axis.\\n\\n Notes\\n -----\\n For details on the algorithm see Gloter, A., A. Douiri,\\n M. Tence, and C. Colliex. “Improving Energy Resolution of\\n EELS Spectra: An Alternative to the Monochromator Solution.”\\n Ultramicroscopy 96, no. 3–4 (September 2003): 385–400.\\n\\n \\\"\\\"\\\"\\n if not self.axes_manager.signal_axes[0].is_uniform:\\n raise NotImplementedError(\\n \\\"This operation is not yet implemented for non-uniform energy axes.\\\"\\n )\\n if show_progressbar is None:\\n show_progressbar = hs.preferences.General.show_progressbar\\n self._check_signal_dimension_equals_one()\\n psf_size = psf.axes_manager.signal_axes[0].size\\n maxval = self.axes_manager.navigation_size\\n show_progressbar = show_progressbar and (maxval > 0)\\n\\n def deconv_function(signal, kernel=None, iterations=15, psf_size=None):\\n imax = kernel.argmax()\\n result = np.array(signal).copy()\\n mimax = psf_size - 1 - imax\\n for _ in range(iterations):\\n first = np.convolve(kernel, result)[imax : imax + psf_size]\\n result *= np.convolve(kernel[::-1], signal / first)[\\n mimax : mimax + psf_size\\n ]\\n return result\\n\\n ds = self.map(\\n deconv_function,\\n kernel=psf,\\n iterations=iterations,\\n psf_size=psf_size,\\n show_progressbar=show_progressbar,\\n num_workers=num_workers,\\n ragged=False,\\n inplace=False,\\n )\\n\\n ds.metadata.General.title += (\\n \\\" after Richardson-Lucy deconvolution %i iterations\\\" % iterations\\n )\\n if ds.tmp_parameters.has_item(\\\"filename\\\"):\\n ds.tmp_parameters.filename += \\\"_after_R-L_deconvolution_%iiter\\\" % iterations\\n return ds\\n\\n richardson_lucy_deconvolution.__doc__ %= (SHOW_PROGRESSBAR_ARG, NUM_WORKERS_ARG)\\n\\n def _are_microscope_parameters_missing(self, ignore_parameters=[]):\\n \\\"\\\"\\\"\\n Check if the EELS parameters necessary to calculate the GOS\\n are defined in metadata. If not, in interactive mode\\n raises an UI item to fill the values.\\n The `ignore_parameters` list can be to ignore parameters.\\n \\\"\\\"\\\"\\n must_exist = (\\n \\\"Acquisition_instrument.TEM.convergence_angle\\\",\\n \\\"Acquisition_instrument.TEM.beam_energy\\\",\\n \\\"Acquisition_instrument.TEM.Detector.EELS.collection_angle\\\",\\n )\\n missing_parameters = []\\n for item in must_exist:\\n exists = self.metadata.has_item(item)\\n if exists is False and item.split(\\\".\\\")[-1] not in ignore_parameters:\\n missing_parameters.append(item)\\n if missing_parameters:\\n _logger.info(\\\"Missing parameters {}\\\".format(missing_parameters))\\n return True\\n else:\\n return False\\n\\n def set_microscope_parameters(\\n self,\\n beam_energy=None,\\n convergence_angle=None,\\n collection_angle=None,\\n toolkit=None,\\n display=True,\\n ):\\n if set((beam_energy, convergence_angle, collection_angle)) == {None}:\\n tem_par = EELSTEMParametersUI(self)\\n return tem_par.gui(toolkit=toolkit, display=display)\\n mp = self.metadata\\n if beam_energy is not None:\\n mp.set_item(\\\"Acquisition_instrument.TEM.beam_energy\\\", beam_energy)\\n if convergence_angle is not None:\\n mp.set_item(\\n \\\"Acquisition_instrument.TEM.convergence_angle\\\", convergence_angle\\n )\\n if collection_angle is not None:\\n mp.set_item(\\n \\\"Acquisition_instrument.TEM.Detector.EELS.collection_angle\\\",\\n collection_angle,\\n )\\n\\n set_microscope_parameters.__doc__ = \\\"\\\"\\\"\\n Set the microscope parameters that are necessary to calculate\\n the GOS.\\n\\n If not all of them are defined, in interactive mode\\n raises an UI item to fill the values.\\n\\n beam_energy: float\\n The energy of the electron beam in keV.\\n convergence_angle : float\\n The microscope convergence semi-angle in mrad.\\n collection_angle : float\\n The collection semi-angle in mrad.\\n {}\\n {}\\n \\\"\\\"\\\".format(\\n TOOLKIT_DT, DISPLAY_DT\\n )\\n\\n def power_law_extrapolation(\\n self, window_size=20, extrapolation_size=1024, add_noise=False, fix_neg_r=False\\n ):\\n \\\"\\\"\\\"\\n Extrapolate the spectrum to the right using a powerlaw.\\n\\n Parameters\\n ----------\\n window_size : int\\n The number of channels from the right side of the\\n spectrum that are used to estimate the power law\\n parameters.\\n extrapolation_size : int\\n Size of the extrapolation in number of channels\\n add_noise : bool\\n If True, add poissonian noise to the extrapolated spectrum.\\n fix_neg_r : bool\\n If True, the negative values for the \\\"components.PowerLaw\\\"\\n parameter r will be flagged and the extrapolation will be\\n done with a constant zero-value.\\n\\n Returns\\n -------\\n A new spectrum, with the extrapolation.\\n\\n \\\"\\\"\\\"\\n self._check_signal_dimension_equals_one()\\n axis = self.axes_manager.signal_axes[0]\\n s = self.deepcopy()\\n s.metadata.General.title += \\\" %i channels extrapolated\\\" % extrapolation_size\\n if s.tmp_parameters.has_item(\\\"filename\\\"):\\n s.tmp_parameters.filename += (\\n \\\"_%i_channels_extrapolated\\\" % extrapolation_size\\n )\\n new_shape = list(self.data.shape)\\n new_shape[axis.index_in_array] += extrapolation_size\\n if self._lazy:\\n left_data = s.data\\n right_shape = list(self.data.shape)\\n right_shape[axis.index_in_array] = extrapolation_size\\n right_chunks = list(self.data.chunks)\\n right_chunks[axis.index_in_array] = (extrapolation_size,)\\n right_data = da.zeros(\\n shape=tuple(right_shape),\\n chunks=tuple(right_chunks),\\n dtype=self.data.dtype,\\n )\\n s.data = da.concatenate([left_data, right_data], axis=axis.index_in_array)\\n else:\\n # just old code\\n s.data = np.zeros(new_shape)\\n s.data[..., : axis.size] = self.data\\n s.get_dimensions_from_data()\\n pl = PowerLaw()\\n pl._axes_manager = self.axes_manager\\n A, r = pl.estimate_parameters(\\n s,\\n axis.index2value(axis.size - window_size),\\n axis.index2value(axis.size - 1),\\n out=True,\\n )\\n if fix_neg_r is True:\\n A = np.where(r <= 0, 0, A)\\n # If the signal is binned we need to bin the extrapolated power law\\n # what, in a first approximation, can be done by multiplying by the\\n # axis step size.\\n if self.axes_manager[-1].is_binned:\\n factor = s.axes_manager[-1].scale\\n else:\\n factor = 1\\n if self._lazy:\\n # only need new axes if the navigation dimension is not 0\\n if s.axes_manager.navigation_dimension:\\n rightslice = (..., None)\\n axisslice = (None, slice(axis.size, None))\\n else:\\n rightslice = (...,)\\n axisslice = (slice(axis.size, None),)\\n right_chunks[axis.index_in_array] = 1\\n x = da.from_array(\\n s.axes_manager.signal_axes[0].axis[axisslice],\\n chunks=(extrapolation_size,),\\n )\\n A = A[rightslice]\\n r = r[rightslice]\\n right_data = factor * A * x ** (-r)\\n s.data = da.concatenate([left_data, right_data], axis=axis.index_in_array)\\n else:\\n s.data[..., axis.size :] = (\\n factor\\n * A[..., np.newaxis]\\n * s.axes_manager.signal_axes[0].axis[np.newaxis, axis.size :]\\n ** (-r[..., np.newaxis])\\n )\\n return s\\n\\n def kramers_kronig_analysis(\\n self, zlp=None, iterations=1, n=None, t=None, delta=0.5, full_output=False\\n ):\\n r\\\"\\\"\\\"\\n Calculate the complex dielectric function from a single scattering\\n distribution (SSD) using the Kramers-Kronig relations.\\n\\n It uses the FFT method as in [1]_. The SSD is an\\n EELSSpectrum instance containing SSD low-loss EELS with no zero-loss\\n peak. The internal loop is devised to approximately subtract the\\n surface plasmon contribution supposing an unoxidized planar surface and\\n neglecting coupling between the surfaces. This method does not account\\n for retardation effects, instrumental broadening and surface plasmon\\n excitation in particles.\\n\\n Note that either refractive index or thickness are required.\\n If both are None or if both are provided an exception is raised.\\n\\n Parameters\\n ----------\\n zlp : {None, number, Signal1D}\\n ZLP intensity. It is optional (can be None) if `t` is None and `n`\\n is not None and the thickness estimation is not required. If `t`\\n is not None, the ZLP is required to perform the normalization and\\n if `t` is not None, the ZLP is required to calculate the thickness.\\n If the ZLP is the same for all spectra, the integral of the ZLP\\n can be provided as a number. Otherwise, if the ZLP intensity is not\\n the same for all spectra, it can be provided as i) a Signal1D\\n of the same dimensions as the current signal containing the ZLP\\n spectra for each location ii) a BaseSignal of signal dimension 0\\n and navigation_dimension equal to the current signal containing the\\n integrated ZLP intensity.\\n iterations : int\\n Number of the iterations for the internal loop to remove the\\n surface plasmon contribution. If 1 the surface plasmon contribution\\n is not estimated and subtracted (the default is 1).\\n n : {None, float}\\n The medium refractive index. Used for normalization of the\\n SSD to obtain the energy loss function. If given the thickness\\n is estimated and returned. It is only required when `t` is None.\\n t : {None, number, Signal1D}\\n The sample thickness in nm. Used for normalization of the SSD\\n to obtain the energy loss function. It is only required when\\n `n` is None. If the thickness is the same for all spectra it can be\\n given by a number. Otherwise, it can be provided as a BaseSignal\\n with signal dimension 0 and navigation_dimension equal to the\\n current signal.\\n delta : float\\n A small number (0.1-0.5 eV) added to the energy axis in\\n specific steps of the calculation the surface loss correction to\\n improve stability.\\n full_output : bool\\n If True, return a dictionary that contains the estimated\\n thickness if `t` is None and the estimated surface plasmon\\n excitation and the spectrum corrected from surface plasmon\\n excitations if `iterations` > 1.\\n\\n Returns\\n -------\\n eps: DielectricFunction instance\\n The complex dielectric function results,\\n\\n .. math::\\n \\\\epsilon = \\\\epsilon_1 + i*\\\\epsilon_2,\\n\\n contained in an DielectricFunction instance.\\n output: Dictionary (optional)\\n A dictionary of optional outputs with the following keys\\n\\n * ``thickness``: the estimated thickness in nm calculated by\\n normalization of the SSD (only when ``t`` is None)\\n * ``surface plasmon estimation``: the estimated surface plasmon\\n excitation (only if ``iterations`` > 1.)\\n\\n Raises\\n ------\\n ValueError\\n If both `n` and `t` are undefined (None).\\n AttributeError\\n If the beam_energy or the collection semi-angle are not defined in\\n metadata.\\n NotImplementedError\\n If the signal axis is a non-uniform axis.\\n\\n Notes\\n -----\\n This method is based in Egerton's Matlab code [1]_ with a\\n minor difference: the wrap-around problem when computing the FFTs is\\n workarounded by padding the signal instead of subtracting the\\n reflected tail.\\n\\n .. [1] Ray Egerton, \\\"Electron Energy-Loss Spectroscopy in the Electron\\n Microscope\\\", Springer-Verlag, 2011.\\n\\n \\\"\\\"\\\"\\n if not self.axes_manager.signal_axes[0].is_uniform:\\n raise NotImplementedError(\\n \\\"This operation is not yet implemented for non-uniform energy axes.\\\"\\n )\\n output = {}\\n if iterations == 1:\\n # In this case s.data is not modified so there is no need to make\\n # a deep copy.\\n s = self.isig[0.0:]\\n else:\\n s = self.isig[0.0:].deepcopy()\\n\\n sorig = self.isig[0.0:]\\n # Avoid singularity at 0\\n if s.axes_manager.signal_axes[0].axis[0] == 0:\\n s = s.isig[1:]\\n sorig = self.isig[1:]\\n\\n # Constants and units\\n me = constants.value(\\\"electron mass energy equivalent in MeV\\\") * 1e3 # keV\\n\\n # Mapped parameters\\n self._are_microscope_parameters_missing(ignore_parameters=[\\\"convergence_angle\\\"])\\n e0 = s.metadata.Acquisition_instrument.TEM.beam_energy\\n beta = s.metadata.Acquisition_instrument.TEM.Detector.EELS.collection_angle\\n\\n axis = s.axes_manager.signal_axes[0]\\n eaxis = axis.axis.copy()\\n\\n if isinstance(zlp, hyperspy.signal.BaseSignal):\\n if (\\n zlp.axes_manager.navigation_dimension\\n == self.axes_manager.navigation_dimension\\n ):\\n if zlp.axes_manager.signal_dimension == 0:\\n i0 = zlp.data\\n else:\\n i0 = zlp.integrate1D(axis.index_in_axes_manager).data\\n else:\\n raise ValueError(\\n \\\"The ZLP signal dimensions are not \\\"\\n \\\"compatible with the dimensions of the \\\"\\n \\\"low-loss signal\\\"\\n )\\n # The following prevents errors if the signal is a single spectrum\\n if len(i0) != 1:\\n i0 = i0.reshape(np.insert(i0.shape, axis.index_in_array, 1))\\n elif isinstance(zlp, numbers.Number):\\n i0 = zlp\\n else:\\n raise ValueError(\\n \\\"The zero-loss peak input is not valid, it must be\\\\\\n in the BaseSignal class or a Number.\\\"\\n )\\n\\n if isinstance(t, hyperspy.signal.BaseSignal):\\n if (\\n t.axes_manager.navigation_dimension\\n == self.axes_manager.navigation_dimension\\n ) and (t.axes_manager.signal_dimension == 0):\\n t = t.data\\n t = t.reshape(np.insert(t.shape, axis.index_in_array, 1))\\n else:\\n raise ValueError(\\n \\\"The thickness signal dimensions are not \\\"\\n \\\"compatible with the dimensions of the \\\"\\n \\\"low-loss signal\\\"\\n )\\n elif isinstance(t, np.ndarray) and t.shape and t.shape != (1,):\\n raise ValueError(\\n \\\"thickness must be a HyperSpy signal or a number,\\\" \\\" not a NumPy array.\\\"\\n )\\n\\n # Slicer to get the signal data from 0 to axis.size\\n slicer = s.axes_manager._get_data_slice(\\n [\\n (axis.index_in_array, slice(None, axis.size)),\\n ]\\n )\\n\\n # Kinetic definitions\\n ke = e0 * (1 + e0 / 2.0 / me) / (1 + e0 / me) ** 2\\n tgt = e0 * (2 * me + e0) / (me + e0)\\n rk0 = 2590 * (1 + e0 / me) * np.sqrt(2 * ke / me)\\n\\n for io in range(iterations):\\n # Calculation of the ELF by normalization of the SSD\\n # Norm(SSD) = Imag(-1/epsilon) (Energy Loss Function, ELF)\\n\\n # We start by the \\\"angular corrections\\\"\\n Im = s.data / (np.log(1 + (beta * tgt / eaxis) ** 2)) / axis.scale\\n if n is None and t is None:\\n raise ValueError(\\n \\\"The thickness and the refractive index are \\\"\\n \\\"not defined. Please provide one of them.\\\"\\n )\\n elif n is not None and t is not None:\\n raise ValueError(\\n \\\"Please provide the refractive index OR the \\\"\\n \\\"thickness information, not both\\\"\\n )\\n elif n is not None:\\n # normalize using the refractive index.\\n K = (Im / eaxis).sum(\\n axis=axis.index_in_array, keepdims=True\\n ) * axis.scale\\n K = K / (np.pi / 2) / (1 - 1.0 / n**2)\\n # K = (K / (np.pi / 2) / (1 - 1. / n ** 2)).reshape(\\n # np.insert(K.shape, axis.index_in_array, 1))\\n # Calculate the thickness only if possible and required\\n if zlp is not None and (full_output is True or iterations > 1):\\n te = 332.5 * K * ke / i0\\n if full_output is True:\\n output[\\\"thickness\\\"] = te\\n elif t is not None:\\n if zlp is None:\\n raise ValueError(\\n \\\"The ZLP must be provided when the \\\"\\n \\\"thickness is used for normalization.\\\"\\n )\\n # normalize using the thickness\\n K = t * i0 / (332.5 * ke)\\n te = t\\n Im = Im / K\\n\\n # Kramers Kronig Transform:\\n # We calculate KKT(Im(-1/epsilon))=1+Re(1/epsilon) with FFT\\n # Follows: D W Johnson 1975 J. Phys. A: Math. Gen. 8 490\\n # Use an optimal FFT size to speed up the calculation, and\\n # make it double the closest upper value to workaround the\\n # wrap-around problem.\\n esize = optimal_fft_size(2 * axis.size)\\n q = -2 * np.fft.fft(Im, esize, axis.index_in_array).imag / esize\\n\\n q[slicer] *= -1\\n q = np.fft.fft(q, axis=axis.index_in_array)\\n # Final touch, we have Re(1/eps)\\n Re = q[slicer].real + 1\\n\\n # Egerton does this to correct the wrap-around problem, but in our\\n # case this is not necessary because we compute the fft on an\\n # extended and padded spectrum to avoid this problem.\\n # Re=real(q)\\n # Tail correction\\n # vm=Re[axis.size-1]\\n # Re[:(axis.size-1)]=Re[:(axis.size-1)]+1-(0.5*vm*((axis.size-1) /\\n # (axis.size*2-arange(0,axis.size-1)))**2)\\n # Re[axis.size:]=1+(0.5*vm*((axis.size-1) /\\n # (axis.size+arange(0,axis.size)))**2)\\n\\n # Epsilon appears:\\n # We calculate the real and imaginary parts of the CDF\\n e1 = Re / (Re**2 + Im**2)\\n e2 = Im / (Re**2 + Im**2)\\n\\n if iterations > 1 and zlp is not None:\\n # Surface losses correction:\\n # Calculates the surface ELF from a vacuum border effect\\n # A simulated surface plasmon is subtracted from the ELF\\n Srfelf = 4 * e2 / ((e1 + 1) ** 2 + e2**2) - Im\\n adep = tgt / (eaxis + delta) * np.arctan(\\n beta * tgt / axis.axis\\n ) - beta / 1000.0 / (beta**2 + axis.axis**2.0 / tgt**2)\\n Srfint = 2000 * K * adep * Srfelf / rk0 / te * axis.scale\\n s.data = sorig.data - Srfint\\n _logger.debug(\\\"Iteration number: %d / %d\\\", io + 1, iterations)\\n if iterations == io + 1 and full_output is True:\\n sp = sorig._deepcopy_with_new_data(Srfint)\\n sp.metadata.General.title += (\\n \\\" estimated surface plasmon excitation.\\\"\\n )\\n output[\\\"surface plasmon estimation\\\"] = sp\\n del sp\\n del Srfint\\n\\n eps = s._deepcopy_with_new_data(e1 + e2 * 1j)\\n del s\\n eps.set_signal_type(\\\"DielectricFunction\\\")\\n eps.metadata.General.title = (\\n self.metadata.General.title + \\\"dielectric function \\\"\\n \\\"(from Kramers-Kronig analysis)\\\"\\n )\\n if eps.tmp_parameters.has_item(\\\"filename\\\"):\\n eps.tmp_parameters.filename = (\\n self.tmp_parameters.filename + \\\"_CDF_after_Kramers_Kronig_transform\\\"\\n )\\n if \\\"thickness\\\" in output:\\n # As above,prevent errors if the signal is a single spectrum\\n if len(te) != 1:\\n te = te[self.axes_manager._get_data_slice([(axis.index_in_array, 0)])]\\n thickness = eps._get_navigation_signal(data=te)\\n thickness.metadata.General.title = (\\n self.metadata.General.title + \\\" thickness \\\"\\n \\\"(calculated using Kramers-Kronig analysis)\\\"\\n )\\n output[\\\"thickness\\\"] = thickness\\n if full_output is False:\\n return eps\\n else:\\n return eps, output\\n\\n def create_model(\\n self,\\n low_loss=None,\\n auto_background=True,\\n auto_add_edges=True,\\n GOS=\\\"gosh\\\",\\n gos_file_path=None,\\n dictionary=None,\\n ):\\n \\\"\\\"\\\"Create a model for the current EELS data.\\n\\n Parameters\\n ----------\\n %s\\n\\n Returns\\n -------\\n model : :class:`~.models.eelsmodel.EELSModel` instance.\\n\\n Raises\\n ------\\n NotImplementedError\\n If the signal axis is a non-uniform axis.\\n \\\"\\\"\\\"\\n from exspy.models.eelsmodel import EELSModel\\n\\n if low_loss is not None and not self.axes_manager.signal_axes[0].is_uniform:\\n raise NotImplementedError(\\n \\\"Multiple scattering is not implemented for spectra with a \\\"\\n \\\"non-uniform energy axis. To create a model that does not \\\"\\n \\\"account for multiple-scattering do not set the `ll` keyword.\\\"\\n )\\n model = EELSModel(\\n self,\\n low_loss=low_loss,\\n auto_background=auto_background,\\n auto_add_edges=auto_add_edges,\\n GOS=GOS,\\n dictionary=dictionary,\\n )\\n return model\\n\\n create_model.__doc__ %= EELSMODEL_PARAMETERS\\n\\n def plot(self, plot_edges=False, only_edges=(\\\"Major\\\", \\\"Minor\\\"), **kwargs):\\n \\\"\\\"\\\"\\n Plot the EELS spectrum. Markers indicating the position of the\\n EELS edges can be added.\\n\\n Parameters\\n ----------\\n plot_edges : {False, True, list of string or string}\\n If True, draws on s.metadata.Sample.elements for edges.\\n Alternatively, provide a string of a single edge, or an iterable\\n containing a list of valid elements, EELS families or edges. For\\n example, an element should be 'Zr', an element edge family should\\n be 'Zr_L' or an EELS edge 'Zr_L3'.\\n only_edges : tuple of string\\n Either 'Major' or 'Minor'. Defaults to both.\\n kwargs\\n The extra keyword arguments for plot()\\n \\\"\\\"\\\"\\n\\n super().plot(**kwargs)\\n\\n if plot_edges:\\n # edges is a mapping {edge_name:edge_energy}\\n edges = self._get_edges_to_plot(plot_edges, only_edges)\\n self._plot_edge_labels(edges)\\n\\n self._plot.signal_plot.events.closed.connect(self._on_signal_plot_closing, [])\\n\\n def _on_signal_plot_closing(self):\\n self._edge_markers = {\\\"lines\\\": None, \\\"texts\\\": None, \\\"names\\\": []}\\n\\n def _get_offsets_and_segments(self, edges):\\n index = np.array([float(v) for v in edges.values()]) # dictionaries\\n segments = np.empty((len(index), 2, 2))\\n offsets = np.empty((len(index), 2))\\n for i, ind in enumerate(index):\\n segments[i] = [[ind, 1], [ind, 1.1]]\\n offsets[i] = [ind, 1.1]\\n return offsets, segments\\n\\n def _initialise_markers(self):\\n self._edge_markers[\\\"lines\\\"] = Lines(\\n segments=np.empty((0, 2, 2)),\\n transform=\\\"relative\\\",\\n color=\\\"black\\\",\\n shift=np.array([0.0, 0.19]),\\n )\\n self._edge_markers[\\\"texts\\\"] = Texts(\\n offsets=np.empty((0, 2)),\\n texts=np.empty((0,)),\\n offset_transform=\\\"relative\\\",\\n rotation=np.pi / 2,\\n horizontalalignment=\\\"left\\\",\\n verticalalignment=\\\"bottom\\\",\\n facecolor=\\\"black\\\",\\n shift=0.2,\\n )\\n for key in [\\\"lines\\\", \\\"texts\\\"]:\\n self.add_marker(self._edge_markers[key], render_figure=False)\\n\\n def _plot_edge_labels(self, edges):\\n \\\"\\\"\\\"\\n Plot the EELS edge label (vertical line segment and text box) on\\n the signal\\n\\n Parameters\\n ----------\\n edges : dictionary\\n A dictionary with the labels as keys and their energies as values.\\n For example, {'Fe_L2': 721.0, 'O_K': 532.0}\\n\\n \\\"\\\"\\\"\\n # the object is needed to connect replot method when axes_manager\\n # indices changed\\n _ = EdgesRange(self, interactive=False)\\n self._add_edge_labels(edges)\\n\\n def _get_edges_to_plot(self, plot_edges, only_edges):\\n # get the dictionary of the edge to be shown\\n extra_element_edge_family = []\\n if plot_edges is True:\\n try:\\n elements = self.metadata.Sample.elements\\n except AttributeError:\\n raise ValueError(\\n \\\"No elements defined. Add them with \\\"\\n \\\"s.add_elements, or specify elements, edge \\\"\\n \\\"families or edges directly\\\"\\n )\\n else:\\n extra_element_edge_family.extend(np.atleast_1d(plot_edges))\\n try:\\n elements = self.metadata.Sample.elements\\n except:\\n elements = []\\n\\n element_edge_family = elements + extra_element_edge_family\\n edges_dict = self._get_edges(element_edge_family, only_edges)\\n\\n return edges_dict\\n\\n def _get_edges(self, element_edge_family, only_edges):\\n # get corresponding information depending on whether it is an element\\n # a particular edge or a family of edge\\n axis_min = self.axes_manager[-1].low_value\\n axis_max = self.axes_manager[-1].high_value\\n\\n names_and_energies = {}\\n shells = [\\\"K\\\", \\\"L\\\", \\\"M\\\", \\\"N\\\", \\\"O\\\"]\\n\\n errmsg = \\\"Edge family '{}' is not supported. Supported edge family \\\" \\\"is {}.\\\"\\n for member in element_edge_family:\\n try:\\n element, ss = member.split(\\\"_\\\")\\n\\n if len(ss) == 1:\\n memtype = \\\"family\\\"\\n if ss not in shells:\\n raise AttributeError(errmsg.format(ss, shells))\\n if len(ss) == 2:\\n memtype = \\\"edge\\\"\\n if ss[0] not in shells:\\n raise AttributeError(errmsg.format(ss[0], shells))\\n except ValueError:\\n element = member\\n ss = \\\"\\\"\\n memtype = \\\"element\\\"\\n\\n try:\\n Binding_energies = elements_db[element][\\\"Atomic_properties\\\"][\\n \\\"Binding_energies\\\"\\n ]\\n except KeyError as err:\\n raise ValueError(\\\"'{}' is not a valid element\\\".format(element)) from err\\n\\n for edge in Binding_energies.keys():\\n relevance = Binding_energies[edge][\\\"relevance\\\"]\\n energy = Binding_energies[edge][\\\"onset_energy (eV)\\\"]\\n\\n isInRel = relevance in only_edges\\n isInRng = axis_min < energy < axis_max\\n isSameFamily = ss in edge\\n\\n if memtype == \\\"element\\\":\\n flag = isInRel & isInRng\\n edge_key = element + \\\"_\\\" + edge\\n elif memtype == \\\"edge\\\":\\n flag = isInRng & (edge == ss)\\n edge_key = member\\n elif memtype == \\\"family\\\":\\n flag = isInRel & isInRng & isSameFamily\\n edge_key = element + \\\"_\\\" + edge\\n\\n if flag:\\n names_and_energies[edge_key] = energy\\n\\n return names_and_energies\\n\\n def _remove_edge_labels(self, edge_names=None, render_figure=True):\\n \\\"\\\"\\\"\\n Remove EELS edges markers to the signal\\n\\n Parameters\\n ----------\\n edge_names : str, list of str or None\\n The string must be the name of edges, e. g. 'Fe_L2'.\\n If ``None`` (default), remove all edges.\\n render_figure : bool\\n If True, render the figure after adding the markers\\n \\\"\\\"\\\"\\n if edge_names is None:\\n edge_names = self._edge_markers[\\\"names\\\"]\\n if isinstance(edge_names, set):\\n # convert to list to find the index\\n edge_names = list(edge_names)\\n if not isinstance(edge_names, (list, tuple, np.ndarray)):\\n edge_names = [edge_names]\\n\\n ind = np.where(np.isin(self._edge_markers[\\\"names\\\"], edge_names))\\n\\n if self._edge_markers[\\\"lines\\\"] is not None:\\n self._edge_markers[\\\"lines\\\"].remove_items(ind)\\n if self._edge_markers[\\\"texts\\\"] is not None:\\n self._edge_markers[\\\"texts\\\"].remove_items(ind)\\n if self._edge_markers[\\\"names\\\"] is not []:\\n self._edge_markers[\\\"names\\\"] = np.delete(self._edge_markers[\\\"names\\\"], ind)\\n\\n if render_figure:\\n self._render_figure(plot=[\\\"signal_plot\\\"])\\n\\n def _add_edge_labels(self, edges, render_figure=True):\\n \\\"\\\"\\\"\\n Add EELS edges markers to the signal\\n\\n Parameters\\n ----------\\n edge_name : dictionary or set\\n If dictionary must be the name of edge as key and energy as values,\\n e.g. {'Cr_L2': 584.0}. If list or set, must the name of the edge,\\n e.g. set('Cr_L2', )\\n render_figure : bool\\n If True, render the figure after adding the markers\\n \\\"\\\"\\\"\\n if isinstance(edges, set):\\n edges_dict = {}\\n for edge in edges:\\n element, ss = edge.split(\\\"_\\\")\\n Binding_energies = elements_db[element][\\\"Atomic_properties\\\"][\\n \\\"Binding_energies\\\"\\n ]\\n edges_dict[edge] = Binding_energies[ss][\\\"onset_energy (eV)\\\"]\\n edges = edges_dict\\n\\n offsets, segments = self._get_offsets_and_segments(edges)\\n names = list(edges.keys())\\n\\n self._edge_markers[\\\"lines\\\"].add_items(segments=segments)\\n self._edge_markers[\\\"lines\\\"].update()\\n self._edge_markers[\\\"texts\\\"].add_items(offsets=offsets, texts=names)\\n self._edge_markers[\\\"lines\\\"].update()\\n self._edge_markers[\\\"names\\\"] = np.append(self._edge_markers[\\\"names\\\"], names)\\n\\n if render_figure:\\n self._render_figure(plot=[\\\"signal_plot\\\"])\\n\\n def _get_complementary_edges(self, edges, only_major=False):\\n \\\"\\\"\\\"\\n Get other edges of the same element present within the energy\\n range of the axis\\n\\n Parameters\\n ----------\\n edges : iterable\\n A sequence of strings contains edges in the format of\\n element_subshell for EELS. For example, ['Fe_L2', 'O_K']\\n only_major : bool\\n Whether to show only the major edges. The default is False.\\n\\n Returns\\n -------\\n complmt_edges : list\\n A list containing all the complementary edges of the same element\\n present within the energy range of the axis\\n \\\"\\\"\\\"\\n\\n emin = self.axes_manager[-1].low_value\\n emax = self.axes_manager[-1].high_value\\n complmt_edges = []\\n\\n elements = set()\\n for edge in edges:\\n element, _ = edge.split(\\\"_\\\")\\n elements.update([element])\\n\\n for element in elements:\\n ss_info = elements_db[element][\\\"Atomic_properties\\\"][\\\"Binding_energies\\\"]\\n\\n for subshell in ss_info:\\n sse = ss_info[subshell][\\\"onset_energy (eV)\\\"]\\n ssr = ss_info[subshell][\\\"relevance\\\"]\\n\\n if only_major:\\n if ssr != \\\"Major\\\":\\n continue\\n\\n edge = element + \\\"_\\\" + subshell\\n if (\\n (emin <= sse <= emax)\\n and (subshell[-1] != \\\"a\\\")\\n and (edge not in edges)\\n ):\\n complmt_edges.append(edge)\\n\\n return complmt_edges\\n\\n def rebin(self, new_shape=None, scale=None, crop=True, dtype=None, out=None):\\n factors = self._validate_rebin_args_and_get_factors(\\n new_shape=new_shape, scale=scale\\n )\\n m = super().rebin(\\n new_shape=new_shape, scale=scale, crop=crop, dtype=dtype, out=out\\n )\\n m = out or m\\n time_factor = np.prod(\\n [factors[axis.index_in_array] for axis in m.axes_manager.navigation_axes]\\n )\\n mdeels = m.metadata\\n m.get_dimensions_from_data()\\n if m.metadata.get_item(\\\"Acquisition_instrument.TEM.Detector.EELS\\\"):\\n mdeels = m.metadata.Acquisition_instrument.TEM.Detector.EELS\\n if \\\"dwell_time\\\" in mdeels:\\n mdeels.dwell_time *= time_factor\\n if \\\"exposure\\\" in mdeels:\\n mdeels.exposure *= time_factor\\n else:\\n _logger.info(\\n \\\"No dwell_time could be found in the metadata so \\\"\\n \\\"this has not been updated.\\\"\\n )\\n if out is None:\\n return m\\n else:\\n out.events.data_changed.trigger(obj=out)\\n return m\\n\\n rebin.__doc__ = hyperspy.signal.BaseSignal.rebin.__doc__\\n\\n def vacuum_mask(\\n self, threshold=10.0, start_energy=None, closing=True, opening=False\\n ):\\n \\\"\\\"\\\"\\n Generate mask of the vacuum region\\n\\n Parameters\\n ----------\\n threshold: float\\n For a given navigation coordinate, mean value in the energy axis\\n below which the pixel is considered as vacuum.\\n start_energy: float, None\\n Minimum energy included in the calculation of the mean intensity.\\n If None, consider only the last quarter of the spectrum to\\n calculate the mask.\\n closing: bool\\n If True, a morphological closing is applied to the mask.\\n opening: bool\\n If True, a morphological opening is applied to the mask.\\n\\n Returns\\n -------\\n mask: signal\\n The mask of the region.\\n \\\"\\\"\\\"\\n if self.axes_manager.navigation_dimension == 0:\\n raise RuntimeError(\\n \\\"Navigation dimenstion must be higher than 0 \\\"\\n \\\"to estimate a vacuum mask.\\\"\\n )\\n signal_axis = self.axes_manager.signal_axes[0]\\n if start_energy is None:\\n start_energy = 0.75 * signal_axis.high_value\\n\\n mask = self.isig[start_energy:].mean(-1) <= threshold\\n\\n from scipy.ndimage import binary_dilation, binary_erosion\\n\\n if closing:\\n mask.data = binary_dilation(mask.data, border_value=0)\\n mask.data = binary_erosion(mask.data, border_value=1)\\n if opening:\\n mask.data = binary_erosion(mask.data, border_value=1)\\n mask.data = binary_dilation(mask.data, border_value=0)\\n return mask\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import contextlib\nimport io\nimport numpy as np\nimport pooch\nimport pytest\nimport hyperspy.api as hs\nfrom unittest import mock\nfrom exspy.misc.elements import elements_db as elements\nfrom hyperspy.decorators import lazifyTestClass\nfrom exspy.misc.eels.gosh_gos import _GOSH_URL, _GOSH_KNOWN_HASH\nfrom exspy.signals import EELSSpectrum\n from exspy.models.eelsmodel import EELSModel\n from hyperspy.components1d import PowerLaw\n from hyperspy.components1d import PowerLaw"},"token_num":{"kind":"number","value":18768,"string":"18,768"},"cropped_code":{"kind":"string","value":"# -*- coding: utf-8 -*-\n# Copyright 2007-2023 The exSpy developers\n#\n# This file is part of exSpy.\n#\n# exSpy is free software: you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# exSpy is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with exSpy. If not, see <https://www.gnu.org/licenses/#GPL>.\n\n\n\n\n\n# Dask does not always work nicely with np.errstate,\n# see: https://github.com/dask/dask/issues/3245, so\n# filter out divide-by-zero warnings that only appear\n# when the test is lazy. When the test is not lazy,\n# internal use of np.errstate means the warnings never\n# appear in the first place.\n@pytest.mark.filterwarnings(\n \"ignore:invalid value encountered in subtract:RuntimeWarning\"\n)\n@pytest.mark.filterwarnings(\"ignore:divide by zero encountered in log:RuntimeWarning\")\n@lazifyTestClass\nclass TestCreateEELSModel:\n def setup_method(self, method):\n"},"all_code":{"kind":"string","value":"# -*- coding: utf-8 -*-\n# Copyright 2007-2023 The exSpy developers\n#\n# This file is part of exSpy.\n#\n# exSpy is free software: you can redistribute it and/or modify\n# it under the terms of the GNU General Public License as published by\n# the Free Software Foundation, either version 3 of the License, or\n# (at your option) any later version.\n#\n# exSpy is distributed in the hope that it will be useful,\n# but WITHOUT ANY WARRANTY; without even the implied warranty of\n# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n# GNU General Public License for more details.\n#\n# You should have received a copy of the GNU General Public License\n# along with exSpy. If not, see <https://www.gnu.org/licenses/#GPL>.\n\n\n\n\n\n# Dask does not always work nicely with np.errstate,\n# see: https://github.com/dask/dask/issues/3245, so\n# filter out divide-by-zero warnings that only appear\n# when the test is lazy. When the test is not lazy,\n# internal use of np.errstate means the warnings never\n# appear in the first place.\n@pytest.mark.filterwarnings(\n \"ignore:invalid value encountered in subtract:RuntimeWarning\"\n)\n@pytest.mark.filterwarnings(\"ignore:divide by zero encountered in log:RuntimeWarning\")\n@lazifyTestClass\nclass TestCreateEELSModel:\n def setup_method(self, method):"},"next_line":{"kind":"string","value":" s = EELSSpectrum(np.zeros(200))"},"gold_snippet_index":{"kind":"number","value":3,"string":"3"},"created_at":{"kind":"string","value":"2023-10-28 20:04:10+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5695,"cells":{"repo_name":{"kind":"string","value":"Elfenreigen/UniChest"},"file_path":{"kind":"string","value":"train.py"},"context":{"kind":"list like","value":[{"identifier":"utils","path":"factory/utils.py","snippet":"class SmoothedValue(object):\nclass MetricLogger(object):\nclass AttrDict(dict):\n def __init__(self, window_size=20, fmt=None):\n def update(self, value, n=1):\n def synchronize_between_processes(self):\n def median(self):\n def avg(self):\n def global_avg(self):\n def max(self):\n def value(self):\n def __str__(self):\n def __init__(self, delimiter=\"\\t\"):\n def update(self, **kwargs):\n def __getattr__(self, attr):\n def __str__(self):\n def global_avg(self):\n def synchronize_between_processes(self):\n def add_meter(self, name, meter):\n def log_every(self, iterable, print_freq, header=None):\n def __init__(self, *args, **kwargs):\ndef compute_acc(logits, label, reduction='mean'):\ndef compute_n_params(model, return_str=True):\ndef setup_for_distributed(is_master):\n def print(*args, **kwargs):\ndef seed_worker(worker_id):\ndef is_dist_avail_and_initialized():\ndef get_world_size():\ndef get_rank():\ndef is_main_process():\ndef save_on_master(*args, **kwargs):\ndef init_distributed_mode(args):\n MB = 1024.0 * 1024.0"},{"identifier":"create_scheduler","path":"scheduler/scheduler_factory.py","snippet":"def create_scheduler(args, optimizer):\n num_epochs = args.epochs\n\n if getattr(args, 'lr_noise', None) is not None:\n lr_noise = getattr(args, 'lr_noise')\n if isinstance(lr_noise, (list, tuple)):\n noise_range = [n * num_epochs for n in lr_noise]\n if len(noise_range) == 1:\n noise_range = noise_range[0]\n else:\n noise_range = lr_noise * num_epochs\n else:\n noise_range = None\n\n lr_scheduler = None\n if args.sched == 'cosine':\n lr_scheduler = CosineLRScheduler(\n optimizer,\n t_initial=num_epochs,\n t_mul=getattr(args, 'lr_cycle_mul', 1.),\n lr_min=args.min_lr,\n decay_rate=args.decay_rate,\n warmup_lr_init=args.warmup_lr,\n warmup_t=args.warmup_epochs,\n cycle_limit=getattr(args, 'lr_cycle_limit', 1),\n t_in_epochs=True,\n noise_range_t=noise_range,\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\n noise_std=getattr(args, 'lr_noise_std', 1.),\n noise_seed=getattr(args, 'seed', 42),\n )\n num_epochs = lr_scheduler.get_cycle_length() + args.cooldown_epochs\n elif args.sched == 'tanh':\n lr_scheduler = TanhLRScheduler(\n optimizer,\n t_initial=num_epochs,\n t_mul=getattr(args, 'lr_cycle_mul', 1.),\n lr_min=args.min_lr,\n warmup_lr_init=args.warmup_lr,\n warmup_t=args.warmup_epochs,\n cycle_limit=getattr(args, 'lr_cycle_limit', 1),\n t_in_epochs=True,\n noise_range_t=noise_range,\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\n noise_std=getattr(args, 'lr_noise_std', 1.),\n noise_seed=getattr(args, 'seed', 42),\n )\n num_epochs = lr_scheduler.get_cycle_length() + args.cooldown_epochs\n elif args.sched == 'step':\n lr_scheduler = StepLRScheduler(\n optimizer,\n decay_t=args.decay_epochs,\n decay_rate=args.decay_rate,\n warmup_lr_init=args.warmup_lr,\n warmup_t=args.warmup_epochs,\n noise_range_t=noise_range,\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\n noise_std=getattr(args, 'lr_noise_std', 1.),\n noise_seed=getattr(args, 'seed', 42),\n )\n elif args.sched == 'plateau':\n mode = 'min' if 'loss' in getattr(args, 'eval_metric', '') else 'max'\n lr_scheduler = PlateauLRScheduler(\n optimizer,\n decay_rate=args.decay_rate,\n patience_t=args.patience_epochs,\n lr_min=args.min_lr,\n mode=mode,\n warmup_lr_init=args.warmup_lr,\n warmup_t=args.warmup_epochs,\n cooldown_t=0,\n noise_range_t=noise_range,\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\n noise_std=getattr(args, 'lr_noise_std', 1.),\n noise_seed=getattr(args, 'seed', 42),\n )\n\n return lr_scheduler, num_epochs"},{"identifier":"create_optimizer","path":"optim/optim_factory.py","snippet":"def create_optimizer(args, model, image_encoder,text_encoder, filter_bias_and_bn=True):\n opt_lower = args.opt.lower()\n weight_decay = args.weight_decay\n if weight_decay and filter_bias_and_bn:\n skip = {}\n if hasattr(model, 'no_weight_decay'):\n skip = model.no_weight_decay()\n parameters = add_weight_decay(model,image_encoder,text_encoder, weight_decay, skip)\n weight_decay = 0.\n else:\n parameters = [filter(lambda p: p.requires_grad, model.parameters()),filter(lambda p: p.requires_grad, image_encoder.parameters()),filter(lambda p: p.requires_grad, text_encoder.parameters())]\n #model.parameters()\n\n # print(parameters)\n if 'fused' in opt_lower:\n assert has_apex and torch.cuda.is_available(), 'APEX and CUDA required for fused optimizers'\n\n opt_args = dict(lr=args.lr, weight_decay=weight_decay)\n if hasattr(args, 'opt_eps') and args.opt_eps is not None:\n opt_args['eps'] = args.opt_eps\n if hasattr(args, 'opt_betas') and args.opt_betas is not None:\n opt_args['betas'] = args.opt_betas\n if hasattr(args, 'opt_args') and args.opt_args is not None:\n opt_args.update(args.opt_args)\n\n opt_split = opt_lower.split('_')\n opt_lower = opt_split[-1]\n if opt_lower == 'sgd' or opt_lower == 'nesterov':\n opt_args.pop('eps', None)\n optimizer = optim.SGD(parameters, momentum=args.momentum, nesterov=True, **opt_args)\n elif opt_lower == 'momentum':\n opt_args.pop('eps', None)\n optimizer = optim.SGD(parameters, momentum=args.momentum, nesterov=False, **opt_args)\n elif opt_lower == 'adam':\n optimizer = optim.Adam(parameters, **opt_args)\n elif opt_lower == 'adamw':\n optimizer = optim.AdamW(parameters, **opt_args)\n elif opt_lower == 'nadam':\n optimizer = Nadam(parameters, **opt_args)\n elif opt_lower == 'radam':\n optimizer = RAdam(parameters, **opt_args)\n elif opt_lower == 'adamp': \n optimizer = AdamP(parameters, wd_ratio=0.01, nesterov=True, **opt_args)\n elif opt_lower == 'sgdp': \n optimizer = SGDP(parameters, momentum=args.momentum, nesterov=True, **opt_args)\n elif opt_lower == 'adadelta':\n optimizer = optim.Adadelta(parameters, **opt_args)\n elif opt_lower == 'adafactor':\n if not args.lr:\n opt_args['lr'] = None\n optimizer = Adafactor(parameters, **opt_args)\n elif opt_lower == 'adahessian':\n optimizer = Adahessian(parameters, **opt_args)\n elif opt_lower == 'rmsprop':\n optimizer = optim.RMSprop(parameters, alpha=0.9, momentum=args.momentum, **opt_args)\n elif opt_lower == 'rmsproptf':\n optimizer = RMSpropTF(parameters, alpha=0.9, momentum=args.momentum, **opt_args)\n elif opt_lower == 'novograd':\n optimizer = NovoGrad(parameters, **opt_args)\n elif opt_lower == 'nvnovograd':\n optimizer = NvNovoGrad(parameters, **opt_args)\n elif opt_lower == 'fusedsgd':\n opt_args.pop('eps', None)\n optimizer = FusedSGD(parameters, momentum=args.momentum, nesterov=True, **opt_args)\n elif opt_lower == 'fusedmomentum':\n opt_args.pop('eps', None)\n optimizer = FusedSGD(parameters, momentum=args.momentum, nesterov=False, **opt_args)\n elif opt_lower == 'fusedadam':\n optimizer = FusedAdam(parameters, adam_w_mode=False, **opt_args)\n elif opt_lower == 'fusedadamw':\n optimizer = FusedAdam(parameters, adam_w_mode=True, **opt_args)\n elif opt_lower == 'fusedlamb':\n optimizer = FusedLAMB(parameters, **opt_args)\n elif opt_lower == 'fusednovograd':\n opt_args.setdefault('betas', (0.95, 0.98))\n optimizer = FusedNovoGrad(parameters, **opt_args)\n else:\n assert False and \"Invalid optimizer\"\n raise ValueError\n\n if len(opt_split) > 1:\n if opt_split[0] == 'lookahead':\n optimizer = Lookahead(optimizer)\n\n return optimizer"},{"identifier":"train","path":"engine/train.py","snippet":"def train(model, image_encoder, text_encoder, tokenizer, data_loader, optimizer, epoch, warmup_steps, device, scheduler, args, config, writer):\n clip_loss = ClipLoss()\n ce_loss = nn.CrossEntropyLoss(ignore_index=-1)\n \n if args.add_dataset:\n ASL_loss = AsymmetricLossAdd(gamma_neg=6, gamma_pos=0, clip=0.05, disable_torch_grad_focal_loss=True)\n else:\n ASL_loss = AsymmetricLoss(gamma_neg=6, gamma_pos=0, clip=0.05, disable_torch_grad_focal_loss=True)\n\n loss_m = AverageMeter()\n loss_clip_m = AverageMeter()\n loss_ce_m = AverageMeter()\n loss_ce_image_m = AverageMeter()\n loss_ce_text_m = AverageMeter()\n batch_time_m = AverageMeter()\n data_time_m = AverageMeter()\n end = time.time()\n\n model.train() \n image_encoder.train() \n text_encoder.train()\n metric_logger = utils.MetricLogger(delimiter=\" \")\n metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\n metric_logger.add_meter('loss', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\n metric_logger.add_meter('loss_ce', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\n metric_logger.add_meter('loss_ce_image', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\n if args.use_entity_features:\n metric_logger.add_meter('loss_ce_text', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\n metric_logger.add_meter('loss_clip', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\n metric_logger.update(loss=1.0)\n metric_logger.update(lr = scheduler._get_lr(epoch)[0])\n\n header = 'Train Epoch: [{}]'.format(epoch)\n print_freq = 50 \n step_size = 100\n warmup_iterations = warmup_steps*step_size \n scalar_step = epoch*len(data_loader)\n num_batches_per_epoch = data_loader.num_batches\n sample_digits = math.ceil(math.log(data_loader.num_samples + 1, 10))\n\n for i, sample in enumerate(metric_logger.log_every(data_loader, print_freq, header)):\n if args.fourier:\n image = fourier_aug(sample['image'].to(device))\n else:\n image = sample['image'].to(device) \n label = sample['label'].long().to(device)\n\n if args.ignore_index:\n pass\n else:\n label[label==-1]=0\n entity = sample['entity']\n\n if args.add_dataset:\n dataset_label = sample['label_dataset']\n\n data_time_m.update(time.time() - end)\n\n optimizer.zero_grad()\n\n if args.add_dataset:\n text_list = ['normal', 'pleural effusion', 'opacity', 'pneumothorax', 'edema', 'atelectasis', 'tube', 'consolidation','enlarged cardiomediastinum','tip', 'pneumonia','line','cardiomegaly', 'fracture','calcification',\n 'device','engorgement', 'nodule', 'wire', 'pacemaker', 'pleural thicken', 'marking', 'scar', 'hyperinflate', 'blunt', 'collapse', 'emphysema', 'aerate', 'mass','infiltration', 'obscure', 'deformity', 'hernia',\n 'drainage', 'distention', 'shift', 'stent', 'lesion', 'hardware', 'dilation', 'aspiration',\n 'fibrosis',\t'No Finding', 'Pleural Other', 'Support Devices', 'Aortic enlargement',\n 'Clavicle fracture', 'Enlarged PA', 'ILD', 'Lung cavity', 'Lung cyst', 'Mediastinal shift',\t\n 'Nodule/Mass', 'Pulmonary fibrosis', 'Rib fracture', 'Other lesion', 'COPD', 'Lung tumor', 'Tuberculosis',\n 'Other diseases']\n\n else:\n\n text_list = ['normal', 'pleural effusion', 'opacity', 'pneumothorax', 'edema', 'atelectasis', 'tube', 'consolidation','enlarged cardiomediastinum','tip', 'pneumonia','line','cardiomegaly', 'fracture','calcification',\n 'device','engorgement', 'nodule', 'wire', 'pacemaker', 'pleural thicken', 'marking', 'scar', 'hyperinflate', 'blunt', 'collapse', 'emphysema', 'aerate', 'mass','infiltration', 'obscure', 'deformity', 'hernia',\n 'drainage', 'distention', 'shift', 'stent', 'lesion', 'hardware', 'dilation', 'aspiration']\n \n \n text_features = get_text_features(text_encoder,text_list,tokenizer,device,max_length=args.max_length)\n entity_features = get_text_features(text_encoder,entity,tokenizer,device,max_length=args.max_length)\n\n image_features,image_features_pool = image_encoder(image)\n if args.add_dataset:\n pred_class_image, moe_img = model(image_features,text_features,args)\n else:\n pred_class_image = model(image_features,text_features)\n\n\n if args.bce or args.asl:\n label = label.float()\n\n label_mask = (label != -1).squeeze()\n\n\n\n if args.add_dataset:\n loss_moe_img = moe_cl_loss(moe_img, dataset_label)\n\n if args.asl:\n pred_class_image = pred_class_image[label_mask]\n label_image = label[label_mask] \n loss_ce_image = ASL_loss(pred_class_image.view(-1,1),label_image.view(-1,1))\n elif args.bce:\n pred_class_image = pred_class_image[label_mask]\n label_image = label[label_mask] \n loss_ce_image = F.binary_cross_entropy(pred_class_image.view(-1,1),label_image.view(-1,1))\n else:\n if args.asl:\n loss_ce_image = ASL_loss(pred_class_image.view(-1,1),label.view(-1,1))\n elif args.bce:\n loss_ce_image = F.binary_cross_entropy_with_logits(pred_class_image.view(-1,1),label.view(-1,1)) \n else:\n loss_ce_image = ce_loss(pred_class_image.view(-1,2),label.view(-1)) \n\n if args.use_entity_features:\n if args.add_dataset:\n pred_class_text, moe_txt = model(entity_features.unsqueeze(1),text_features,args)\n loss_moe_txt = moe_cl_loss(moe_txt, dataset_label)\n else:\n pred_class_text = model(entity_features.unsqueeze(1),text_features)\n\n if args.add_dataset:\n if args.asl:\n pred_class_text = pred_class_text[label_mask]\n label_text = label[label_mask] \n loss_ce_text = ASL_loss(pred_class_text.view(-1,1),label_text.view(-1,1))\n \n elif args.bce:\n pred_class_text = pred_class_text[label_mask]\n label_text = label[label_mask] \n loss_ce_text = F.binary_cross_entropy(pred_class_text.view(-1,1),label_text.view(-1,1))\n\n else:\n if args.asl:\n loss_ce_text = ASL_loss(pred_class_text.view(-1,1),label.view(-1,1))\n elif args.bce:\n loss_ce_text = F.binary_cross_entropy_with_logits(pred_class_text.view(-1,1),label.view(-1,1)) \n else:\n loss_ce_text = ce_loss(pred_class_text.view(-1,2),label.view(-1))\n\n loss_ce = loss_ce_image + loss_ce_text\n if args.add_dataset:\n loss_moe = loss_moe_img + loss_moe_txt\n\n else:\n loss_ce = loss_ce_image\n if args.add_dataset:\n loss_moe = loss_moe_img\n\n\n loss_clip = clip_loss(image_features_pool,entity_features)\n if args.add_dataset:\n loss = loss_ce + loss_clip * args.loss_ratio + args.moe_ratio * loss_moe\n else:\n loss = loss_ce + loss_clip * args.loss_ratio\n \n\n loss.backward()\n optimizer.step() \n \n writer.add_scalar('loss/loss', loss, scalar_step)\n writer.add_scalar('loss/loss_ce', loss_ce, scalar_step)\n writer.add_scalar('loss/loss_ce_image', loss_ce_image, scalar_step)\n if args.use_entity_features:\n writer.add_scalar('loss/loss_ce_text', loss_ce_text, scalar_step)\n writer.add_scalar('loss/loss_clip', loss_clip, scalar_step)\n scalar_step += 1\n\n metric_logger.update(loss=loss.item())\n metric_logger.update(loss_ce=loss_ce.item())\n metric_logger.update(loss_ce_image=loss_ce_image.item())\n if args.use_entity_features:\n metric_logger.update(loss_ce_text=loss_ce_text.item())\n metric_logger.update(loss_clip=loss_clip.item())\n\n\n if epoch==0 and i%step_size==0 and i<=warmup_iterations: \n scheduler.step(i//step_size) \n metric_logger.update(lr = scheduler._get_lr(epoch)[0])\n\n batch_time_m.update(time.time() - end)\n end = time.time()\n batch_count = i + 1\n if i % 100 == 0:\n batch_size = len(image)\n num_samples = batch_count * batch_size\n samples_per_epoch = data_loader.num_samples\n percent_complete = 100.0 * batch_count / num_batches_per_epoch\n\n # NOTE loss is coarsely sampled, just master node and per log update\n loss_m.update(loss.item(), batch_size)\n loss_clip_m.update(loss_clip.item(), batch_size)\n loss_ce_m.update(loss_ce.item(), batch_size)\n loss_ce_image_m.update(loss_ce_image.item(), batch_size)\n if args.use_entity_features:\n loss_ce_text_m.update(loss_ce_text.item(), batch_size)\n logging.info(\n f\"Train Epoch: {epoch} [{num_samples:>{sample_digits}}/{samples_per_epoch} ({percent_complete:.0f}%)] \"\n f\"Loss: {loss_m.val:#.5g} ({loss_m.avg:#.4g}) \"\n f\"Loss_clip: {loss_clip_m.val:#.5g} ({loss_clip_m.avg:#.4g}) \"\n f\"Loss_ce: {loss_ce_m.val:#.5g} ({loss_ce_m.avg:#.4g}) \"\n f\"Loss_ce_image: {loss_ce_image_m.val:#.5g} ({loss_ce_image_m.avg:#.4g}) \"\n f\"Loss_ce_text: {loss_ce_text_m.val:#.5g} ({loss_ce_text_m.avg:#.4g}) \"\n f\"Data (t): {data_time_m.avg:.3f} \"\n f\"Batch (t): {batch_time_m.avg:.3f}, {batch_size/ batch_time_m.val:#g}/s \"\n f\"LR: { scheduler._get_lr(epoch)[0]:5f} \"\n )\n else:\n logging.info(\n f\"Train Epoch: {epoch} [{num_samples:>{sample_digits}}/{samples_per_epoch} ({percent_complete:.0f}%)] \"\n f\"Loss: {loss_m.val:#.5g} ({loss_m.avg:#.4g}) \"\n f\"Loss_clip: {loss_clip_m.val:#.5g} ({loss_clip_m.avg:#.4g}) \"\n f\"Loss_ce: {loss_ce_m.val:#.5g} ({loss_ce_m.avg:#.4g}) \"\n f\"Loss_ce_image: {loss_ce_image_m.val:#.5g} ({loss_ce_image_m.avg:#.4g}) \"\n f\"Data (t): {data_time_m.avg:.3f} \"\n f\"Batch (t): {batch_time_m.avg:.3f}, {batch_size/ batch_time_m.val:#g}/s \"\n f\"LR: { scheduler._get_lr(epoch)[0]:5f} \"\n )\n\n # gather the stats from all processes\n metric_logger.synchronize_between_processes()\n print(\"Averaged stats:\", metric_logger.global_avg()) \n return {k: \"{:.6f}\".format(meter.global_avg) for k, meter in metric_logger.meters.items()} #,loss_epoch.mean()"},{"identifier":"valid_on_cheXpert","path":"engine/train.py","snippet":"def valid_on_cheXpert(model,image_encoder,text_encoder,tokenizer,data_loader, epoch, device, args, config, writer):\n criterion = nn.CrossEntropyLoss()\n model.eval()\n image_encoder.eval()\n text_encoder.eval()\n text_list = ['atelectasis', 'cardiomegaly', 'consolidation', 'edema', 'pleural effusion']\n text_features = get_text_features(text_encoder,text_list,tokenizer,device,max_length=args.max_length)\n \n val_scalar_step = epoch*len(data_loader)\n val_losses = []\n\n # initialize the ground truth and output tensor\n gt = torch.FloatTensor()\n gt = gt.cuda()\n pred = torch.FloatTensor()\n pred = pred.cuda()\n\n for i, sample in enumerate(data_loader):\n image = sample['image'].to(device,non_blocking=True) \n label = sample['label'].long().to(device)\n if args.bce or args.asl:\n label = label.float()\n\n gt = torch.cat((gt, label), 0)\n with torch.no_grad():\n image_features,image_features_pool = image_encoder(image)\n \n # \n if args.add_dataset:\n pred_class,_ = model(image_features,text_features,args)#b,14,2/1\n val_loss = F.binary_cross_entropy(pred_class.view(-1,1),label.view(-1, 1))\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\n else:\n pred_class = model(image_features,text_features)#b,14,2/1\n if args.bce or args.asl:\n val_loss = F.binary_cross_entropy_with_logits(pred_class.view(-1,1),label.view(-1, 1))\n pred_class = torch.sigmoid(pred_class)\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\n else:\n val_loss = criterion(pred_class.view(-1,2),label.view(-1))\n pred_class = torch.softmax(pred_class, dim=-1)\n pred = torch.cat((pred, pred_class[:,:,1]), 0)\n \n val_losses.append(val_loss.item())\n writer.add_scalar('val_loss/loss', val_loss, val_scalar_step)\n val_scalar_step += 1\n metrics = compute_AUCs(gt, pred, n_class=5)\n AUROC_avg = metrics['mean_auc']\n avg_val_loss = np.array(val_losses).mean()\n return avg_val_loss,AUROC_avg,metrics"},{"identifier":"valid_on_chestxray14","path":"engine/train.py","snippet":"def valid_on_chestxray14(model, image_encoder, text_encoder, tokenizer, data_loader, epoch, device, args, config, writer):\n criterion = nn.CrossEntropyLoss()\n model.eval()\n image_encoder.eval()\n text_encoder.eval()\n text_list = [\"atelectasis\",\"cardiomegaly\",\"pleural effusion\",\"infiltration\",\"lung mass\",\"lung nodule\",\"pneumonia\",\"pneumothorax\",\"consolidation\",\"edema\",\"emphysema\",\"fibrosis\",\"pleural thicken\",\"hernia\"]\n text_features = get_text_features(text_encoder,text_list,tokenizer,device,max_length=args.max_length)\n \n val_scalar_step = epoch*len(data_loader)\n val_losses = []\n\n gt = torch.FloatTensor()\n gt = gt.cuda()\n pred = torch.FloatTensor()\n pred = pred.cuda()\n\n for i, sample in enumerate(data_loader):\n image = sample['image'].to(device,non_blocking=True) \n label = sample['label'].long().to(device)\n if args.bce or args.asl:\n label = label.float()\n\n gt = torch.cat((gt, label), 0)\n with torch.no_grad():\n image_features,image_features_pool = image_encoder(image)\n\n if args.add_dataset:\n pred_class,_ = model(image_features,text_features,args)#b,14,2/1\n val_loss = F.binary_cross_entropy(pred_class.view(-1,1),label.view(-1, 1))\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\n else:\n pred_class = model(image_features,text_features)#b,14,2/1\n if args.bce or args.asl:\n val_loss = F.binary_cross_entropy_with_logits(pred_class.view(-1,1),label.view(-1, 1))\n pred_class = torch.sigmoid(pred_class)\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\n else:\n val_loss = criterion(pred_class.view(-1,2),label.view(-1))\n pred_class = torch.softmax(pred_class, dim=-1)\n pred = torch.cat((pred, pred_class[:,:,1]), 0)\n\n\n\n val_losses.append(val_loss.item())\n writer.add_scalar('val_loss/loss', val_loss, val_scalar_step)\n val_scalar_step += 1\n metrics = compute_AUCs(gt, pred, n_class = 14)\n AUROC_avg = metrics['mean_auc']\n avg_val_loss = np.array(val_losses).mean()\n return avg_val_loss,AUROC_avg,metrics"},{"identifier":"CLP_clinical","path":"models/clip_tqn.py","snippet":"class CLP_clinical(nn.Module):\n def __init__(self,\n bert_model_name: str,\n embed_dim: int = 768,\n freeze_layers:Union[Tuple[int, int], int] = None):\n super().__init__()\n self.bert_model = self._get_bert_basemodel(bert_model_name=bert_model_name, freeze_layers=freeze_layers)\n self.mlp_embed = nn.Sequential(\n nn.Linear(embed_dim, embed_dim),\n nn.GELU(),\n nn.Linear(embed_dim, embed_dim)\n )\n self.embed_dim = embed_dim\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\n self.init_parameters()\n \n def init_parameters(self):\n nn.init.constant_(self.logit_scale, np.log(1 / 0.07))\n for m in self.mlp_embed:\n if isinstance(m, nn.Linear):\n nn.init.normal_(m.weight, std=self.embed_dim ** -0.5)\n\n def _get_bert_basemodel(self, bert_model_name, freeze_layers=None):#12\n try:\n print(bert_model_name)\n config = BertConfig.from_pretrained(bert_model_name, output_hidden_states=True)#bert-base-uncased\n model = AutoModel.from_pretrained(bert_model_name, config=config)#, return_dict=True)\n print(\"Text feature extractor:\", bert_model_name)\n print(\"bert encoder layers:\",len(model.encoder.layer))\n except:\n raise (\"Invalid model name. Check the config file and pass a BERT model from transformers lybrary\")\n\n if freeze_layers is not None:\n for layer_idx in freeze_layers:\n for param in list(model.encoder.layer[layer_idx].parameters()):\n param.requires_grad = False\n return model\n\n def encode_text(self, text):\n #input batch_size,token, return batch_size,dim \n output = self.bert_model(input_ids = text['input_ids'],attention_mask = text['attention_mask'] )\n last_hidden_state, pooler_output, hidden_states = output[0],output[1],output[2]\n encode_out = self.mlp_embed(pooler_output)\n # encode_out = pooler_output\n return encode_out\n \n def forward(self,text1,text2):\n text1_features = self.encode_text(text1)\n text2_features = self.encode_text(text2)\n text1_features = F.normalize(text1_features, dim=-1)\n text2_features = F.normalize(text2_features, dim=-1)\n return text1_features, text2_features, self.logit_scale.exp()"},{"identifier":"ModelRes","path":"models/clip_tqn.py","snippet":"class ModelRes(nn.Module):\n def __init__(self, res_base_model):\n super(ModelRes, self).__init__()\n self.resnet_dict = {\"resnet50\": models.resnet50(pretrained=True)}\n self.resnet = self._get_res_basemodel(res_base_model)\n\n num_ftrs = int(self.resnet.fc.in_features)\n self.res_features = nn.Sequential(*list(self.resnet.children())[:-2])\n\n self.res_l1 = nn.Linear(num_ftrs, num_ftrs)\n self.res_l2 = nn.Linear(num_ftrs, 768)\n\n def _get_res_basemodel(self, res_model_name):\n try:\n res_model = self.resnet_dict[res_model_name]\n print(\"Image feature extractor:\", res_model_name)\n return res_model\n except:\n raise (\"Invalid model name. Check the config file and pass one of: resnet18 or resnet50\")\n\n def forward(self, img):\n batch_size = img.shape[0]\n res_fea = self.res_features(img)\n\n res_fea = rearrange(res_fea,'b d n1 n2 -> b (n1 n2) d')\n h = rearrange(res_fea,'b n d -> (b n) d')\n x = self.res_l1(h)\n x = F.relu(x)\n x = self.res_l2(x)\n out_emb = rearrange(x,'(b n) d -> b n d',b=batch_size)\n out_pool = torch.mean(out_emb,dim=1)\n return out_emb,out_pool"},{"identifier":"TQN_Model","path":"models/clip_tqn.py","snippet":"class TQN_Model(nn.Module):\n def __init__(self, \n embed_dim: int = 768, \n class_num: int = 1, \n lam: list = [1, 0]\n ):\n super().__init__()\n self.d_model = embed_dim\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\n decoder_layer = TransformerDecoderLayer(self.d_model, 4, 1024,\n 0.1, 'relu',normalize_before=True)\n decoder_layerV1 = TransformerDecoderLayerV1(self.d_model, 4, 1024,\n 0.1, 'relu', True, lam)\n self.decoder_norm = nn.LayerNorm(self.d_model)\n self.decoder = TransformerDecoder(decoder_layer, 4, self.decoder_norm,\n return_intermediate=False)\n self.decoderV1 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\n return_intermediate=False)\n \n self.dropout_feas = nn.Dropout(0.1)\n\n self.mlp_head = nn.Sequential( # nn.LayerNorm(768),\n nn.Linear(embed_dim, class_num)\n )\n self.apply(self._init_weights)\n \n @staticmethod\n def _init_weights(module):\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n\n elif isinstance(module, nn.MultiheadAttention):\n module.in_proj_weight.data.normal_(mean=0.0, std=0.02)\n module.out_proj.weight.data.normal_(mean=0.0, std=0.02)\n\n elif isinstance(module, nn.Embedding):\n module.weight.data.normal_(mean=0.0, std=0.02)\n if module.padding_idx is not None:\n module.weight.data[module.padding_idx].zero_()\n \n def forward(self, image_features, text_features):\n\n batch_size = image_features.shape[0]\n image_features = image_features.transpose(0,1)\n text_features = text_features.unsqueeze(1).repeat(1, batch_size, 1)\n image_features = self.decoder_norm(image_features)\n text_features = self.decoder_norm(text_features)\n \n image_features_pool = torch.mean(image_features,dim=0).unsqueeze(0)\n features = self.decoderV1(text_features, image_features, image_features_pool,\n memory_key_padding_mask=None, pos=None, query_pos=None) \n \n features = self.dropout_feas(features).transpose(0,1) #b,embed_dim\n out = self.mlp_head(features) #(batch_size, query_num)\n return out"},{"identifier":"TQN_Model_Add","path":"models/clip_tqn.py","snippet":"class TQN_Model_Add(nn.Module):\n def __init__(self, \n embed_dim: int = 768, \n class_num: int = 1, \n gate_num: int = 3,\n high_dim: int = 32,\n lam: list = [1, 0]\n ):\n super().__init__()\n self.d_model = embed_dim\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\n decoder_layer = TransformerDecoderLayer(self.d_model, 4, 1024,\n 0.1, 'relu',normalize_before=True)\n decoder_layerV1 = TransformerDecoderLayerV1(self.d_model, 4, 1024,\n 0.1, 'relu', True, lam)\n self.decoder_norm = nn.LayerNorm(self.d_model)\n self.decoder = TransformerDecoder(decoder_layer, 4, self.decoder_norm,\n return_intermediate=False)\n self.decoderV1 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\n return_intermediate=False)\n \n self.decoderV1_1 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\n return_intermediate=False)\n self.decoderV1_2 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\n return_intermediate=False)\n self.decoderV1_3 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\n return_intermediate=False)\n\n self.dropout_feas = nn.Dropout(0.1)\n\n self.mlp_head = nn.Sequential( # nn.LayerNorm(768),\n nn.Linear(embed_dim, class_num)\n )\n self.mlp_head_1 = nn.Sequential( # nn.LayerNorm(768),\n nn.Linear(embed_dim, class_num)\n )\n self.mlp_head_2 = nn.Sequential( # nn.LayerNorm(768),\n nn.Linear(embed_dim, class_num)\n )\n self.mlp_head_3 = nn.Sequential( # nn.LayerNorm(768),\n nn.Linear(embed_dim, class_num)\n ) \n \n self.gate_head = nn.Sequential(\n nn.Linear(embed_dim, gate_num)\n )\n self.cl_head = nn.Sequential(\n nn.Linear(gate_num, high_dim)\n )\n\n self.apply(self._init_weights)\n \n @staticmethod\n def _init_weights(module):\n if isinstance(module, nn.Linear):\n module.weight.data.normal_(mean=0.0, std=0.02)\n\n elif isinstance(module, nn.MultiheadAttention):\n module.in_proj_weight.data.normal_(mean=0.0, std=0.02)\n module.out_proj.weight.data.normal_(mean=0.0, std=0.02)\n\n elif isinstance(module, nn.Embedding):\n module.weight.data.normal_(mean=0.0, std=0.02)\n if module.padding_idx is not None:\n module.weight.data[module.padding_idx].zero_()\n \n def forward(self, image_features, text_features, args):\n\n batch_size = image_features.shape[0]\n image_features = image_features.transpose(0,1)\n text_features = text_features.unsqueeze(1).repeat(1, batch_size, 1)\n image_features = self.decoder_norm(image_features)\n text_features = self.decoder_norm(text_features)\n \n image_features_pool = torch.mean(image_features,dim=0).unsqueeze(0)\n features = self.decoderV1(text_features, image_features, image_features_pool,\n memory_key_padding_mask=None, pos=None, query_pos=None)\n gate_weight = self.gate_head(image_features_pool.squeeze(0)) \n \n features = self.dropout_feas(features).transpose(0,1) #b,embed_dim\n \n \n if args.finetune:\n features_1 = self.decoderV1_1(text_features, image_features, image_features_pool,\n memory_key_padding_mask=None, pos=None, query_pos=None)\n features_1 = self.dropout_feas(features_1).transpose(0,1) \n features_2 = self.decoderV1_2(text_features, image_features, image_features_pool,\n memory_key_padding_mask=None, pos=None, query_pos=None)\n features_2 = self.dropout_feas(features_2).transpose(0,1) \n features_3 = self.decoderV1_3(text_features, image_features, image_features_pool,\n memory_key_padding_mask=None, pos=None, query_pos=None)\n features_3 = self.dropout_feas(features_3).transpose(0,1) \n \n out_1 = torch.sigmoid(self.mlp_head_1(features_1))\n out_2 = torch.sigmoid(self.mlp_head_2(features_2))\n out_3 = torch.sigmoid(self.mlp_head_3(features_3))\n\n\n out = self.mlp_head(features)\n \n gate_weight = torch.softmax(gate_weight, dim=1)\n out = torch.sigmoid(out)\n\n high_dimension = self.cl_head(gate_weight)\n out_bias = gate_weight[:,0].unsqueeze(1).unsqueeze(2) * out_1 + gate_weight[:,1].unsqueeze(1).unsqueeze(2) * out_2 + gate_weight[:,2].unsqueeze(1).unsqueeze(2) * out_3\n\n out = args.main_ratio * out + args.bias_ratio * out_bias\n\n return out, high_dimension"},{"identifier":"ModelDense","path":"models/clip_tqn.py","snippet":"class ModelDense(nn.Module):\n def __init__(self, dense_base_model):\n super(ModelDense, self).__init__()\n \n self.densenet_dict = {\"densenet121\": models.densenet121(pretrained=True)}#,\n # \"densenet161\": models.densenet161(pretrained=True)}\n self.densenet = self._get_dense_basemodel(dense_base_model)\n num_ftrs = int(self.densenet.classifier.in_features)\n self.dense_features = self.densenet.features\n self.dense_l1 = nn.Linear(num_ftrs, num_ftrs)\n self.dense_l2 = nn.Linear(num_ftrs, 768)\n\n def _get_dense_basemodel(self, dense_base_model):\n try:\n dense_model = self.densenet_dict[dense_base_model]\n print(\"Image feature extractor:\", dense_base_model)\n return dense_model\n except:\n raise (\"Invalid model name. Check the config file and pass one of: densenet121 or densenet161\")\n\n def forward(self, img):\n batch_size = img.shape[0]\n dense_fea = self.dense_features(img)#N, 1024, 7,7\n dense_fea = rearrange(dense_fea,'b d n1 n2 -> b (n1 n2) d')\n h = rearrange(dense_fea,'b n d -> (b n) d')\n x = self.dense_l1(h)\n x = F.relu(x)\n x = self.dense_l2(x)\n out_emb = rearrange(x,'(b n) d -> b n d',b=batch_size)\n out_pool = torch.mean(out_emb,dim=1)\n return out_emb,out_pool"},{"identifier":"CLP_clinical2","path":"models/clip_tqn.py","snippet":"class CLP_clinical2(nn.Module):\n def __init__(self,\n bert_model_name: str,\n embed_dim: int = 768,\n freeze_layers:Union[Tuple[int, int], int] = None):\n super().__init__()\n self.bert_model = self._get_bert_basemodel(bert_model_name=bert_model_name, freeze_layers=freeze_layers)\n\n\n def _get_bert_basemodel(self, bert_model_name, freeze_layers=None):#12\n try:\n print(bert_model_name)\n model = AutoModel.from_pretrained(bert_model_name)\n print(\"Text feature extractor:\", bert_model_name)\n print(\"bert encoder layers:\",len(model.encoder.layer))\n except:\n raise (\"Invalid model name. Check the config file and pass a BERT model from transformers lybrary\")\n\n if freeze_layers is not None:\n for layer_idx in freeze_layers:\n for param in list(model.encoder.layer[layer_idx].parameters()):\n param.requires_grad = False\n return model\n\n def encode_text(self, text):\n output = self.bert_model(input_ids = text['input_ids'],attention_mask = text['attention_mask'] )\n encode_out = output.last_hidden_state[:,0,:]\n return encode_out\n \n def forward(self,text1,text2):\n text1_features = self.encode_text(text1)\n text2_features = self.encode_text(text2)\n text1_features = F.normalize(text1_features, dim=-1)\n text2_features = F.normalize(text2_features, dim=-1)\n return text1_features, text2_features, self.logit_scale.exp()"},{"identifier":"BertTokenizer","path":"models/tokenization_bert.py","snippet":"class BertTokenizer(PreTrainedTokenizer):\n r\"\"\"\n Construct a BERT tokenizer. Based on WordPiece.\n This tokenizer inherits from :class:`~transformers.PreTrainedTokenizer` which contains most of the main methods.\n Users should refer to this superclass for more information regarding those methods.\n Args:\n vocab_file (:obj:`str`):\n File containing the vocabulary.\n do_lower_case (:obj:`bool`, `optional`, defaults to :obj:`True`):\n Whether or not to lowercase the input when tokenizing.\n do_basic_tokenize (:obj:`bool`, `optional`, defaults to :obj:`True`):\n Whether or not to do basic tokenization before WordPiece.\n never_split (:obj:`Iterable`, `optional`):\n Collection of tokens which will never be split during tokenization. Only has an effect when\n :obj:`do_basic_tokenize=True`\n unk_token (:obj:`str`, `optional`, defaults to :obj:`\"[UNK]\"`):\n The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this\n token instead.\n sep_token (:obj:`str`, `optional`, defaults to :obj:`\"[SEP]\"`):\n The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for\n sequence classification or for a text and a question for question answering. It is also used as the last\n token of a sequence built with special tokens.\n pad_token (:obj:`str`, `optional`, defaults to :obj:`\"[PAD]\"`):\n The token used for padding, for example when batching sequences of different lengths.\n cls_token (:obj:`str`, `optional`, defaults to :obj:`\"[CLS]\"`):\n The classifier token which is used when doing sequence classification (classification of the whole sequence\n instead of per-token classification). It is the first token of the sequence when built with special tokens.\n mask_token (:obj:`str`, `optional`, defaults to :obj:`\"[MASK]\"`):\n The token used for masking values. This is the token used when training this model with masked language\n modeling. This is the token which the model will try to predict.\n tokenize_chinese_chars (:obj:`bool`, `optional`, defaults to :obj:`True`):\n Whether or not to tokenize Chinese characters.\n This should likely be deactivated for Japanese (see this `issue\n <https://github.com/huggingface/transformers/issues/328>`__).\n strip_accents: (:obj:`bool`, `optional`):\n Whether or not to strip all accents. If this option is not specified, then it will be determined by the\n value for :obj:`lowercase` (as in the original BERT).\n \"\"\"\n\n vocab_files_names = VOCAB_FILES_NAMES\n pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP\n pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION\n max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES\n\n def __init__(\n self,\n vocab_file,\n do_lower_case=True,\n do_basic_tokenize=True,\n never_split=None,\n unk_token=\"[UNK]\",\n sep_token=\"[SEP]\",\n pad_token=\"[PAD]\",\n cls_token=\"[CLS]\",\n mask_token=\"[MASK]\",\n tokenize_chinese_chars=True,\n strip_accents=None,\n **kwargs\n ):\n super().__init__(\n do_lower_case=do_lower_case,\n do_basic_tokenize=do_basic_tokenize,\n never_split=never_split,\n unk_token=unk_token,\n sep_token=sep_token,\n pad_token=pad_token,\n cls_token=cls_token,\n mask_token=mask_token,\n tokenize_chinese_chars=tokenize_chinese_chars,\n strip_accents=strip_accents,\n **kwargs,\n )\n\n if not os.path.isfile(vocab_file):\n raise ValueError(\n \"Can't find a vocabulary file at path '{}'. To load the vocabulary from a Google pretrained \"\n \"model use `tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`\".format(vocab_file)\n )\n self.vocab = load_vocab(vocab_file)\n self.ids_to_tokens = collections.OrderedDict([(ids, tok) for tok, ids in self.vocab.items()])\n self.do_basic_tokenize = do_basic_tokenize\n if do_basic_tokenize:\n self.basic_tokenizer = BasicTokenizer(\n do_lower_case=do_lower_case,\n never_split=never_split,\n tokenize_chinese_chars=tokenize_chinese_chars,\n strip_accents=strip_accents,\n )\n self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab, unk_token=self.unk_token)\n\n @property\n def do_lower_case(self):\n return self.basic_tokenizer.do_lower_case\n\n @property\n def vocab_size(self):\n return len(self.vocab)\n\n def get_vocab(self):\n return dict(self.vocab, **self.added_tokens_encoder)\n\n def _tokenize(self, text):\n split_tokens = []\n if self.do_basic_tokenize:\n for token in self.basic_tokenizer.tokenize(text, never_split=self.all_special_tokens):\n\n # If the token is part of the never_split set\n if token in self.basic_tokenizer.never_split:\n split_tokens.append(token)\n else:\n split_tokens += self.wordpiece_tokenizer.tokenize(token)\n else:\n split_tokens = self.wordpiece_tokenizer.tokenize(text)\n return split_tokens\n\n def _convert_token_to_id(self, token):\n \"\"\" Converts a token (str) in an id using the vocab. \"\"\"\n return self.vocab.get(token, self.vocab.get(self.unk_token))\n\n def _convert_id_to_token(self, index):\n \"\"\"Converts an index (integer) in a token (str) using the vocab.\"\"\"\n return self.ids_to_tokens.get(index, self.unk_token)\n\n def convert_tokens_to_string(self, tokens):\n \"\"\" Converts a sequence of tokens (string) in a single string. \"\"\"\n out_string = \" \".join(tokens).replace(\" ##\", \"\").strip()\n return out_string\n\n def build_inputs_with_special_tokens(\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\n ) -> List[int]:\n \"\"\"\n Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and\n adding special tokens. A BERT sequence has the following format:\n - single sequence: ``[CLS] X ``\n - pair of sequences: ``[CLS] A [SEP] B [SEP]``\n Args:\n token_ids_0 (:obj:`List[int]`):\n List of IDs to which the special tokens will be added.\n token_ids_1 (:obj:`List[int]`, `optional`):\n Optional second list of IDs for sequence pairs.\n Returns:\n :obj:`List[int]`: List of `input IDs <../glossary.html#input-ids>`__ with the appropriate special tokens.\n \"\"\"\n if token_ids_1 is None:\n return [self.cls_token_id] + token_ids_0\n cls = [self.cls_token_id]\n sep = [self.sep_token_id]\n return cls + token_ids_0 + sep + token_ids_1 + sep\n\n def get_special_tokens_mask(\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False\n ) -> List[int]:\n \"\"\"\n Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding\n special tokens using the tokenizer ``prepare_for_model`` method.\n Args:\n token_ids_0 (:obj:`List[int]`):\n List of IDs.\n token_ids_1 (:obj:`List[int]`, `optional`):\n Optional second list of IDs for sequence pairs.\n already_has_special_tokens (:obj:`bool`, `optional`, defaults to :obj:`False`):\n Whether or not the token list is already formatted with special tokens for the model.\n Returns:\n :obj:`List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.\n \"\"\"\n\n if already_has_special_tokens:\n if token_ids_1 is not None:\n raise ValueError(\n \"You should not supply a second sequence if the provided sequence of \"\n \"ids is already formatted with special tokens for the model.\"\n )\n return list(map(lambda x: 1 if x in [self.sep_token_id, self.cls_token_id] else 0, token_ids_0))\n\n if token_ids_1 is not None:\n return [1] + ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1)) + [1]\n return [1] + ([0] * len(token_ids_0)) + [1]\n\n def create_token_type_ids_from_sequences(\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\n ) -> List[int]:\n \"\"\"\n Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence\n pair mask has the following format:\n ::\n 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1\n | first sequence | second sequence |\n If :obj:`token_ids_1` is :obj:`None`, this method only returns the first portion of the mask (0s).\n Args:\n token_ids_0 (:obj:`List[int]`):\n List of IDs.\n token_ids_1 (:obj:`List[int]`, `optional`):\n Optional second list of IDs for sequence pairs.\n Returns:\n :obj:`List[int]`: List of `token type IDs <../glossary.html#token-type-ids>`_ according to the given\n sequence(s).\n \"\"\"\n sep = [self.sep_token_id]\n cls = [self.cls_token_id]\n if token_ids_1 is None:\n return len(cls + token_ids_0 + sep) * [0]\n return len(cls + token_ids_0 + sep) * [0] + len(token_ids_1 + sep) * [1]\n\n def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:\n index = 0\n if os.path.isdir(save_directory):\n vocab_file = os.path.join(\n save_directory, (filename_prefix + \"-\" if filename_prefix else \"\") + VOCAB_FILES_NAMES[\"vocab_file\"]\n )\n else:\n vocab_file = (filename_prefix + \"-\" if filename_prefix else \"\") + save_directory\n with open(vocab_file, \"w\", encoding=\"utf-8\") as writer:\n for token, token_index in sorted(self.vocab.items(), key=lambda kv: kv[1]):\n if index != token_index:\n logger.warning(\n \"Saving vocabulary to {}: vocabulary indices are not consecutive.\"\n \" Please check that the vocabulary is not corrupted!\".format(vocab_file)\n )\n index = token_index\n writer.write(token + \"\\n\")\n index += 1\n return (vocab_file,)"},{"identifier":"MIMIC_Dataset","path":"dataset/dataset_entity.py","snippet":"class MIMIC_Dataset(Dataset):\n def __init__(self, json_path, csv_path, sty_path,image_res,args):\n self.json_info = json.load(open(json_path,'r'))\n data_info = pd.read_csv(csv_path)\n self.img_path_list = np.asarray(data_info.iloc[:,0])\n self.class_list = np.asarray(data_info.iloc[:,1:])#40 class for fine-grained query list\n sty_info = pd.read_csv(sty_path)\n self.sty_dict_info = self.csv_to_dict(sty_info)\n\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n\n if args.colourjitter:\n self.transform = transforms.Compose([ \n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\n transforms.RandomHorizontalFlip(),\n\n transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.4),\n transforms.RandomGrayscale(),\n\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \n transforms.ToTensor(),\n normalize,\n ])\n\n else:\n self.transform = transforms.Compose([ \n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\n transforms.RandomHorizontalFlip(),\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \n transforms.ToTensor(),\n normalize,\n ]) \n\n \n def csv_to_dict(self,sty_info):\n tui_list = sty_info.iloc[:,0]\n sty_list = sty_info.iloc[:,1]\n sty_dict = defaultdict(list)\n for idx in tqdm(range(len(tui_list))):\n tui_idx = tui_list[idx]\n sty_idx = sty_list[idx]\n sty_dict[tui_idx] = sty_idx\n return sty_dict\n \n def __len__(self):\n return len(self.img_path_list)\n \n def __getitem__(self, index):\n img_path = self.img_path_list[index].replace(\"/nvme/zhangruipeng/zhangxiaoman/dataset/MIMIC-CXR-DCM/files\", '/remote-home/share/medical/public/MIMIC-CXR-JPG/MIMIC-CXR/small/files')\n class_label = self.class_list[index] \n\n # index_transit = np.load(\"/remote-home/tianjiedai/KAD/R1_CLIP_LR/A1_DATA/small/index0626.npy\")\n # new_index_json = index_transit[index]\n # entities = self.json_info[new_index_json]['entities']\n # captions = self.json_info[new_index_json]['caption']\n \n entities = self.json_info[index]['entities']\n captions = self.json_info[index]['caption']\n\n\n if len(entities) != 0:\n caption_list = ''\n entity_details = ''\n for entity in entities:\n sub_caption = entity['caption']\n sub_entities = entity['entity']#搞错了 还不是list\n sub_entity_details = ''\n for sub_entity in sub_entities:\n try:\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \n except:\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \n entity_details = entity_details + sub_entity_details + ' [SEP] '\n caption_list = caption_list + sub_caption + ' [SEP] '\n else:\n caption_list = ''\n entity_details = ''\n for sub_caption in captions:\n caption_list = caption_list + sub_caption + ' [SEP] '\n entity_details = caption_list\n \n # img = open_jpg(img_path).convert('RGB') \n img = Image.open(img_path).convert('RGB') \n image = self.transform(img)\n return {\n \"image\": image,\n \"label\": class_label,\n \"caption\": caption_list,\n \"entity\": entity_details\n }"},{"identifier":"Mergetrain_Dataset","path":"dataset/dataset_entity.py","snippet":"class Mergetrain_Dataset(Dataset):\n def __init__(self, json_path, csv_path, sty_path,image_res,args):\n self.json_info = json.load(open(json_path,'r'))\n data_info = pd.read_csv(csv_path)\n self.img_path_list = np.asarray(data_info.iloc[:,0])\n self.class_list = np.asarray(data_info.iloc[:,2:])#60 class for fine-grained query list\n self.label_dataset_list = np.asarray(data_info.iloc[:,1])\n\n sty_info = pd.read_csv(sty_path)\n self.sty_dict_info = self.csv_to_dict(sty_info)\n\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n\n if args.colourjitter:\n self.transform = transforms.Compose([ \n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\n transforms.RandomHorizontalFlip(),\n\n transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.4),\n transforms.RandomGrayscale(),\n\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \n transforms.ToTensor(),\n normalize,\n ])\n\n else:\n self.transform = transforms.Compose([ \n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\n transforms.RandomHorizontalFlip(),\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \n transforms.ToTensor(),\n normalize,\n ]) \n\n \n def csv_to_dict(self,sty_info):\n tui_list = sty_info.iloc[:,0]\n sty_list = sty_info.iloc[:,1]\n sty_dict = defaultdict(list)\n for idx in tqdm(range(len(tui_list))):\n tui_idx = tui_list[idx]\n sty_idx = sty_list[idx]\n sty_dict[tui_idx] = sty_idx\n return sty_dict\n \n def __len__(self):\n return len(self.img_path_list)\n \n def __getitem__(self, index):\n\n if self.label_dataset_list[index] == 0:\n img_path = self.img_path_list[index].replace(\"/nvme/zhangruipeng/zhangxiaoman/dataset/MIMIC-CXR-DCM/files\", '/remote-home/share/medical/public/MIMIC-CXR-JPG/MIMIC-CXR/small/files')\n class_label = self.class_list[index] \n\n # index_transit = np.load(\"/remote-home/tianjiedai/KAD/R1_CLIP_LR/A1_DATA/small/index0626.npy\")\n # new_index_json = index_transit[index]\n # entities = self.json_info[new_index_json]['entities']\n # captions = self.json_info[new_index_json]['caption']\n \n entities = self.json_info[index]['entities']\n captions = self.json_info[index]['caption']\n\n\n if len(entities) != 0:\n caption_list = ''\n entity_details = ''\n for entity in entities:\n sub_caption = entity['caption']\n sub_entities = entity['entity']#搞错了 还不是list\n sub_entity_details = ''\n for sub_entity in sub_entities:\n try:\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \n except:\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \n entity_details = entity_details + sub_entity_details + ' [SEP] '\n caption_list = caption_list + sub_caption + ' [SEP] '\n else:\n caption_list = ''\n entity_details = ''\n for sub_caption in captions:\n caption_list = caption_list + sub_caption + ' [SEP] '\n entity_details = caption_list\n \n # img = open_jpg(img_path).convert('RGB') \n # img = Image.open(img_path).convert('RGB') \n # image = self.transform(img)\n # return {\n # \"image\": image,\n # \"label\": class_label,\n # \"caption\": caption_list,\n # \"entity\": entity_details\n # }\n \n else:\n img_path = self.img_path_list[index]\n class_label = self.class_list[index] \n caption_list = ''\n head = ['normal', 'pleural effusion', 'opacity', 'pneumothorax', 'edema', 'atelectasis', 'tube', 'consolidation','enlarged cardiomediastinum','tip', 'pneumonia','line','cardiomegaly', 'fracture','calcification',\n 'device','engorgement', 'nodule', 'wire', 'pacemaker', 'pleural thicken', 'marking', 'scar', 'hyperinflate', 'blunt', 'collapse', 'emphysema', 'aerate', 'mass','infiltration', 'obscure', 'deformity', 'hernia',\n 'drainage', 'distention', 'shift', 'stent', 'lesion', 'hardware', 'dilation', 'aspiration',\n 'fibrosis',\t'No Finding', 'Pleural Other', 'Support Devices', 'Aortic enlargement',\n 'Clavicle fracture', 'Enlarged PA', 'ILD', 'Lung cavity', 'Lung cyst', 'Mediastinal shift',\t\n 'Nodule/Mass', 'Pulmonary fibrosis', 'Rib fracture', 'Other lesion', 'COPD', 'Lung tumor', 'Tuberculosis',\n 'Other diseases']\n index_positive = np.where(class_label == 1)\n entity = np.array(head)[index_positive]\n entity_details = ''\n for sub_entity in entity:\n entity_details = entity_details + sub_entity + ' [SEP] '\n\n img = Image.open(img_path).convert('RGB') \n image = self.transform(img)\n label_dataset = self.label_dataset_list[index]\n\n return {\n \"image\": image,\n \"label\": class_label,\n \"label_dataset\": label_dataset,\n \"caption\": caption_list,\n \"entity\": entity_details\n }"},{"identifier":"Chestxray14_Dataset","path":"dataset/dataset_entity.py","snippet":"class Chestxray14_Dataset(Dataset):\n def __init__(self, csv_path,image_res):\n data_info = pd.read_csv(csv_path)\n self.img_path_list = np.asarray(data_info.iloc[:,0])\n self.class_list = np.asarray(data_info.iloc[:,3:])\n\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n self.transform = transforms.Compose([ \n transforms.Resize(image_res, interpolation=transforms.InterpolationMode.BICUBIC),\n transforms.ToTensor(),\n normalize,\n ])\n \n def __getitem__(self, index):\n img_path = self.img_path_list[index].replace('/mnt/petrelfs/zhangxiaoman/DATA/Chestxray/ChestXray8/','/remote-home/share/medical/public/ChestXray8/')\n class_label = self.class_list[index] \n img = Image.open(img_path).convert('RGB') \n image = self.transform(img)\n return {\n \"image\": image,\n \"label\": class_label\n }\n \n def __len__(self):\n return len(self.img_path_list)"},{"identifier":"CheXpert_Dataset","path":"dataset/dataset_entity.py","snippet":"class CheXpert_Dataset(Dataset):\n def __init__(self, csv_path,image_res):\n data_info = pd.read_csv(csv_path)\n self.img_path_list = np.asarray(data_info.iloc[:,0])\n self.class_list = np.asarray(data_info.iloc[:,[13,7,11,10,15]])\n\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\n self.transform = transforms.Compose([ \n transforms.Resize([image_res,image_res], interpolation=transforms.InterpolationMode.BICUBIC),\n transforms.ToTensor(),\n normalize,\n ]) \n \n def __getitem__(self, index):\n img_path = os.path.join('/remote-home/share/tianjiedai/',self.img_path_list[index])\n class_label = self.class_list[index] \n img = Image.open(img_path).convert('RGB') \n image = self.transform(img)\n return {\n \"image\": image,\n \"label\": class_label\n }\n \n def __len__(self):\n return len(self.img_path_list)"}],"string":"[\n {\n \"identifier\": \"utils\",\n \"path\": \"factory/utils.py\",\n \"snippet\": \"class SmoothedValue(object):\\nclass MetricLogger(object):\\nclass AttrDict(dict):\\n def __init__(self, window_size=20, fmt=None):\\n def update(self, value, n=1):\\n def synchronize_between_processes(self):\\n def median(self):\\n def avg(self):\\n def global_avg(self):\\n def max(self):\\n def value(self):\\n def __str__(self):\\n def __init__(self, delimiter=\\\"\\\\t\\\"):\\n def update(self, **kwargs):\\n def __getattr__(self, attr):\\n def __str__(self):\\n def global_avg(self):\\n def synchronize_between_processes(self):\\n def add_meter(self, name, meter):\\n def log_every(self, iterable, print_freq, header=None):\\n def __init__(self, *args, **kwargs):\\ndef compute_acc(logits, label, reduction='mean'):\\ndef compute_n_params(model, return_str=True):\\ndef setup_for_distributed(is_master):\\n def print(*args, **kwargs):\\ndef seed_worker(worker_id):\\ndef is_dist_avail_and_initialized():\\ndef get_world_size():\\ndef get_rank():\\ndef is_main_process():\\ndef save_on_master(*args, **kwargs):\\ndef init_distributed_mode(args):\\n MB = 1024.0 * 1024.0\"\n },\n {\n \"identifier\": \"create_scheduler\",\n \"path\": \"scheduler/scheduler_factory.py\",\n \"snippet\": \"def create_scheduler(args, optimizer):\\n num_epochs = args.epochs\\n\\n if getattr(args, 'lr_noise', None) is not None:\\n lr_noise = getattr(args, 'lr_noise')\\n if isinstance(lr_noise, (list, tuple)):\\n noise_range = [n * num_epochs for n in lr_noise]\\n if len(noise_range) == 1:\\n noise_range = noise_range[0]\\n else:\\n noise_range = lr_noise * num_epochs\\n else:\\n noise_range = None\\n\\n lr_scheduler = None\\n if args.sched == 'cosine':\\n lr_scheduler = CosineLRScheduler(\\n optimizer,\\n t_initial=num_epochs,\\n t_mul=getattr(args, 'lr_cycle_mul', 1.),\\n lr_min=args.min_lr,\\n decay_rate=args.decay_rate,\\n warmup_lr_init=args.warmup_lr,\\n warmup_t=args.warmup_epochs,\\n cycle_limit=getattr(args, 'lr_cycle_limit', 1),\\n t_in_epochs=True,\\n noise_range_t=noise_range,\\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\\n noise_std=getattr(args, 'lr_noise_std', 1.),\\n noise_seed=getattr(args, 'seed', 42),\\n )\\n num_epochs = lr_scheduler.get_cycle_length() + args.cooldown_epochs\\n elif args.sched == 'tanh':\\n lr_scheduler = TanhLRScheduler(\\n optimizer,\\n t_initial=num_epochs,\\n t_mul=getattr(args, 'lr_cycle_mul', 1.),\\n lr_min=args.min_lr,\\n warmup_lr_init=args.warmup_lr,\\n warmup_t=args.warmup_epochs,\\n cycle_limit=getattr(args, 'lr_cycle_limit', 1),\\n t_in_epochs=True,\\n noise_range_t=noise_range,\\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\\n noise_std=getattr(args, 'lr_noise_std', 1.),\\n noise_seed=getattr(args, 'seed', 42),\\n )\\n num_epochs = lr_scheduler.get_cycle_length() + args.cooldown_epochs\\n elif args.sched == 'step':\\n lr_scheduler = StepLRScheduler(\\n optimizer,\\n decay_t=args.decay_epochs,\\n decay_rate=args.decay_rate,\\n warmup_lr_init=args.warmup_lr,\\n warmup_t=args.warmup_epochs,\\n noise_range_t=noise_range,\\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\\n noise_std=getattr(args, 'lr_noise_std', 1.),\\n noise_seed=getattr(args, 'seed', 42),\\n )\\n elif args.sched == 'plateau':\\n mode = 'min' if 'loss' in getattr(args, 'eval_metric', '') else 'max'\\n lr_scheduler = PlateauLRScheduler(\\n optimizer,\\n decay_rate=args.decay_rate,\\n patience_t=args.patience_epochs,\\n lr_min=args.min_lr,\\n mode=mode,\\n warmup_lr_init=args.warmup_lr,\\n warmup_t=args.warmup_epochs,\\n cooldown_t=0,\\n noise_range_t=noise_range,\\n noise_pct=getattr(args, 'lr_noise_pct', 0.67),\\n noise_std=getattr(args, 'lr_noise_std', 1.),\\n noise_seed=getattr(args, 'seed', 42),\\n )\\n\\n return lr_scheduler, num_epochs\"\n },\n {\n \"identifier\": \"create_optimizer\",\n \"path\": \"optim/optim_factory.py\",\n \"snippet\": \"def create_optimizer(args, model, image_encoder,text_encoder, filter_bias_and_bn=True):\\n opt_lower = args.opt.lower()\\n weight_decay = args.weight_decay\\n if weight_decay and filter_bias_and_bn:\\n skip = {}\\n if hasattr(model, 'no_weight_decay'):\\n skip = model.no_weight_decay()\\n parameters = add_weight_decay(model,image_encoder,text_encoder, weight_decay, skip)\\n weight_decay = 0.\\n else:\\n parameters = [filter(lambda p: p.requires_grad, model.parameters()),filter(lambda p: p.requires_grad, image_encoder.parameters()),filter(lambda p: p.requires_grad, text_encoder.parameters())]\\n #model.parameters()\\n\\n # print(parameters)\\n if 'fused' in opt_lower:\\n assert has_apex and torch.cuda.is_available(), 'APEX and CUDA required for fused optimizers'\\n\\n opt_args = dict(lr=args.lr, weight_decay=weight_decay)\\n if hasattr(args, 'opt_eps') and args.opt_eps is not None:\\n opt_args['eps'] = args.opt_eps\\n if hasattr(args, 'opt_betas') and args.opt_betas is not None:\\n opt_args['betas'] = args.opt_betas\\n if hasattr(args, 'opt_args') and args.opt_args is not None:\\n opt_args.update(args.opt_args)\\n\\n opt_split = opt_lower.split('_')\\n opt_lower = opt_split[-1]\\n if opt_lower == 'sgd' or opt_lower == 'nesterov':\\n opt_args.pop('eps', None)\\n optimizer = optim.SGD(parameters, momentum=args.momentum, nesterov=True, **opt_args)\\n elif opt_lower == 'momentum':\\n opt_args.pop('eps', None)\\n optimizer = optim.SGD(parameters, momentum=args.momentum, nesterov=False, **opt_args)\\n elif opt_lower == 'adam':\\n optimizer = optim.Adam(parameters, **opt_args)\\n elif opt_lower == 'adamw':\\n optimizer = optim.AdamW(parameters, **opt_args)\\n elif opt_lower == 'nadam':\\n optimizer = Nadam(parameters, **opt_args)\\n elif opt_lower == 'radam':\\n optimizer = RAdam(parameters, **opt_args)\\n elif opt_lower == 'adamp': \\n optimizer = AdamP(parameters, wd_ratio=0.01, nesterov=True, **opt_args)\\n elif opt_lower == 'sgdp': \\n optimizer = SGDP(parameters, momentum=args.momentum, nesterov=True, **opt_args)\\n elif opt_lower == 'adadelta':\\n optimizer = optim.Adadelta(parameters, **opt_args)\\n elif opt_lower == 'adafactor':\\n if not args.lr:\\n opt_args['lr'] = None\\n optimizer = Adafactor(parameters, **opt_args)\\n elif opt_lower == 'adahessian':\\n optimizer = Adahessian(parameters, **opt_args)\\n elif opt_lower == 'rmsprop':\\n optimizer = optim.RMSprop(parameters, alpha=0.9, momentum=args.momentum, **opt_args)\\n elif opt_lower == 'rmsproptf':\\n optimizer = RMSpropTF(parameters, alpha=0.9, momentum=args.momentum, **opt_args)\\n elif opt_lower == 'novograd':\\n optimizer = NovoGrad(parameters, **opt_args)\\n elif opt_lower == 'nvnovograd':\\n optimizer = NvNovoGrad(parameters, **opt_args)\\n elif opt_lower == 'fusedsgd':\\n opt_args.pop('eps', None)\\n optimizer = FusedSGD(parameters, momentum=args.momentum, nesterov=True, **opt_args)\\n elif opt_lower == 'fusedmomentum':\\n opt_args.pop('eps', None)\\n optimizer = FusedSGD(parameters, momentum=args.momentum, nesterov=False, **opt_args)\\n elif opt_lower == 'fusedadam':\\n optimizer = FusedAdam(parameters, adam_w_mode=False, **opt_args)\\n elif opt_lower == 'fusedadamw':\\n optimizer = FusedAdam(parameters, adam_w_mode=True, **opt_args)\\n elif opt_lower == 'fusedlamb':\\n optimizer = FusedLAMB(parameters, **opt_args)\\n elif opt_lower == 'fusednovograd':\\n opt_args.setdefault('betas', (0.95, 0.98))\\n optimizer = FusedNovoGrad(parameters, **opt_args)\\n else:\\n assert False and \\\"Invalid optimizer\\\"\\n raise ValueError\\n\\n if len(opt_split) > 1:\\n if opt_split[0] == 'lookahead':\\n optimizer = Lookahead(optimizer)\\n\\n return optimizer\"\n },\n {\n \"identifier\": \"train\",\n \"path\": \"engine/train.py\",\n \"snippet\": \"def train(model, image_encoder, text_encoder, tokenizer, data_loader, optimizer, epoch, warmup_steps, device, scheduler, args, config, writer):\\n clip_loss = ClipLoss()\\n ce_loss = nn.CrossEntropyLoss(ignore_index=-1)\\n \\n if args.add_dataset:\\n ASL_loss = AsymmetricLossAdd(gamma_neg=6, gamma_pos=0, clip=0.05, disable_torch_grad_focal_loss=True)\\n else:\\n ASL_loss = AsymmetricLoss(gamma_neg=6, gamma_pos=0, clip=0.05, disable_torch_grad_focal_loss=True)\\n\\n loss_m = AverageMeter()\\n loss_clip_m = AverageMeter()\\n loss_ce_m = AverageMeter()\\n loss_ce_image_m = AverageMeter()\\n loss_ce_text_m = AverageMeter()\\n batch_time_m = AverageMeter()\\n data_time_m = AverageMeter()\\n end = time.time()\\n\\n model.train() \\n image_encoder.train() \\n text_encoder.train()\\n metric_logger = utils.MetricLogger(delimiter=\\\" \\\")\\n metric_logger.add_meter('lr', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\\n metric_logger.add_meter('loss', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\\n metric_logger.add_meter('loss_ce', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\\n metric_logger.add_meter('loss_ce_image', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\\n if args.use_entity_features:\\n metric_logger.add_meter('loss_ce_text', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\\n metric_logger.add_meter('loss_clip', utils.SmoothedValue(window_size=50, fmt='{value:.6f}'))\\n metric_logger.update(loss=1.0)\\n metric_logger.update(lr = scheduler._get_lr(epoch)[0])\\n\\n header = 'Train Epoch: [{}]'.format(epoch)\\n print_freq = 50 \\n step_size = 100\\n warmup_iterations = warmup_steps*step_size \\n scalar_step = epoch*len(data_loader)\\n num_batches_per_epoch = data_loader.num_batches\\n sample_digits = math.ceil(math.log(data_loader.num_samples + 1, 10))\\n\\n for i, sample in enumerate(metric_logger.log_every(data_loader, print_freq, header)):\\n if args.fourier:\\n image = fourier_aug(sample['image'].to(device))\\n else:\\n image = sample['image'].to(device) \\n label = sample['label'].long().to(device)\\n\\n if args.ignore_index:\\n pass\\n else:\\n label[label==-1]=0\\n entity = sample['entity']\\n\\n if args.add_dataset:\\n dataset_label = sample['label_dataset']\\n\\n data_time_m.update(time.time() - end)\\n\\n optimizer.zero_grad()\\n\\n if args.add_dataset:\\n text_list = ['normal', 'pleural effusion', 'opacity', 'pneumothorax', 'edema', 'atelectasis', 'tube', 'consolidation','enlarged cardiomediastinum','tip', 'pneumonia','line','cardiomegaly', 'fracture','calcification',\\n 'device','engorgement', 'nodule', 'wire', 'pacemaker', 'pleural thicken', 'marking', 'scar', 'hyperinflate', 'blunt', 'collapse', 'emphysema', 'aerate', 'mass','infiltration', 'obscure', 'deformity', 'hernia',\\n 'drainage', 'distention', 'shift', 'stent', 'lesion', 'hardware', 'dilation', 'aspiration',\\n 'fibrosis',\\t'No Finding', 'Pleural Other', 'Support Devices', 'Aortic enlargement',\\n 'Clavicle fracture', 'Enlarged PA', 'ILD', 'Lung cavity', 'Lung cyst', 'Mediastinal shift',\\t\\n 'Nodule/Mass', 'Pulmonary fibrosis', 'Rib fracture', 'Other lesion', 'COPD', 'Lung tumor', 'Tuberculosis',\\n 'Other diseases']\\n\\n else:\\n\\n text_list = ['normal', 'pleural effusion', 'opacity', 'pneumothorax', 'edema', 'atelectasis', 'tube', 'consolidation','enlarged cardiomediastinum','tip', 'pneumonia','line','cardiomegaly', 'fracture','calcification',\\n 'device','engorgement', 'nodule', 'wire', 'pacemaker', 'pleural thicken', 'marking', 'scar', 'hyperinflate', 'blunt', 'collapse', 'emphysema', 'aerate', 'mass','infiltration', 'obscure', 'deformity', 'hernia',\\n 'drainage', 'distention', 'shift', 'stent', 'lesion', 'hardware', 'dilation', 'aspiration']\\n \\n \\n text_features = get_text_features(text_encoder,text_list,tokenizer,device,max_length=args.max_length)\\n entity_features = get_text_features(text_encoder,entity,tokenizer,device,max_length=args.max_length)\\n\\n image_features,image_features_pool = image_encoder(image)\\n if args.add_dataset:\\n pred_class_image, moe_img = model(image_features,text_features,args)\\n else:\\n pred_class_image = model(image_features,text_features)\\n\\n\\n if args.bce or args.asl:\\n label = label.float()\\n\\n label_mask = (label != -1).squeeze()\\n\\n\\n\\n if args.add_dataset:\\n loss_moe_img = moe_cl_loss(moe_img, dataset_label)\\n\\n if args.asl:\\n pred_class_image = pred_class_image[label_mask]\\n label_image = label[label_mask] \\n loss_ce_image = ASL_loss(pred_class_image.view(-1,1),label_image.view(-1,1))\\n elif args.bce:\\n pred_class_image = pred_class_image[label_mask]\\n label_image = label[label_mask] \\n loss_ce_image = F.binary_cross_entropy(pred_class_image.view(-1,1),label_image.view(-1,1))\\n else:\\n if args.asl:\\n loss_ce_image = ASL_loss(pred_class_image.view(-1,1),label.view(-1,1))\\n elif args.bce:\\n loss_ce_image = F.binary_cross_entropy_with_logits(pred_class_image.view(-1,1),label.view(-1,1)) \\n else:\\n loss_ce_image = ce_loss(pred_class_image.view(-1,2),label.view(-1)) \\n\\n if args.use_entity_features:\\n if args.add_dataset:\\n pred_class_text, moe_txt = model(entity_features.unsqueeze(1),text_features,args)\\n loss_moe_txt = moe_cl_loss(moe_txt, dataset_label)\\n else:\\n pred_class_text = model(entity_features.unsqueeze(1),text_features)\\n\\n if args.add_dataset:\\n if args.asl:\\n pred_class_text = pred_class_text[label_mask]\\n label_text = label[label_mask] \\n loss_ce_text = ASL_loss(pred_class_text.view(-1,1),label_text.view(-1,1))\\n \\n elif args.bce:\\n pred_class_text = pred_class_text[label_mask]\\n label_text = label[label_mask] \\n loss_ce_text = F.binary_cross_entropy(pred_class_text.view(-1,1),label_text.view(-1,1))\\n\\n else:\\n if args.asl:\\n loss_ce_text = ASL_loss(pred_class_text.view(-1,1),label.view(-1,1))\\n elif args.bce:\\n loss_ce_text = F.binary_cross_entropy_with_logits(pred_class_text.view(-1,1),label.view(-1,1)) \\n else:\\n loss_ce_text = ce_loss(pred_class_text.view(-1,2),label.view(-1))\\n\\n loss_ce = loss_ce_image + loss_ce_text\\n if args.add_dataset:\\n loss_moe = loss_moe_img + loss_moe_txt\\n\\n else:\\n loss_ce = loss_ce_image\\n if args.add_dataset:\\n loss_moe = loss_moe_img\\n\\n\\n loss_clip = clip_loss(image_features_pool,entity_features)\\n if args.add_dataset:\\n loss = loss_ce + loss_clip * args.loss_ratio + args.moe_ratio * loss_moe\\n else:\\n loss = loss_ce + loss_clip * args.loss_ratio\\n \\n\\n loss.backward()\\n optimizer.step() \\n \\n writer.add_scalar('loss/loss', loss, scalar_step)\\n writer.add_scalar('loss/loss_ce', loss_ce, scalar_step)\\n writer.add_scalar('loss/loss_ce_image', loss_ce_image, scalar_step)\\n if args.use_entity_features:\\n writer.add_scalar('loss/loss_ce_text', loss_ce_text, scalar_step)\\n writer.add_scalar('loss/loss_clip', loss_clip, scalar_step)\\n scalar_step += 1\\n\\n metric_logger.update(loss=loss.item())\\n metric_logger.update(loss_ce=loss_ce.item())\\n metric_logger.update(loss_ce_image=loss_ce_image.item())\\n if args.use_entity_features:\\n metric_logger.update(loss_ce_text=loss_ce_text.item())\\n metric_logger.update(loss_clip=loss_clip.item())\\n\\n\\n if epoch==0 and i%step_size==0 and i<=warmup_iterations: \\n scheduler.step(i//step_size) \\n metric_logger.update(lr = scheduler._get_lr(epoch)[0])\\n\\n batch_time_m.update(time.time() - end)\\n end = time.time()\\n batch_count = i + 1\\n if i % 100 == 0:\\n batch_size = len(image)\\n num_samples = batch_count * batch_size\\n samples_per_epoch = data_loader.num_samples\\n percent_complete = 100.0 * batch_count / num_batches_per_epoch\\n\\n # NOTE loss is coarsely sampled, just master node and per log update\\n loss_m.update(loss.item(), batch_size)\\n loss_clip_m.update(loss_clip.item(), batch_size)\\n loss_ce_m.update(loss_ce.item(), batch_size)\\n loss_ce_image_m.update(loss_ce_image.item(), batch_size)\\n if args.use_entity_features:\\n loss_ce_text_m.update(loss_ce_text.item(), batch_size)\\n logging.info(\\n f\\\"Train Epoch: {epoch} [{num_samples:>{sample_digits}}/{samples_per_epoch} ({percent_complete:.0f}%)] \\\"\\n f\\\"Loss: {loss_m.val:#.5g} ({loss_m.avg:#.4g}) \\\"\\n f\\\"Loss_clip: {loss_clip_m.val:#.5g} ({loss_clip_m.avg:#.4g}) \\\"\\n f\\\"Loss_ce: {loss_ce_m.val:#.5g} ({loss_ce_m.avg:#.4g}) \\\"\\n f\\\"Loss_ce_image: {loss_ce_image_m.val:#.5g} ({loss_ce_image_m.avg:#.4g}) \\\"\\n f\\\"Loss_ce_text: {loss_ce_text_m.val:#.5g} ({loss_ce_text_m.avg:#.4g}) \\\"\\n f\\\"Data (t): {data_time_m.avg:.3f} \\\"\\n f\\\"Batch (t): {batch_time_m.avg:.3f}, {batch_size/ batch_time_m.val:#g}/s \\\"\\n f\\\"LR: { scheduler._get_lr(epoch)[0]:5f} \\\"\\n )\\n else:\\n logging.info(\\n f\\\"Train Epoch: {epoch} [{num_samples:>{sample_digits}}/{samples_per_epoch} ({percent_complete:.0f}%)] \\\"\\n f\\\"Loss: {loss_m.val:#.5g} ({loss_m.avg:#.4g}) \\\"\\n f\\\"Loss_clip: {loss_clip_m.val:#.5g} ({loss_clip_m.avg:#.4g}) \\\"\\n f\\\"Loss_ce: {loss_ce_m.val:#.5g} ({loss_ce_m.avg:#.4g}) \\\"\\n f\\\"Loss_ce_image: {loss_ce_image_m.val:#.5g} ({loss_ce_image_m.avg:#.4g}) \\\"\\n f\\\"Data (t): {data_time_m.avg:.3f} \\\"\\n f\\\"Batch (t): {batch_time_m.avg:.3f}, {batch_size/ batch_time_m.val:#g}/s \\\"\\n f\\\"LR: { scheduler._get_lr(epoch)[0]:5f} \\\"\\n )\\n\\n # gather the stats from all processes\\n metric_logger.synchronize_between_processes()\\n print(\\\"Averaged stats:\\\", metric_logger.global_avg()) \\n return {k: \\\"{:.6f}\\\".format(meter.global_avg) for k, meter in metric_logger.meters.items()} #,loss_epoch.mean()\"\n },\n {\n \"identifier\": \"valid_on_cheXpert\",\n \"path\": \"engine/train.py\",\n \"snippet\": \"def valid_on_cheXpert(model,image_encoder,text_encoder,tokenizer,data_loader, epoch, device, args, config, writer):\\n criterion = nn.CrossEntropyLoss()\\n model.eval()\\n image_encoder.eval()\\n text_encoder.eval()\\n text_list = ['atelectasis', 'cardiomegaly', 'consolidation', 'edema', 'pleural effusion']\\n text_features = get_text_features(text_encoder,text_list,tokenizer,device,max_length=args.max_length)\\n \\n val_scalar_step = epoch*len(data_loader)\\n val_losses = []\\n\\n # initialize the ground truth and output tensor\\n gt = torch.FloatTensor()\\n gt = gt.cuda()\\n pred = torch.FloatTensor()\\n pred = pred.cuda()\\n\\n for i, sample in enumerate(data_loader):\\n image = sample['image'].to(device,non_blocking=True) \\n label = sample['label'].long().to(device)\\n if args.bce or args.asl:\\n label = label.float()\\n\\n gt = torch.cat((gt, label), 0)\\n with torch.no_grad():\\n image_features,image_features_pool = image_encoder(image)\\n \\n # \\n if args.add_dataset:\\n pred_class,_ = model(image_features,text_features,args)#b,14,2/1\\n val_loss = F.binary_cross_entropy(pred_class.view(-1,1),label.view(-1, 1))\\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\\n else:\\n pred_class = model(image_features,text_features)#b,14,2/1\\n if args.bce or args.asl:\\n val_loss = F.binary_cross_entropy_with_logits(pred_class.view(-1,1),label.view(-1, 1))\\n pred_class = torch.sigmoid(pred_class)\\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\\n else:\\n val_loss = criterion(pred_class.view(-1,2),label.view(-1))\\n pred_class = torch.softmax(pred_class, dim=-1)\\n pred = torch.cat((pred, pred_class[:,:,1]), 0)\\n \\n val_losses.append(val_loss.item())\\n writer.add_scalar('val_loss/loss', val_loss, val_scalar_step)\\n val_scalar_step += 1\\n metrics = compute_AUCs(gt, pred, n_class=5)\\n AUROC_avg = metrics['mean_auc']\\n avg_val_loss = np.array(val_losses).mean()\\n return avg_val_loss,AUROC_avg,metrics\"\n },\n {\n \"identifier\": \"valid_on_chestxray14\",\n \"path\": \"engine/train.py\",\n \"snippet\": \"def valid_on_chestxray14(model, image_encoder, text_encoder, tokenizer, data_loader, epoch, device, args, config, writer):\\n criterion = nn.CrossEntropyLoss()\\n model.eval()\\n image_encoder.eval()\\n text_encoder.eval()\\n text_list = [\\\"atelectasis\\\",\\\"cardiomegaly\\\",\\\"pleural effusion\\\",\\\"infiltration\\\",\\\"lung mass\\\",\\\"lung nodule\\\",\\\"pneumonia\\\",\\\"pneumothorax\\\",\\\"consolidation\\\",\\\"edema\\\",\\\"emphysema\\\",\\\"fibrosis\\\",\\\"pleural thicken\\\",\\\"hernia\\\"]\\n text_features = get_text_features(text_encoder,text_list,tokenizer,device,max_length=args.max_length)\\n \\n val_scalar_step = epoch*len(data_loader)\\n val_losses = []\\n\\n gt = torch.FloatTensor()\\n gt = gt.cuda()\\n pred = torch.FloatTensor()\\n pred = pred.cuda()\\n\\n for i, sample in enumerate(data_loader):\\n image = sample['image'].to(device,non_blocking=True) \\n label = sample['label'].long().to(device)\\n if args.bce or args.asl:\\n label = label.float()\\n\\n gt = torch.cat((gt, label), 0)\\n with torch.no_grad():\\n image_features,image_features_pool = image_encoder(image)\\n\\n if args.add_dataset:\\n pred_class,_ = model(image_features,text_features,args)#b,14,2/1\\n val_loss = F.binary_cross_entropy(pred_class.view(-1,1),label.view(-1, 1))\\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\\n else:\\n pred_class = model(image_features,text_features)#b,14,2/1\\n if args.bce or args.asl:\\n val_loss = F.binary_cross_entropy_with_logits(pred_class.view(-1,1),label.view(-1, 1))\\n pred_class = torch.sigmoid(pred_class)\\n pred = torch.cat((pred, pred_class[:,:,0]), 0)\\n else:\\n val_loss = criterion(pred_class.view(-1,2),label.view(-1))\\n pred_class = torch.softmax(pred_class, dim=-1)\\n pred = torch.cat((pred, pred_class[:,:,1]), 0)\\n\\n\\n\\n val_losses.append(val_loss.item())\\n writer.add_scalar('val_loss/loss', val_loss, val_scalar_step)\\n val_scalar_step += 1\\n metrics = compute_AUCs(gt, pred, n_class = 14)\\n AUROC_avg = metrics['mean_auc']\\n avg_val_loss = np.array(val_losses).mean()\\n return avg_val_loss,AUROC_avg,metrics\"\n },\n {\n \"identifier\": \"CLP_clinical\",\n \"path\": \"models/clip_tqn.py\",\n \"snippet\": \"class CLP_clinical(nn.Module):\\n def __init__(self,\\n bert_model_name: str,\\n embed_dim: int = 768,\\n freeze_layers:Union[Tuple[int, int], int] = None):\\n super().__init__()\\n self.bert_model = self._get_bert_basemodel(bert_model_name=bert_model_name, freeze_layers=freeze_layers)\\n self.mlp_embed = nn.Sequential(\\n nn.Linear(embed_dim, embed_dim),\\n nn.GELU(),\\n nn.Linear(embed_dim, embed_dim)\\n )\\n self.embed_dim = embed_dim\\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\\n self.init_parameters()\\n \\n def init_parameters(self):\\n nn.init.constant_(self.logit_scale, np.log(1 / 0.07))\\n for m in self.mlp_embed:\\n if isinstance(m, nn.Linear):\\n nn.init.normal_(m.weight, std=self.embed_dim ** -0.5)\\n\\n def _get_bert_basemodel(self, bert_model_name, freeze_layers=None):#12\\n try:\\n print(bert_model_name)\\n config = BertConfig.from_pretrained(bert_model_name, output_hidden_states=True)#bert-base-uncased\\n model = AutoModel.from_pretrained(bert_model_name, config=config)#, return_dict=True)\\n print(\\\"Text feature extractor:\\\", bert_model_name)\\n print(\\\"bert encoder layers:\\\",len(model.encoder.layer))\\n except:\\n raise (\\\"Invalid model name. Check the config file and pass a BERT model from transformers lybrary\\\")\\n\\n if freeze_layers is not None:\\n for layer_idx in freeze_layers:\\n for param in list(model.encoder.layer[layer_idx].parameters()):\\n param.requires_grad = False\\n return model\\n\\n def encode_text(self, text):\\n #input batch_size,token, return batch_size,dim \\n output = self.bert_model(input_ids = text['input_ids'],attention_mask = text['attention_mask'] )\\n last_hidden_state, pooler_output, hidden_states = output[0],output[1],output[2]\\n encode_out = self.mlp_embed(pooler_output)\\n # encode_out = pooler_output\\n return encode_out\\n \\n def forward(self,text1,text2):\\n text1_features = self.encode_text(text1)\\n text2_features = self.encode_text(text2)\\n text1_features = F.normalize(text1_features, dim=-1)\\n text2_features = F.normalize(text2_features, dim=-1)\\n return text1_features, text2_features, self.logit_scale.exp()\"\n },\n {\n \"identifier\": \"ModelRes\",\n \"path\": \"models/clip_tqn.py\",\n \"snippet\": \"class ModelRes(nn.Module):\\n def __init__(self, res_base_model):\\n super(ModelRes, self).__init__()\\n self.resnet_dict = {\\\"resnet50\\\": models.resnet50(pretrained=True)}\\n self.resnet = self._get_res_basemodel(res_base_model)\\n\\n num_ftrs = int(self.resnet.fc.in_features)\\n self.res_features = nn.Sequential(*list(self.resnet.children())[:-2])\\n\\n self.res_l1 = nn.Linear(num_ftrs, num_ftrs)\\n self.res_l2 = nn.Linear(num_ftrs, 768)\\n\\n def _get_res_basemodel(self, res_model_name):\\n try:\\n res_model = self.resnet_dict[res_model_name]\\n print(\\\"Image feature extractor:\\\", res_model_name)\\n return res_model\\n except:\\n raise (\\\"Invalid model name. Check the config file and pass one of: resnet18 or resnet50\\\")\\n\\n def forward(self, img):\\n batch_size = img.shape[0]\\n res_fea = self.res_features(img)\\n\\n res_fea = rearrange(res_fea,'b d n1 n2 -> b (n1 n2) d')\\n h = rearrange(res_fea,'b n d -> (b n) d')\\n x = self.res_l1(h)\\n x = F.relu(x)\\n x = self.res_l2(x)\\n out_emb = rearrange(x,'(b n) d -> b n d',b=batch_size)\\n out_pool = torch.mean(out_emb,dim=1)\\n return out_emb,out_pool\"\n },\n {\n \"identifier\": \"TQN_Model\",\n \"path\": \"models/clip_tqn.py\",\n \"snippet\": \"class TQN_Model(nn.Module):\\n def __init__(self, \\n embed_dim: int = 768, \\n class_num: int = 1, \\n lam: list = [1, 0]\\n ):\\n super().__init__()\\n self.d_model = embed_dim\\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\\n decoder_layer = TransformerDecoderLayer(self.d_model, 4, 1024,\\n 0.1, 'relu',normalize_before=True)\\n decoder_layerV1 = TransformerDecoderLayerV1(self.d_model, 4, 1024,\\n 0.1, 'relu', True, lam)\\n self.decoder_norm = nn.LayerNorm(self.d_model)\\n self.decoder = TransformerDecoder(decoder_layer, 4, self.decoder_norm,\\n return_intermediate=False)\\n self.decoderV1 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\\n return_intermediate=False)\\n \\n self.dropout_feas = nn.Dropout(0.1)\\n\\n self.mlp_head = nn.Sequential( # nn.LayerNorm(768),\\n nn.Linear(embed_dim, class_num)\\n )\\n self.apply(self._init_weights)\\n \\n @staticmethod\\n def _init_weights(module):\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n\\n elif isinstance(module, nn.MultiheadAttention):\\n module.in_proj_weight.data.normal_(mean=0.0, std=0.02)\\n module.out_proj.weight.data.normal_(mean=0.0, std=0.02)\\n\\n elif isinstance(module, nn.Embedding):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n if module.padding_idx is not None:\\n module.weight.data[module.padding_idx].zero_()\\n \\n def forward(self, image_features, text_features):\\n\\n batch_size = image_features.shape[0]\\n image_features = image_features.transpose(0,1)\\n text_features = text_features.unsqueeze(1).repeat(1, batch_size, 1)\\n image_features = self.decoder_norm(image_features)\\n text_features = self.decoder_norm(text_features)\\n \\n image_features_pool = torch.mean(image_features,dim=0).unsqueeze(0)\\n features = self.decoderV1(text_features, image_features, image_features_pool,\\n memory_key_padding_mask=None, pos=None, query_pos=None) \\n \\n features = self.dropout_feas(features).transpose(0,1) #b,embed_dim\\n out = self.mlp_head(features) #(batch_size, query_num)\\n return out\"\n },\n {\n \"identifier\": \"TQN_Model_Add\",\n \"path\": \"models/clip_tqn.py\",\n \"snippet\": \"class TQN_Model_Add(nn.Module):\\n def __init__(self, \\n embed_dim: int = 768, \\n class_num: int = 1, \\n gate_num: int = 3,\\n high_dim: int = 32,\\n lam: list = [1, 0]\\n ):\\n super().__init__()\\n self.d_model = embed_dim\\n self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))\\n decoder_layer = TransformerDecoderLayer(self.d_model, 4, 1024,\\n 0.1, 'relu',normalize_before=True)\\n decoder_layerV1 = TransformerDecoderLayerV1(self.d_model, 4, 1024,\\n 0.1, 'relu', True, lam)\\n self.decoder_norm = nn.LayerNorm(self.d_model)\\n self.decoder = TransformerDecoder(decoder_layer, 4, self.decoder_norm,\\n return_intermediate=False)\\n self.decoderV1 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\\n return_intermediate=False)\\n \\n self.decoderV1_1 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\\n return_intermediate=False)\\n self.decoderV1_2 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\\n return_intermediate=False)\\n self.decoderV1_3 = TransformerDecoderV1(decoder_layerV1, 4, self.decoder_norm,\\n return_intermediate=False)\\n\\n self.dropout_feas = nn.Dropout(0.1)\\n\\n self.mlp_head = nn.Sequential( # nn.LayerNorm(768),\\n nn.Linear(embed_dim, class_num)\\n )\\n self.mlp_head_1 = nn.Sequential( # nn.LayerNorm(768),\\n nn.Linear(embed_dim, class_num)\\n )\\n self.mlp_head_2 = nn.Sequential( # nn.LayerNorm(768),\\n nn.Linear(embed_dim, class_num)\\n )\\n self.mlp_head_3 = nn.Sequential( # nn.LayerNorm(768),\\n nn.Linear(embed_dim, class_num)\\n ) \\n \\n self.gate_head = nn.Sequential(\\n nn.Linear(embed_dim, gate_num)\\n )\\n self.cl_head = nn.Sequential(\\n nn.Linear(gate_num, high_dim)\\n )\\n\\n self.apply(self._init_weights)\\n \\n @staticmethod\\n def _init_weights(module):\\n if isinstance(module, nn.Linear):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n\\n elif isinstance(module, nn.MultiheadAttention):\\n module.in_proj_weight.data.normal_(mean=0.0, std=0.02)\\n module.out_proj.weight.data.normal_(mean=0.0, std=0.02)\\n\\n elif isinstance(module, nn.Embedding):\\n module.weight.data.normal_(mean=0.0, std=0.02)\\n if module.padding_idx is not None:\\n module.weight.data[module.padding_idx].zero_()\\n \\n def forward(self, image_features, text_features, args):\\n\\n batch_size = image_features.shape[0]\\n image_features = image_features.transpose(0,1)\\n text_features = text_features.unsqueeze(1).repeat(1, batch_size, 1)\\n image_features = self.decoder_norm(image_features)\\n text_features = self.decoder_norm(text_features)\\n \\n image_features_pool = torch.mean(image_features,dim=0).unsqueeze(0)\\n features = self.decoderV1(text_features, image_features, image_features_pool,\\n memory_key_padding_mask=None, pos=None, query_pos=None)\\n gate_weight = self.gate_head(image_features_pool.squeeze(0)) \\n \\n features = self.dropout_feas(features).transpose(0,1) #b,embed_dim\\n \\n \\n if args.finetune:\\n features_1 = self.decoderV1_1(text_features, image_features, image_features_pool,\\n memory_key_padding_mask=None, pos=None, query_pos=None)\\n features_1 = self.dropout_feas(features_1).transpose(0,1) \\n features_2 = self.decoderV1_2(text_features, image_features, image_features_pool,\\n memory_key_padding_mask=None, pos=None, query_pos=None)\\n features_2 = self.dropout_feas(features_2).transpose(0,1) \\n features_3 = self.decoderV1_3(text_features, image_features, image_features_pool,\\n memory_key_padding_mask=None, pos=None, query_pos=None)\\n features_3 = self.dropout_feas(features_3).transpose(0,1) \\n \\n out_1 = torch.sigmoid(self.mlp_head_1(features_1))\\n out_2 = torch.sigmoid(self.mlp_head_2(features_2))\\n out_3 = torch.sigmoid(self.mlp_head_3(features_3))\\n\\n\\n out = self.mlp_head(features)\\n \\n gate_weight = torch.softmax(gate_weight, dim=1)\\n out = torch.sigmoid(out)\\n\\n high_dimension = self.cl_head(gate_weight)\\n out_bias = gate_weight[:,0].unsqueeze(1).unsqueeze(2) * out_1 + gate_weight[:,1].unsqueeze(1).unsqueeze(2) * out_2 + gate_weight[:,2].unsqueeze(1).unsqueeze(2) * out_3\\n\\n out = args.main_ratio * out + args.bias_ratio * out_bias\\n\\n return out, high_dimension\"\n },\n {\n \"identifier\": \"ModelDense\",\n \"path\": \"models/clip_tqn.py\",\n \"snippet\": \"class ModelDense(nn.Module):\\n def __init__(self, dense_base_model):\\n super(ModelDense, self).__init__()\\n \\n self.densenet_dict = {\\\"densenet121\\\": models.densenet121(pretrained=True)}#,\\n # \\\"densenet161\\\": models.densenet161(pretrained=True)}\\n self.densenet = self._get_dense_basemodel(dense_base_model)\\n num_ftrs = int(self.densenet.classifier.in_features)\\n self.dense_features = self.densenet.features\\n self.dense_l1 = nn.Linear(num_ftrs, num_ftrs)\\n self.dense_l2 = nn.Linear(num_ftrs, 768)\\n\\n def _get_dense_basemodel(self, dense_base_model):\\n try:\\n dense_model = self.densenet_dict[dense_base_model]\\n print(\\\"Image feature extractor:\\\", dense_base_model)\\n return dense_model\\n except:\\n raise (\\\"Invalid model name. Check the config file and pass one of: densenet121 or densenet161\\\")\\n\\n def forward(self, img):\\n batch_size = img.shape[0]\\n dense_fea = self.dense_features(img)#N, 1024, 7,7\\n dense_fea = rearrange(dense_fea,'b d n1 n2 -> b (n1 n2) d')\\n h = rearrange(dense_fea,'b n d -> (b n) d')\\n x = self.dense_l1(h)\\n x = F.relu(x)\\n x = self.dense_l2(x)\\n out_emb = rearrange(x,'(b n) d -> b n d',b=batch_size)\\n out_pool = torch.mean(out_emb,dim=1)\\n return out_emb,out_pool\"\n },\n {\n \"identifier\": \"CLP_clinical2\",\n \"path\": \"models/clip_tqn.py\",\n \"snippet\": \"class CLP_clinical2(nn.Module):\\n def __init__(self,\\n bert_model_name: str,\\n embed_dim: int = 768,\\n freeze_layers:Union[Tuple[int, int], int] = None):\\n super().__init__()\\n self.bert_model = self._get_bert_basemodel(bert_model_name=bert_model_name, freeze_layers=freeze_layers)\\n\\n\\n def _get_bert_basemodel(self, bert_model_name, freeze_layers=None):#12\\n try:\\n print(bert_model_name)\\n model = AutoModel.from_pretrained(bert_model_name)\\n print(\\\"Text feature extractor:\\\", bert_model_name)\\n print(\\\"bert encoder layers:\\\",len(model.encoder.layer))\\n except:\\n raise (\\\"Invalid model name. Check the config file and pass a BERT model from transformers lybrary\\\")\\n\\n if freeze_layers is not None:\\n for layer_idx in freeze_layers:\\n for param in list(model.encoder.layer[layer_idx].parameters()):\\n param.requires_grad = False\\n return model\\n\\n def encode_text(self, text):\\n output = self.bert_model(input_ids = text['input_ids'],attention_mask = text['attention_mask'] )\\n encode_out = output.last_hidden_state[:,0,:]\\n return encode_out\\n \\n def forward(self,text1,text2):\\n text1_features = self.encode_text(text1)\\n text2_features = self.encode_text(text2)\\n text1_features = F.normalize(text1_features, dim=-1)\\n text2_features = F.normalize(text2_features, dim=-1)\\n return text1_features, text2_features, self.logit_scale.exp()\"\n },\n {\n \"identifier\": \"BertTokenizer\",\n \"path\": \"models/tokenization_bert.py\",\n \"snippet\": \"class BertTokenizer(PreTrainedTokenizer):\\n r\\\"\\\"\\\"\\n Construct a BERT tokenizer. Based on WordPiece.\\n This tokenizer inherits from :class:`~transformers.PreTrainedTokenizer` which contains most of the main methods.\\n Users should refer to this superclass for more information regarding those methods.\\n Args:\\n vocab_file (:obj:`str`):\\n File containing the vocabulary.\\n do_lower_case (:obj:`bool`, `optional`, defaults to :obj:`True`):\\n Whether or not to lowercase the input when tokenizing.\\n do_basic_tokenize (:obj:`bool`, `optional`, defaults to :obj:`True`):\\n Whether or not to do basic tokenization before WordPiece.\\n never_split (:obj:`Iterable`, `optional`):\\n Collection of tokens which will never be split during tokenization. Only has an effect when\\n :obj:`do_basic_tokenize=True`\\n unk_token (:obj:`str`, `optional`, defaults to :obj:`\\\"[UNK]\\\"`):\\n The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this\\n token instead.\\n sep_token (:obj:`str`, `optional`, defaults to :obj:`\\\"[SEP]\\\"`):\\n The separator token, which is used when building a sequence from multiple sequences, e.g. two sequences for\\n sequence classification or for a text and a question for question answering. It is also used as the last\\n token of a sequence built with special tokens.\\n pad_token (:obj:`str`, `optional`, defaults to :obj:`\\\"[PAD]\\\"`):\\n The token used for padding, for example when batching sequences of different lengths.\\n cls_token (:obj:`str`, `optional`, defaults to :obj:`\\\"[CLS]\\\"`):\\n The classifier token which is used when doing sequence classification (classification of the whole sequence\\n instead of per-token classification). It is the first token of the sequence when built with special tokens.\\n mask_token (:obj:`str`, `optional`, defaults to :obj:`\\\"[MASK]\\\"`):\\n The token used for masking values. This is the token used when training this model with masked language\\n modeling. This is the token which the model will try to predict.\\n tokenize_chinese_chars (:obj:`bool`, `optional`, defaults to :obj:`True`):\\n Whether or not to tokenize Chinese characters.\\n This should likely be deactivated for Japanese (see this `issue\\n <https://github.com/huggingface/transformers/issues/328>`__).\\n strip_accents: (:obj:`bool`, `optional`):\\n Whether or not to strip all accents. If this option is not specified, then it will be determined by the\\n value for :obj:`lowercase` (as in the original BERT).\\n \\\"\\\"\\\"\\n\\n vocab_files_names = VOCAB_FILES_NAMES\\n pretrained_vocab_files_map = PRETRAINED_VOCAB_FILES_MAP\\n pretrained_init_configuration = PRETRAINED_INIT_CONFIGURATION\\n max_model_input_sizes = PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES\\n\\n def __init__(\\n self,\\n vocab_file,\\n do_lower_case=True,\\n do_basic_tokenize=True,\\n never_split=None,\\n unk_token=\\\"[UNK]\\\",\\n sep_token=\\\"[SEP]\\\",\\n pad_token=\\\"[PAD]\\\",\\n cls_token=\\\"[CLS]\\\",\\n mask_token=\\\"[MASK]\\\",\\n tokenize_chinese_chars=True,\\n strip_accents=None,\\n **kwargs\\n ):\\n super().__init__(\\n do_lower_case=do_lower_case,\\n do_basic_tokenize=do_basic_tokenize,\\n never_split=never_split,\\n unk_token=unk_token,\\n sep_token=sep_token,\\n pad_token=pad_token,\\n cls_token=cls_token,\\n mask_token=mask_token,\\n tokenize_chinese_chars=tokenize_chinese_chars,\\n strip_accents=strip_accents,\\n **kwargs,\\n )\\n\\n if not os.path.isfile(vocab_file):\\n raise ValueError(\\n \\\"Can't find a vocabulary file at path '{}'. To load the vocabulary from a Google pretrained \\\"\\n \\\"model use `tokenizer = BertTokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`\\\".format(vocab_file)\\n )\\n self.vocab = load_vocab(vocab_file)\\n self.ids_to_tokens = collections.OrderedDict([(ids, tok) for tok, ids in self.vocab.items()])\\n self.do_basic_tokenize = do_basic_tokenize\\n if do_basic_tokenize:\\n self.basic_tokenizer = BasicTokenizer(\\n do_lower_case=do_lower_case,\\n never_split=never_split,\\n tokenize_chinese_chars=tokenize_chinese_chars,\\n strip_accents=strip_accents,\\n )\\n self.wordpiece_tokenizer = WordpieceTokenizer(vocab=self.vocab, unk_token=self.unk_token)\\n\\n @property\\n def do_lower_case(self):\\n return self.basic_tokenizer.do_lower_case\\n\\n @property\\n def vocab_size(self):\\n return len(self.vocab)\\n\\n def get_vocab(self):\\n return dict(self.vocab, **self.added_tokens_encoder)\\n\\n def _tokenize(self, text):\\n split_tokens = []\\n if self.do_basic_tokenize:\\n for token in self.basic_tokenizer.tokenize(text, never_split=self.all_special_tokens):\\n\\n # If the token is part of the never_split set\\n if token in self.basic_tokenizer.never_split:\\n split_tokens.append(token)\\n else:\\n split_tokens += self.wordpiece_tokenizer.tokenize(token)\\n else:\\n split_tokens = self.wordpiece_tokenizer.tokenize(text)\\n return split_tokens\\n\\n def _convert_token_to_id(self, token):\\n \\\"\\\"\\\" Converts a token (str) in an id using the vocab. \\\"\\\"\\\"\\n return self.vocab.get(token, self.vocab.get(self.unk_token))\\n\\n def _convert_id_to_token(self, index):\\n \\\"\\\"\\\"Converts an index (integer) in a token (str) using the vocab.\\\"\\\"\\\"\\n return self.ids_to_tokens.get(index, self.unk_token)\\n\\n def convert_tokens_to_string(self, tokens):\\n \\\"\\\"\\\" Converts a sequence of tokens (string) in a single string. \\\"\\\"\\\"\\n out_string = \\\" \\\".join(tokens).replace(\\\" ##\\\", \\\"\\\").strip()\\n return out_string\\n\\n def build_inputs_with_special_tokens(\\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\\n ) -> List[int]:\\n \\\"\\\"\\\"\\n Build model inputs from a sequence or a pair of sequence for sequence classification tasks by concatenating and\\n adding special tokens. A BERT sequence has the following format:\\n - single sequence: ``[CLS] X ``\\n - pair of sequences: ``[CLS] A [SEP] B [SEP]``\\n Args:\\n token_ids_0 (:obj:`List[int]`):\\n List of IDs to which the special tokens will be added.\\n token_ids_1 (:obj:`List[int]`, `optional`):\\n Optional second list of IDs for sequence pairs.\\n Returns:\\n :obj:`List[int]`: List of `input IDs <../glossary.html#input-ids>`__ with the appropriate special tokens.\\n \\\"\\\"\\\"\\n if token_ids_1 is None:\\n return [self.cls_token_id] + token_ids_0\\n cls = [self.cls_token_id]\\n sep = [self.sep_token_id]\\n return cls + token_ids_0 + sep + token_ids_1 + sep\\n\\n def get_special_tokens_mask(\\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None, already_has_special_tokens: bool = False\\n ) -> List[int]:\\n \\\"\\\"\\\"\\n Retrieve sequence ids from a token list that has no special tokens added. This method is called when adding\\n special tokens using the tokenizer ``prepare_for_model`` method.\\n Args:\\n token_ids_0 (:obj:`List[int]`):\\n List of IDs.\\n token_ids_1 (:obj:`List[int]`, `optional`):\\n Optional second list of IDs for sequence pairs.\\n already_has_special_tokens (:obj:`bool`, `optional`, defaults to :obj:`False`):\\n Whether or not the token list is already formatted with special tokens for the model.\\n Returns:\\n :obj:`List[int]`: A list of integers in the range [0, 1]: 1 for a special token, 0 for a sequence token.\\n \\\"\\\"\\\"\\n\\n if already_has_special_tokens:\\n if token_ids_1 is not None:\\n raise ValueError(\\n \\\"You should not supply a second sequence if the provided sequence of \\\"\\n \\\"ids is already formatted with special tokens for the model.\\\"\\n )\\n return list(map(lambda x: 1 if x in [self.sep_token_id, self.cls_token_id] else 0, token_ids_0))\\n\\n if token_ids_1 is not None:\\n return [1] + ([0] * len(token_ids_0)) + [1] + ([0] * len(token_ids_1)) + [1]\\n return [1] + ([0] * len(token_ids_0)) + [1]\\n\\n def create_token_type_ids_from_sequences(\\n self, token_ids_0: List[int], token_ids_1: Optional[List[int]] = None\\n ) -> List[int]:\\n \\\"\\\"\\\"\\n Create a mask from the two sequences passed to be used in a sequence-pair classification task. A BERT sequence\\n pair mask has the following format:\\n ::\\n 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1\\n | first sequence | second sequence |\\n If :obj:`token_ids_1` is :obj:`None`, this method only returns the first portion of the mask (0s).\\n Args:\\n token_ids_0 (:obj:`List[int]`):\\n List of IDs.\\n token_ids_1 (:obj:`List[int]`, `optional`):\\n Optional second list of IDs for sequence pairs.\\n Returns:\\n :obj:`List[int]`: List of `token type IDs <../glossary.html#token-type-ids>`_ according to the given\\n sequence(s).\\n \\\"\\\"\\\"\\n sep = [self.sep_token_id]\\n cls = [self.cls_token_id]\\n if token_ids_1 is None:\\n return len(cls + token_ids_0 + sep) * [0]\\n return len(cls + token_ids_0 + sep) * [0] + len(token_ids_1 + sep) * [1]\\n\\n def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> Tuple[str]:\\n index = 0\\n if os.path.isdir(save_directory):\\n vocab_file = os.path.join(\\n save_directory, (filename_prefix + \\\"-\\\" if filename_prefix else \\\"\\\") + VOCAB_FILES_NAMES[\\\"vocab_file\\\"]\\n )\\n else:\\n vocab_file = (filename_prefix + \\\"-\\\" if filename_prefix else \\\"\\\") + save_directory\\n with open(vocab_file, \\\"w\\\", encoding=\\\"utf-8\\\") as writer:\\n for token, token_index in sorted(self.vocab.items(), key=lambda kv: kv[1]):\\n if index != token_index:\\n logger.warning(\\n \\\"Saving vocabulary to {}: vocabulary indices are not consecutive.\\\"\\n \\\" Please check that the vocabulary is not corrupted!\\\".format(vocab_file)\\n )\\n index = token_index\\n writer.write(token + \\\"\\\\n\\\")\\n index += 1\\n return (vocab_file,)\"\n },\n {\n \"identifier\": \"MIMIC_Dataset\",\n \"path\": \"dataset/dataset_entity.py\",\n \"snippet\": \"class MIMIC_Dataset(Dataset):\\n def __init__(self, json_path, csv_path, sty_path,image_res,args):\\n self.json_info = json.load(open(json_path,'r'))\\n data_info = pd.read_csv(csv_path)\\n self.img_path_list = np.asarray(data_info.iloc[:,0])\\n self.class_list = np.asarray(data_info.iloc[:,1:])#40 class for fine-grained query list\\n sty_info = pd.read_csv(sty_path)\\n self.sty_dict_info = self.csv_to_dict(sty_info)\\n\\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\\n\\n if args.colourjitter:\\n self.transform = transforms.Compose([ \\n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\\n transforms.RandomHorizontalFlip(),\\n\\n transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.4),\\n transforms.RandomGrayscale(),\\n\\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \\n transforms.ToTensor(),\\n normalize,\\n ])\\n\\n else:\\n self.transform = transforms.Compose([ \\n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\\n transforms.RandomHorizontalFlip(),\\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \\n transforms.ToTensor(),\\n normalize,\\n ]) \\n\\n \\n def csv_to_dict(self,sty_info):\\n tui_list = sty_info.iloc[:,0]\\n sty_list = sty_info.iloc[:,1]\\n sty_dict = defaultdict(list)\\n for idx in tqdm(range(len(tui_list))):\\n tui_idx = tui_list[idx]\\n sty_idx = sty_list[idx]\\n sty_dict[tui_idx] = sty_idx\\n return sty_dict\\n \\n def __len__(self):\\n return len(self.img_path_list)\\n \\n def __getitem__(self, index):\\n img_path = self.img_path_list[index].replace(\\\"/nvme/zhangruipeng/zhangxiaoman/dataset/MIMIC-CXR-DCM/files\\\", '/remote-home/share/medical/public/MIMIC-CXR-JPG/MIMIC-CXR/small/files')\\n class_label = self.class_list[index] \\n\\n # index_transit = np.load(\\\"/remote-home/tianjiedai/KAD/R1_CLIP_LR/A1_DATA/small/index0626.npy\\\")\\n # new_index_json = index_transit[index]\\n # entities = self.json_info[new_index_json]['entities']\\n # captions = self.json_info[new_index_json]['caption']\\n \\n entities = self.json_info[index]['entities']\\n captions = self.json_info[index]['caption']\\n\\n\\n if len(entities) != 0:\\n caption_list = ''\\n entity_details = ''\\n for entity in entities:\\n sub_caption = entity['caption']\\n sub_entities = entity['entity']#搞错了 还不是list\\n sub_entity_details = ''\\n for sub_entity in sub_entities:\\n try:\\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \\n except:\\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \\n entity_details = entity_details + sub_entity_details + ' [SEP] '\\n caption_list = caption_list + sub_caption + ' [SEP] '\\n else:\\n caption_list = ''\\n entity_details = ''\\n for sub_caption in captions:\\n caption_list = caption_list + sub_caption + ' [SEP] '\\n entity_details = caption_list\\n \\n # img = open_jpg(img_path).convert('RGB') \\n img = Image.open(img_path).convert('RGB') \\n image = self.transform(img)\\n return {\\n \\\"image\\\": image,\\n \\\"label\\\": class_label,\\n \\\"caption\\\": caption_list,\\n \\\"entity\\\": entity_details\\n }\"\n },\n {\n \"identifier\": \"Mergetrain_Dataset\",\n \"path\": \"dataset/dataset_entity.py\",\n \"snippet\": \"class Mergetrain_Dataset(Dataset):\\n def __init__(self, json_path, csv_path, sty_path,image_res,args):\\n self.json_info = json.load(open(json_path,'r'))\\n data_info = pd.read_csv(csv_path)\\n self.img_path_list = np.asarray(data_info.iloc[:,0])\\n self.class_list = np.asarray(data_info.iloc[:,2:])#60 class for fine-grained query list\\n self.label_dataset_list = np.asarray(data_info.iloc[:,1])\\n\\n sty_info = pd.read_csv(sty_path)\\n self.sty_dict_info = self.csv_to_dict(sty_info)\\n\\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\\n\\n if args.colourjitter:\\n self.transform = transforms.Compose([ \\n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\\n transforms.RandomHorizontalFlip(),\\n\\n transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4, hue=0.4),\\n transforms.RandomGrayscale(),\\n\\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \\n transforms.ToTensor(),\\n normalize,\\n ])\\n\\n else:\\n self.transform = transforms.Compose([ \\n transforms.RandomResizedCrop(image_res,scale=(0.2, 1.0), interpolation=transforms.InterpolationMode.BICUBIC),\\n transforms.RandomHorizontalFlip(),\\n RandomAugment(2,7,isPIL=True,augs=['Identity','AutoContrast','Equalize','Brightness','Sharpness',\\n 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']), \\n transforms.ToTensor(),\\n normalize,\\n ]) \\n\\n \\n def csv_to_dict(self,sty_info):\\n tui_list = sty_info.iloc[:,0]\\n sty_list = sty_info.iloc[:,1]\\n sty_dict = defaultdict(list)\\n for idx in tqdm(range(len(tui_list))):\\n tui_idx = tui_list[idx]\\n sty_idx = sty_list[idx]\\n sty_dict[tui_idx] = sty_idx\\n return sty_dict\\n \\n def __len__(self):\\n return len(self.img_path_list)\\n \\n def __getitem__(self, index):\\n\\n if self.label_dataset_list[index] == 0:\\n img_path = self.img_path_list[index].replace(\\\"/nvme/zhangruipeng/zhangxiaoman/dataset/MIMIC-CXR-DCM/files\\\", '/remote-home/share/medical/public/MIMIC-CXR-JPG/MIMIC-CXR/small/files')\\n class_label = self.class_list[index] \\n\\n # index_transit = np.load(\\\"/remote-home/tianjiedai/KAD/R1_CLIP_LR/A1_DATA/small/index0626.npy\\\")\\n # new_index_json = index_transit[index]\\n # entities = self.json_info[new_index_json]['entities']\\n # captions = self.json_info[new_index_json]['caption']\\n \\n entities = self.json_info[index]['entities']\\n captions = self.json_info[index]['caption']\\n\\n\\n if len(entities) != 0:\\n caption_list = ''\\n entity_details = ''\\n for entity in entities:\\n sub_caption = entity['caption']\\n sub_entities = entity['entity']#搞错了 还不是list\\n sub_entity_details = ''\\n for sub_entity in sub_entities:\\n try:\\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \\n except:\\n sub_entity_details += ' [ENT] ' + sub_entity['Entity'] \\n entity_details = entity_details + sub_entity_details + ' [SEP] '\\n caption_list = caption_list + sub_caption + ' [SEP] '\\n else:\\n caption_list = ''\\n entity_details = ''\\n for sub_caption in captions:\\n caption_list = caption_list + sub_caption + ' [SEP] '\\n entity_details = caption_list\\n \\n # img = open_jpg(img_path).convert('RGB') \\n # img = Image.open(img_path).convert('RGB') \\n # image = self.transform(img)\\n # return {\\n # \\\"image\\\": image,\\n # \\\"label\\\": class_label,\\n # \\\"caption\\\": caption_list,\\n # \\\"entity\\\": entity_details\\n # }\\n \\n else:\\n img_path = self.img_path_list[index]\\n class_label = self.class_list[index] \\n caption_list = ''\\n head = ['normal', 'pleural effusion', 'opacity', 'pneumothorax', 'edema', 'atelectasis', 'tube', 'consolidation','enlarged cardiomediastinum','tip', 'pneumonia','line','cardiomegaly', 'fracture','calcification',\\n 'device','engorgement', 'nodule', 'wire', 'pacemaker', 'pleural thicken', 'marking', 'scar', 'hyperinflate', 'blunt', 'collapse', 'emphysema', 'aerate', 'mass','infiltration', 'obscure', 'deformity', 'hernia',\\n 'drainage', 'distention', 'shift', 'stent', 'lesion', 'hardware', 'dilation', 'aspiration',\\n 'fibrosis',\\t'No Finding', 'Pleural Other', 'Support Devices', 'Aortic enlargement',\\n 'Clavicle fracture', 'Enlarged PA', 'ILD', 'Lung cavity', 'Lung cyst', 'Mediastinal shift',\\t\\n 'Nodule/Mass', 'Pulmonary fibrosis', 'Rib fracture', 'Other lesion', 'COPD', 'Lung tumor', 'Tuberculosis',\\n 'Other diseases']\\n index_positive = np.where(class_label == 1)\\n entity = np.array(head)[index_positive]\\n entity_details = ''\\n for sub_entity in entity:\\n entity_details = entity_details + sub_entity + ' [SEP] '\\n\\n img = Image.open(img_path).convert('RGB') \\n image = self.transform(img)\\n label_dataset = self.label_dataset_list[index]\\n\\n return {\\n \\\"image\\\": image,\\n \\\"label\\\": class_label,\\n \\\"label_dataset\\\": label_dataset,\\n \\\"caption\\\": caption_list,\\n \\\"entity\\\": entity_details\\n }\"\n },\n {\n \"identifier\": \"Chestxray14_Dataset\",\n \"path\": \"dataset/dataset_entity.py\",\n \"snippet\": \"class Chestxray14_Dataset(Dataset):\\n def __init__(self, csv_path,image_res):\\n data_info = pd.read_csv(csv_path)\\n self.img_path_list = np.asarray(data_info.iloc[:,0])\\n self.class_list = np.asarray(data_info.iloc[:,3:])\\n\\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\\n self.transform = transforms.Compose([ \\n transforms.Resize(image_res, interpolation=transforms.InterpolationMode.BICUBIC),\\n transforms.ToTensor(),\\n normalize,\\n ])\\n \\n def __getitem__(self, index):\\n img_path = self.img_path_list[index].replace('/mnt/petrelfs/zhangxiaoman/DATA/Chestxray/ChestXray8/','/remote-home/share/medical/public/ChestXray8/')\\n class_label = self.class_list[index] \\n img = Image.open(img_path).convert('RGB') \\n image = self.transform(img)\\n return {\\n \\\"image\\\": image,\\n \\\"label\\\": class_label\\n }\\n \\n def __len__(self):\\n return len(self.img_path_list)\"\n },\n {\n \"identifier\": \"CheXpert_Dataset\",\n \"path\": \"dataset/dataset_entity.py\",\n \"snippet\": \"class CheXpert_Dataset(Dataset):\\n def __init__(self, csv_path,image_res):\\n data_info = pd.read_csv(csv_path)\\n self.img_path_list = np.asarray(data_info.iloc[:,0])\\n self.class_list = np.asarray(data_info.iloc[:,[13,7,11,10,15]])\\n\\n normalize = transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))\\n self.transform = transforms.Compose([ \\n transforms.Resize([image_res,image_res], interpolation=transforms.InterpolationMode.BICUBIC),\\n transforms.ToTensor(),\\n normalize,\\n ]) \\n \\n def __getitem__(self, index):\\n img_path = os.path.join('/remote-home/share/tianjiedai/',self.img_path_list[index])\\n class_label = self.class_list[index] \\n img = Image.open(img_path).convert('RGB') \\n image = self.transform(img)\\n return {\\n \\\"image\\\": image,\\n \\\"label\\\": class_label\\n }\\n \\n def __len__(self):\\n return len(self.img_path_list)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import argparse\nimport os\nimport logging\nimport yaml\nimport numpy as np\nimport random\nimport time\nimport datetime\nimport json\nimport math\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.backends.cudnn as cudnn\nimport torch.distributed as dist\nimport socket\nfrom pathlib import Path\nfrom functools import partial\nfrom sklearn.metrics import roc_auc_score\nfrom collections import OrderedDict\nfrom torch.utils.data import DataLoader\nfrom tensorboardX import SummaryWriter\nfrom transformers import AutoModel,BertConfig,AutoTokenizer\nfrom factory import utils\nfrom scheduler import create_scheduler\nfrom optim import create_optimizer\nfrom engine.train import train,valid_on_cheXpert,valid_on_chestxray14\nfrom models.clip_tqn import CLP_clinical,ModelRes,TQN_Model,TQN_Model_Add,ModelDense,CLP_clinical2\nfrom models.tokenization_bert import BertTokenizer\nfrom dataset.dataset_entity import MIMIC_Dataset,Mergetrain_Dataset, Chestxray14_Dataset,CheXpert_Dataset\nfrom io import BytesIO"},"token_num":{"kind":"number","value":17454,"string":"17,454"},"cropped_code":{"kind":"string","value":"\n #### Dataset #### \n print(\"Creating dataset\")\n \n if args.add_dataset == True:\n train_dataset = Mergetrain_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)\n\n else:\n train_dataset = MIMIC_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)\n \n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n train_dataloader = DataLoader(\n train_dataset,\n batch_size=config['batch_size'],\n num_workers=8,\n pin_memory=True,\n sampler=train_sampler, \n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n train_dataloader.num_samples = len(train_dataset)\n train_dataloader.num_batches = len(train_dataloader) \n\n val_dataset = Chestxray14_Dataset(config['chestxray_valid_file'],config['image_res'])\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n val_dataloader =DataLoader(\n val_dataset,\n batch_size=config['batch_size'],\n num_workers=8,\n pin_memory=True,\n sampler=val_sampler,\n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n val_dataloader.num_samples = len(val_dataset)\n val_dataloader.num_batches = len(val_dataloader) \n\n test_dataset = Chestxray14_Dataset(config['chestxray_test_file'],config['image_res'])\n test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n test_dataloader =DataLoader(\n test_dataset,\n batch_size=config['batch_size'],\n num_workers=8,\n pin_memory=True,\n sampler=test_sampler,\n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n test_dataloader.num_samples = len(test_dataset)\n test_dataloader.num_batches = len(test_dataloader) \n\n\n test_dataset_chexpert = CheXpert_Dataset(config['chexpert_valid_file'],config['image_res'])\n test_sampler_chexpert = torch.utils.data.distributed.DistributedSampler(test_dataset_chexpert,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n test_dataloader_chexpert =DataLoader(\n test_dataset_chexpert,\n batch_size=config['batch_size'],\n num_workers=4,\n pin_memory=True,\n sampler=test_sampler_chexpert,\n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n test_dataloader_chexpert.num_samples = len(test_dataset_chexpert)\n test_dataloader_chexpert.num_batches = len(test_dataloader_chexpert)\n \n\n if args.image_encoder_name == 'resnet':\n image_encoder = ModelRes(res_base_model='resnet50').cuda()\n elif args.image_encoder_name == 'dense':\n image_encoder = ModelDense(dense_base_model = 'densenet121').cuda()\n\n\n if args.bert_model_name == 'emilyalsentzer/Bio_ClinicalBERT':\n tokenizer = BertTokenizer.from_pretrained(args.bert_model_name)\n text_encoder = CLP_clinical2(bert_model_name=args.bert_model_name).cuda()\n\n else:\n tokenizer = AutoTokenizer.from_pretrained(args.bert_model_name,do_lower_case=True, local_files_only=True)\n text_encoder = CLP_clinical(bert_model_name=args.bert_model_name).cuda()\n\n\n if args.bert_pretrained:\n\n checkpoint = torch.load(args.bert_pretrained, map_location='cpu')\n state_dict = checkpoint[\"state_dict\"]\n text_encoder.load_state_dict(state_dict)\n print('Load pretrained bert success from: ',args.bert_pretrained)\n if args.freeze_bert:\n for param in text_encoder.parameters():\n param.requires_grad = False\n \n if args.add_dataset:\n if 'lam' in config:\n model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim, lam = config['lam']).cuda()\n else:\n model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim).cuda()\n else:\n if 'lam' in config:\n model = TQN_Model(class_num = args.class_num, lam = config['lam']).cuda()\n else:\n model = TQN_Model(class_num = args.class_num).cuda() \n\n\n model = torch.nn.parallel.DistributedDataParallel(model, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)\n model_without_ddp = model.module\n\n if args.finetune:\n image_encoder_without_ddp = image_encoder\n else:\n image_encoder = torch.nn.parallel.DistributedDataParallel(image_encoder, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)\n image_encoder_without_ddp = image_encoder.module\n\n text_encoder_without_ddp = text_encoder\n \n arg_opt = utils.AttrDict(config['optimizer'])\n"},"all_code":{"kind":"string","value":"\n# import ruamel.yaml as yaml\n\n\n\n\n\n\ndef main(args, config):\n torch.cuda.current_device()\n torch.cuda._initialized = True\n print(\"Total CUDA devices: \", torch.cuda.device_count()) \n torch.set_default_tensor_type('torch.FloatTensor')\n \n utils.init_distributed_mode(args)\n \n device = torch.device(args.device)\n\n # fix the seed for reproducibility\n seed = args.seed + utils.get_rank()\n torch.manual_seed(seed)\n np.random.seed(seed)\n random.seed(seed)\n cudnn.benchmark = True\n\n start_epoch = 0\n max_epoch = config['schedular']['epochs']\n warmup_steps = config['schedular']['warmup_epochs']\n\n num_tasks = utils.get_world_size()\n global_rank = utils.get_rank()\n sampler_rank = global_rank\n print('sampler_rank',sampler_rank,'num_tasks',num_tasks)\n\n #### Dataset #### \n print(\"Creating dataset\")\n \n if args.add_dataset == True:\n train_dataset = Mergetrain_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)\n\n else:\n train_dataset = MIMIC_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)\n \n train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n train_dataloader = DataLoader(\n train_dataset,\n batch_size=config['batch_size'],\n num_workers=8,\n pin_memory=True,\n sampler=train_sampler, \n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n train_dataloader.num_samples = len(train_dataset)\n train_dataloader.num_batches = len(train_dataloader) \n\n val_dataset = Chestxray14_Dataset(config['chestxray_valid_file'],config['image_res'])\n val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n val_dataloader =DataLoader(\n val_dataset,\n batch_size=config['batch_size'],\n num_workers=8,\n pin_memory=True,\n sampler=val_sampler,\n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n val_dataloader.num_samples = len(val_dataset)\n val_dataloader.num_batches = len(val_dataloader) \n\n test_dataset = Chestxray14_Dataset(config['chestxray_test_file'],config['image_res'])\n test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n test_dataloader =DataLoader(\n test_dataset,\n batch_size=config['batch_size'],\n num_workers=8,\n pin_memory=True,\n sampler=test_sampler,\n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n test_dataloader.num_samples = len(test_dataset)\n test_dataloader.num_batches = len(test_dataloader) \n\n\n test_dataset_chexpert = CheXpert_Dataset(config['chexpert_valid_file'],config['image_res'])\n test_sampler_chexpert = torch.utils.data.distributed.DistributedSampler(test_dataset_chexpert,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)\n test_dataloader_chexpert =DataLoader(\n test_dataset_chexpert,\n batch_size=config['batch_size'],\n num_workers=4,\n pin_memory=True,\n sampler=test_sampler_chexpert,\n collate_fn=None,\n worker_init_fn=utils.seed_worker,\n drop_last=True,\n ) \n test_dataloader_chexpert.num_samples = len(test_dataset_chexpert)\n test_dataloader_chexpert.num_batches = len(test_dataloader_chexpert)\n \n\n if args.image_encoder_name == 'resnet':\n image_encoder = ModelRes(res_base_model='resnet50').cuda()\n elif args.image_encoder_name == 'dense':\n image_encoder = ModelDense(dense_base_model = 'densenet121').cuda()\n\n\n if args.bert_model_name == 'emilyalsentzer/Bio_ClinicalBERT':\n tokenizer = BertTokenizer.from_pretrained(args.bert_model_name)\n text_encoder = CLP_clinical2(bert_model_name=args.bert_model_name).cuda()\n\n else:\n tokenizer = AutoTokenizer.from_pretrained(args.bert_model_name,do_lower_case=True, local_files_only=True)\n text_encoder = CLP_clinical(bert_model_name=args.bert_model_name).cuda()\n\n\n if args.bert_pretrained:\n\n checkpoint = torch.load(args.bert_pretrained, map_location='cpu')\n state_dict = checkpoint[\"state_dict\"]\n text_encoder.load_state_dict(state_dict)\n print('Load pretrained bert success from: ',args.bert_pretrained)\n if args.freeze_bert:\n for param in text_encoder.parameters():\n param.requires_grad = False\n \n if args.add_dataset:\n if 'lam' in config:\n model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim, lam = config['lam']).cuda()\n else:\n model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim).cuda()\n else:\n if 'lam' in config:\n model = TQN_Model(class_num = args.class_num, lam = config['lam']).cuda()\n else:\n model = TQN_Model(class_num = args.class_num).cuda() \n\n\n model = torch.nn.parallel.DistributedDataParallel(model, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)\n model_without_ddp = model.module\n\n if args.finetune:\n image_encoder_without_ddp = image_encoder\n else:\n image_encoder = torch.nn.parallel.DistributedDataParallel(image_encoder, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)\n image_encoder_without_ddp = image_encoder.module\n\n text_encoder_without_ddp = text_encoder\n \n arg_opt = utils.AttrDict(config['optimizer'])"},"next_line":{"kind":"string","value":" optimizer = create_optimizer(arg_opt, model_without_ddp,image_encoder_without_ddp,text_encoder_without_ddp)"},"gold_snippet_index":{"kind":"number","value":2,"string":"2"},"created_at":{"kind":"string","value":"2023-10-30 00:24:16+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5696,"cells":{"repo_name":{"kind":"string","value":"ifrit98/storage-subnet"},"file_path":{"kind":"string","value":"neurons/miner.py"},"context":{"kind":"list like","value":[{"identifier":"hash_data","path":"storage/shared/ecc.py","snippet":"def hash_data(data):\n \"\"\"\n Compute a SHA3-256 hash of the input data and return its integer representation.\n\n The function handles both byte-like and non-byte-like inputs by converting non-byte inputs to\n strings and then encoding to bytes before hashing.\n\n Parameters:\n - data (bytes | bytearray | object): Data to be hashed.\n\n Returns:\n - int: Integer representation of the SHA3-256 hash of the input data.\n\n Raises:\n - TypeError: If the hashing operation encounters an incompatible data type.\n \"\"\"\n if not isinstance(data, (bytes, bytearray)):\n data_str = str(data)\n data = data_str.encode()\n h = hashlib.sha3_256(data).hexdigest()\n return int(h, 16)"},{"identifier":"setup_CRS","path":"storage/shared/ecc.py","snippet":"def setup_CRS(curve=\"P-256\"):\n \"\"\"\n Generate a pair of random points to serve as a Common Reference String (CRS) for elliptic curve operations.\n\n The CRS is essential for various cryptographic protocols that rely on a shared reference\n between parties, typically for the purpose of ensuring consistent cryptographic operations.\n\n Parameters:\n - curve (str, optional): Name of the elliptic curve to use; defaults to \"P-256\".\n\n Returns:\n - tuple(ECC.EccPoint, ECC.EccPoint): A 2-tuple of ECC.EccPoint instances representing the base points (g, h).\n\n Raises:\n - ValueError: If the specified elliptic curve name is not recognized.\n \"\"\"\n curve_obj = ECC.generate(curve=curve)\n g = curve_obj.pointQ # Base point\n h = ECC.generate(curve=curve).pointQ # Another random point\n return g, h"},{"identifier":"ECCommitment","path":"storage/shared/ecc.py","snippet":"class ECCommitment:\n \"\"\"\n Elliptic Curve based commitment scheme allowing one to commit to a chosen value while keeping it hidden to others.\n\n Attributes:\n g (ECC.EccPoint): The base point of the elliptic curve used as part of the commitment.\n h (ECC.EccPoint): Another random point on the elliptic curve used as part of the commitment.\n\n Methods:\n commit(m): Accepts a message, hashes it, and produces a commitment to the hashed message.\n open(c, m_val, r): Accepts a commitment, a hashed message, and a random value to verify the commitment.\n\n The `commit` method will print the commitment process, and the `open` method will print the verification process.\n \"\"\"\n\n def __init__(self, g, h, verbose=False):\n self.g = g # Base point of the curve\n self.h = h # Another random point on the curve\n self.verbose = verbose\n\n def commit(self, m): # AKA Seal.\n \"\"\"\n Create a cryptographic commitment to a message.\n\n The message is hashed, and the hash is used along with a random number to form the commitment\n using the public parameters g and h. The commitment can be verified with the `open` method.\n\n Parameters:\n - m (bytes | bytearray | object): The message to commit to.\n\n Returns:\n - tuple: A 3-tuple (commitment, hashed message value, random number used in the commitment).\n\n Side Effects:\n - This method will print the commitment details to the console.\n\n Raises:\n - Exception: If the commitment calculation fails.\n \"\"\"\n m_val = hash_data(m) # Compute hash of the data\n r = random.randint(1, 2**256)\n c1 = self.g.__mul__(m_val)\n c2 = self.h.__mul__(r)\n c = c1.__add__(c2)\n if self.verbose:\n print(\n f\"Committing: Data = {m}\\nHashed Value = {m_val}\\nRandom Value = {r}\\nComputed Commitment = {c}\\n\"\n )\n return c, m_val, r\n\n def open(self, c, m_val, r):\n \"\"\"\n Verify a commitment using the original message hash and randomness.\n\n This method recomputes the commitment using the public parameters and compares it with\n the provided commitment to check its validity.\n\n Parameters:\n - c (ECC.EccPoint): The commitment point to verify.\n - m_val (int): The integer value of the hashed message used in the commitment.\n - r (int): The random number used in the commitment.\n\n Returns:\n - bool: True if the verification succeeds (commitment is valid), False otherwise.\n\n Side Effects:\n - This method will print the verification details to the console.\n\n Raises:\n - Exception: If the verification calculation fails.\n \"\"\"\n c1 = self.g.__mul__(m_val)\n c2 = self.h.__mul__(r)\n computed_c = c1.__add__(c2)\n if self.verbose:\n print(\n f\"\\nOpening: Hashed Value = {m_val}\\nRandom Value = {r}\\nRecomputed Commitment = {computed_c}\\nOriginal Commitment = {c}\"\n )\n return computed_c == c"},{"identifier":"ecc_point_to_hex","path":"storage/shared/ecc.py","snippet":"def ecc_point_to_hex(point):\n \"\"\"\n Convert an elliptic curve point to a hexadecimal string.\n\n This encoding is typically used for compact representation or for preparing the data\n to be transmitted over protocols that may not support binary data.\n\n Parameters:\n - point (ECC.EccPoint): An ECC point to convert.\n\n Returns:\n - str: Hexadecimal string representing the elliptic curve point.\n\n Raises:\n - AttributeError: If the input is not a valid ECC point with accessible x and y coordinates.\n \"\"\"\n point_str = \"{},{}\".format(point.x, point.y)\n return binascii.hexlify(point_str.encode()).decode()"},{"identifier":"hex_to_ecc_point","path":"storage/shared/ecc.py","snippet":"def hex_to_ecc_point(hex_str, curve):\n \"\"\"\n Convert a hexadecimal string back into an elliptic curve point.\n\n This function is typically used to deserialize an ECC point that has been transmitted or stored as a hex string.\n\n Parameters:\n - hex_str (str): The hex string representing an elliptic curve point.\n - curve (str): The name of the elliptic curve the point belongs to.\n\n Returns:\n - ECC.EccPoint: The elliptic curve point represented by the hex string.\n\n Raises:\n - ValueError: If the hex string is not properly formatted or does not represent a valid point on the specified curve.\n \"\"\"\n point_str = binascii.unhexlify(hex_str).decode()\n x, y = map(int, point_str.split(\",\"))\n return ECC.EccPoint(x, y, curve=curve)"},{"identifier":"MerkleTree","path":"storage/shared/merkle.py","snippet":"class MerkleTree(object):\n \"\"\"\n Represents a Merkle Tree, a data structure used for efficiently summarizing and verifying the\n integrity of large sets of data. The Merkle Tree is a binary tree where each leaf node is the hash\n of a data block and every non-leaf node is the hash of its children nodes.\n\n Attributes:\n hash_function (callable): The hash function used for generating hashes of the blocks\n and non-leaf nodes in the Merkle Tree.\n leaves (list): A list where each element is a bytearray representing the hashed value of a leaf.\n levels (list of lists): A list of lists where each sublist represents a level of the tree, starting\n from the leaves up to the root.\n is_ready (bool): Indicates whether the tree has been fully constructed and is ready to provide\n the Merkle root and proofs.\n\n Methods:\n add_leaf(values, do_hash=False): Adds one or multiple leaves to the tree. If `do_hash` is True,\n it will hash the values before adding them as leaves.\n get_leaf(index): Retrieves the hexadecimal string representation of a leaf at the given index.\n get_leaf_count(): Returns the total number of leaves in the tree.\n get_tree_ready_state(): Checks if the tree has been fully constructed.\n make_tree(): Constructs the Merkle Tree from the current leaves. This method must be called\n after all leaves are added and before retrieving the Merkle root or proofs.\n get_merkle_root(): Retrieves the Merkle root as a hexadecimal string if the tree is ready.\n get_proof(index): Generates a proof of inclusion for the leaf at the given index. This proof\n consists of a list of sibling hashes that, when combined with the target leaf,\n can reproduce the Merkle root.\n update_leaf(index, new_value): Updates the value of the leaf at the given index with `new_value`\n and recalculates the hashes up the tree to reflect this change.\n serialize(): Converts the Merkle Tree into a JSON-formatted string for storage or transmission.\n deserialize(json_data, hash_type=\"sha3_256\"): Reconstructs the Merkle Tree from a JSON string,\n using the specified hash function.\n\n Raises:\n Exception: If the `hash_type` provided during initialization is not supported or recognized.\n\n Example:\n # Create a Merkle tree using the SHA3-256 hash function\n merkle_tree = MerkleTree(hash_type='sha3_256')\n\n # Add data blocks (as leaves) to the tree\n merkle_tree.add_leaf(['block1', 'block2', 'block3'], do_hash=True)\n\n # Construct the tree\n merkle_tree.make_tree()\n\n # Retrieve the Merkle root\n root = merkle_tree.get_merkle_root()\n\n # Get proof of inclusion for the first data block\n proof = merkle_tree.get_proof(0)\n\n # Update the value of the first leaf and reconstruct the tree\n merkle_tree.update_leaf(0, 'new_block1_hashed_value')\n merkle_tree.make_tree()\n\n # Serialize the tree for storage\n serialized_tree = merkle_tree.serialize()\n\n # Deserialize the tree for later use\n deserialized_tree = MerkleTree.deserialize(serialized_tree, hash_type='sha3_256')\n\n Note:\n The hash_function attribute is determined by the hash_type parameter provided at initialization.\n Only hash types supported by the `hashlib` library can be used. Attempting to use an unsupported\n hash type will result in an exception.\n \"\"\"\n\n def __init__(self, hash_type=\"sha3_256\"):\n hash_type = hash_type.lower()\n if hash_type in [\"sha3_256\"]:\n self.hash_function = getattr(hashlib, hash_type)\n else:\n raise Exception(\"`hash_type` {} nor supported\".format(hash_type))\n\n self.reset_tree()\n\n def __eq__(self, other):\n if not isinstance(other, MerkleTree):\n return False\n return self.serialize() == other.serialize()\n\n def _to_hex(self, x):\n try: # python3\n return x.hex()\n except: # python2\n return binascii.hexlify(x)\n\n def reset_tree(self):\n self.leaves = list()\n self.levels = None\n self.is_ready = False\n\n def add_leaf(self, values, do_hash=False):\n self.is_ready = False\n # check if single leaf\n if not isinstance(values, tuple) and not isinstance(values, list):\n values = [values]\n for v in values:\n if do_hash:\n v = v.encode(\"utf-8\")\n v = self.hash_function(v).hexdigest()\n v = bytearray.fromhex(v)\n self.leaves.append(v)\n\n def get_leaf(self, index):\n return self._to_hex(self.leaves[index])\n\n def get_leaf_count(self):\n return len(self.leaves)\n\n def get_tree_ready_state(self):\n return self.is_ready\n\n def _calculate_next_level(self):\n solo_leave = None\n N = len(self.levels[0]) # number of leaves on the level\n if N % 2 == 1: # if odd number of leaves on the level\n solo_leave = self.levels[0][-1]\n N -= 1\n\n new_level = []\n for l, r in zip(self.levels[0][0:N:2], self.levels[0][1:N:2]):\n new_level.append(self.hash_function(l + r).digest())\n if solo_leave is not None:\n new_level.append(solo_leave)\n self.levels = [\n new_level,\n ] + self.levels # prepend new level\n\n def make_tree(self):\n \"\"\"\n Constructs the Merkle Tree from the leaves that have been added.\n\n This must be called after adding all the leaves and before calling\n get_merkle_root or get_proof to ensure the tree is constructed.\n \"\"\"\n self.is_ready = False\n if self.get_leaf_count() > 0:\n self.levels = [\n self.leaves,\n ]\n while len(self.levels[0]) > 1:\n self._calculate_next_level()\n self.is_ready = True\n\n def get_merkle_root(self):\n if self.is_ready:\n if self.levels is not None:\n return self._to_hex(self.levels[0][0])\n else:\n return None\n else:\n return None\n\n def get_proof(self, index):\n \"\"\"\n Generates the proof for the existence of a leaf at the specified index within the Merkle Tree.\n\n A Merkle proof is a collection of sibling hashes on the path from a leaf to the root of the tree.\n This proof can be used to independently verify that a leaf is indeed part of the Merkle tree without\n needing the entire tree. Each element of the proof shows the direction ('left' or 'right') and the\n corresponding hash that pairs with the path to the root.\n\n Parameters:\n index (int): The index of the target leaf for which to generate the Merkle proof. The index must\n correspond to the position of the leaf in the original list of leaves when the tree\n was constructed.\n\n Returns:\n list of dicts: A list where each dictionary contains a single key-value pair. The key is either\n 'left' or 'right', indicating the side of the sibling hash, and the value is a\n string representing the hexadecimal hash value of the sibling. If the tree is not\n ready or the index is out of bounds, None is returned.\n\n Raises:\n IndexError: If the index provided is not within the range of the leaves in the tree.\n ValueError: If the tree has not been constructed by calling `make_tree` method, or the index\n is not an integer.\n\n Example:\n # Assuming `merkle_tree` is an instance of `MerkleTree` and has been populated with leaves and made ready\n proof = merkle_tree.get_proof(2)\n print(proof) # Outputs something like [{'left': 'abcd...'}, {'right': 'ef01...'}]\n\n Note:\n The Merkle proof is only valid if the tree is in the ready state (`is_ready` attribute is True),\n which occurs after the `make_tree` method has been called. If the tree is not ready or the index\n is not valid, the method will return None.\n \"\"\"\n if self.levels is None:\n return None\n elif not self.is_ready or index > len(self.leaves) - 1 or index < 0:\n return None\n else:\n proof = []\n for x in range(len(self.levels) - 1, 0, -1):\n level_len = len(self.levels[x])\n if (index == level_len - 1) and (\n level_len % 2 == 1\n ): # skip if this is an odd end node\n index = int(index / 2.0)\n continue\n is_right_node = index % 2\n sibling_index = index - 1 if is_right_node else index + 1\n sibling_pos = \"left\" if is_right_node else \"right\"\n sibling_value = self._to_hex(self.levels[x][sibling_index])\n proof.append({sibling_pos: sibling_value})\n index = int(index / 2.0)\n return proof\n\n def update_leaf(self, index, new_value):\n \"\"\"\n Updates the value of a leaf at a given index in the Merkle Tree and recalculates the hashes along\n the path from the updated leaf to the root of the tree to reflect the change.\n\n This method allows the Merkle Tree to maintain integrity by ensuring that any updates to the leaf\n nodes are propagated upwards, resulting in a new Merkle root that represents the current state of\n the leaves.\n\n Parameters:\n index (int): The index of the leaf to update. The index is zero-based and must be less than\n the number of leaves in the tree.\n new_value (str): The new value in hexadecimal format to which the leaf should be updated. This\n value should be a valid hexadecimal string that represents the hashed data\n if hashing was applied to the leaves upon tree construction.\n\n Returns:\n None\n\n Raises:\n ValueError: If the tree is not ready for updates (i.e., `is_ready` is False), if the index is\n not an integer, if the new_value is not a hexadecimal string, or if the index is\n out of bounds (less than 0 or greater than or equal to the number of leaves).\n IndexError: If the index is out of the range of current leaves.\n\n Example:\n # Assuming `merkle_tree` is an instance of `MerkleTree`, populated with leaves and made ready.\n merkle_tree.update_leaf(0, 'a1b2c3d4e5f67890')\n # The leaf at index 0 is updated, and changes are propagated to the root.\n\n Note:\n The tree must have been constructed and be in a ready state before calling this method. If the\n tree has not been made by calling the `make_tree` method, or the index is invalid, this method\n will not perform an update and will return None.\n \"\"\"\n if not self.is_ready:\n return None\n new_value = bytearray.fromhex(new_value)\n self.levels[-1][index] = new_value\n for x in range(len(self.levels) - 1, 0, -1):\n parent_index = index // 2\n left_child = self.levels[x][parent_index * 2]\n try:\n right_child = self.levels[x][parent_index * 2 + 1]\n except IndexError:\n right_child = bytearray()\n self.levels[x - 1][parent_index] = self.hash_function(\n left_child + right_child\n ).digest()\n index = parent_index\n\n def serialize(self):\n \"\"\"\n Serializes the MerkleTree object into a JSON string.\n \"\"\"\n # Convert the bytearray leaves and levels to hex strings for serialization\n leaves = [self._to_hex(leaf) for leaf in self.leaves]\n levels = None\n if self.levels is not None:\n levels = []\n for level in self.levels:\n levels.append([self._to_hex(item) for item in level])\n\n # Construct a dictionary with the MerkleTree properties\n merkle_tree_data = {\n \"leaves\": leaves,\n \"levels\": levels,\n \"is_ready\": self.is_ready,\n }\n\n # Convert the dictionary to a JSON string\n return json.dumps(merkle_tree_data)\n\n @classmethod\n def deserialize(cls, json_data, hash_type=\"sha3_256\"):\n \"\"\"\n Deserializes the JSON string into a MerkleTree object.\n \"\"\"\n # Convert the JSON string back to a dictionary\n merkle_tree_data = json.loads(json_data)\n\n # Create a new MerkleTree object\n m_tree = cls(hash_type)\n\n # Convert the hex strings back to bytearrays and set the leaves and levels\n m_tree.leaves = [bytearray.fromhex(leaf) for leaf in merkle_tree_data[\"leaves\"]]\n if merkle_tree_data[\"levels\"] is not None:\n m_tree.levels = []\n for level in merkle_tree_data[\"levels\"]:\n m_tree.levels.append([bytearray.fromhex(item) for item in level])\n m_tree.is_ready = merkle_tree_data[\"is_ready\"]\n\n return m_tree"},{"identifier":"b64_encode","path":"storage/shared/utils.py","snippet":"def b64_encode(data: Union[bytes, str, List[str], List[bytes], dict]) -> str:\n \"\"\"\n Encodes the given data into a base64 string. If the data is a list or dictionary of bytes, it converts\n the bytes into hexadecimal strings before encoding.\n\n Args:\n data (list or dict): The data to be base64 encoded. Can be a list of bytes or a dictionary with bytes values.\n\n Returns:\n str: The base64 encoded string of the input data.\n\n Raises:\n TypeError: If the input is not a list, dict, or bytes.\n \"\"\"\n if isinstance(data, bytes):\n data = data.hex()\n if isinstance(data, list) and len(data) and isinstance(data[0], bytes):\n data = [d.hex() for d in data]\n if isinstance(data, dict) and isinstance(data[list(data.keys())[0]], bytes):\n data = {k: v.hex() for k, v in data.items()}\n return base64.b64encode(json.dumps(data).encode()).decode(\"utf-8\")"},{"identifier":"b64_decode","path":"storage/shared/utils.py","snippet":"def b64_decode(data: bytes, decode_hex: bool = False, encrypted: bool = False):\n \"\"\"\n Decodes a base64 string into a list or dictionary. If decode_hex is True, it converts any hexadecimal strings\n within the data back into bytes.\n\n Args:\n data (bytes or str): The base64 encoded data to be decoded.\n decode_hex (bool): A flag to indicate whether to decode hex strings into bytes. Defaults to False.\n\n Returns:\n list or dict: The decoded data. Returns a list if the original encoded data was a list, and a dict if it was a dict.\n\n Raises:\n ValueError: If the input is not properly base64 encoded or if hex decoding fails.\n \"\"\"\n data = data.decode(\"utf-8\") if isinstance(data, bytes) else data\n decoded_data = json.loads(\n base64.b64decode(data) if encrypted else base64.b64decode(data).decode(\"utf-8\")\n )\n if decode_hex:\n try:\n decoded_data = (\n [bytes.fromhex(d) for d in decoded_data]\n if isinstance(decoded_data, list)\n else {k: bytes.fromhex(v) for k, v in decoded_data.items()}\n )\n except:\n pass\n return decoded_data"},{"identifier":"chunk_data","path":"storage/shared/utils.py","snippet":"def chunk_data(data: bytes, chunksize: int) -> List[bytes]:\n \"\"\"\n Generator function that chunks the given data into pieces of a specified size.\n\n Args:\n data (bytes): The binary data to be chunked.\n chunksize (int): The size of each chunk in bytes.\n\n Yields:\n bytes: A chunk of the data with the size equal to 'chunksize' or the remaining size of data.\n\n Raises:\n ValueError: If 'chunksize' is less than or equal to 0.\n \"\"\"\n for i in range(0, len(data), chunksize):\n yield data[i : i + chunksize]"},{"identifier":"safe_key_search","path":"storage/shared/utils.py","snippet":"async def safe_key_search(database: aioredis.Redis, pattern: str) -> List[str]:\n \"\"\"\n Safely search for keys in the database that doesn't block.\n `scan_iter` uses cursor under the hood.\n \"\"\"\n return [key for key in await database.scan_iter(pattern)]"},{"identifier":"run","path":"storage/miner/run.py","snippet":"def run(self):\n \"\"\"\n Initiates and manages the main loop for the miner on the Bittensor network.\n\n This function performs the following primary tasks:\n 1. Check for registration on the Bittensor network.\n 2. Attaches the miner's forward, blacklist, and priority functions to its axon.\n 3. Starts the miner's axon, making it active on the network.\n 4. Regularly updates the metagraph with the latest network state.\n 5. Optionally sets weights on the network, defining how much trust to assign to other nodes.\n 6. Handles graceful shutdown on keyboard interrupts and logs unforeseen errors.\n\n The miner continues its operations until `should_exit` is set to True or an external interruption occurs.\n During each epoch of its operation, the miner waits for new blocks on the Bittensor network, updates its\n knowledge of the network (metagraph), and sets its weights. This process ensures the miner remains active\n and up-to-date with the network's latest state.\n\n Note:\n - The function leverages the global configurations set during the initialization of the miner.\n - The miner's axon serves as its interface to the Bittensor network, handling incoming and outgoing requests.\n\n Raises:\n KeyboardInterrupt: If the miner is stopped by a manual interruption.\n Exception: For unforeseen errors during the miner's operation, which are logged for diagnosis.\n \"\"\"\n block_handler_substrate = SubstrateInterface(\n ss58_format=bt.__ss58_format__,\n use_remote_preset=True,\n url=self.subtensor.chain_endpoint,\n type_registry=bt.__type_registry__,\n )\n\n netuid = self.config.netuid\n\n # --- Check for registration.\n if not self.subtensor.is_hotkey_registered(\n netuid=netuid,\n hotkey_ss58=self.wallet.hotkey.ss58_address,\n ):\n bt.logging.error(\n f\"Wallet: {self.wallet} is not registered on netuid {netuid}\"\n f\"Please register the hotkey using `btcli subnets register` before trying again\"\n )\n exit()\n\n tempo = block_handler_substrate.query(\n module=\"SubtensorModule\", storage_function=\"Tempo\", params=[netuid]\n ).value\n\n last_extrinsic_hash = None\n checked_extrinsics_count = 0\n should_retry = False\n\n def handler(obj, update_nr, subscription_id):\n current_block = obj[\"header\"][\"number\"]\n block_hash = block_handler_substrate.get_block_hash(current_block)\n bt.logging.debug(f\"New block #{current_block}\")\n\n bt.logging.debug(\n f\"Blocks since epoch: {(current_block + netuid + 1) % (tempo + 1)}\"\n )\n\n nonlocal last_extrinsic_hash\n nonlocal checked_extrinsics_count\n nonlocal should_retry\n\n if last_extrinsic_hash != None:\n try:\n receipt = block_handler_substrate.retrieve_extrinsic_by_hash(\n block_hash, last_extrinsic_hash\n )\n bt.logging.debug(\n f\"Last set-weights call: {'Success' if receipt.is_success else format('Failure, reason: %s', receipt.error_message['name'] if receipt.error_message != None else 'nil')}\"\n )\n\n should_retry = False\n last_extrinsic_hash = None\n checked_extrinsics_count = 0\n except Exception as e:\n checked_extrinsics_count += 1\n bt.logging.debug(f\"An error occurred, extrinsic not found in block.\")\n finally:\n if checked_extrinsics_count >= 20:\n should_retry = True\n last_extrinsic_hash = None\n checked_extrinsics_count = 0\n\n if ((current_block + netuid + 1) % (tempo + 1) == 0) or should_retry:\n bt.logging.info(\n f\"New epoch started, setting weights at block {current_block}\"\n )\n with self.subtensor.substrate as substrate:\n call = substrate.compose_call(\n call_module=\"SubtensorModule\",\n call_function=\"set_weights\",\n call_params={\n \"dests\": [self.my_subnet_uid],\n \"weights\": [65535],\n \"netuid\": netuid,\n \"version_key\": 1,\n },\n )\n\n # Period dictates how long the extrinsic will stay as part of waiting pool\n extrinsic = substrate.create_signed_extrinsic(\n call=call, keypair=self.wallet.hotkey, era={\"period\": 1000}\n )\n\n dry_run = runtime_call(\n substrate=substrate,\n api=\"TaggedTransactionQueue\",\n method=\"validate_transaction\",\n params=[\"InBlock\", extrinsic, block_hash],\n block_hash=block_hash,\n )\n bt.logging.debug(dry_run)\n\n response = substrate.submit_extrinsic(\n extrinsic,\n wait_for_inclusion=False,\n wait_for_finalization=False,\n )\n\n result_data = substrate.rpc_request(\"author_pendingExtrinsics\", [])\n for extrinsic_data in result_data[\"result\"]:\n extrinsic = substrate.runtime_config.create_scale_object(\n \"Extrinsic\", metadata=substrate.metadata\n )\n extrinsic.decode(\n ScaleBytes(extrinsic_data),\n check_remaining=substrate.config.get(\"strict_scale_decode\"),\n )\n\n if extrinsic.value[\"extrinsic_hash\"] == response.extrinsic_hash:\n bt.logging.debug(\n \"Weights transaction is in the pending transaction pool\"\n )\n\n last_extrinsic_hash = response.extrinsic_hash\n should_retry = False\n\n # --- Update the miner storage information periodically.\n if not should_retry:\n update_storage_stats(self)\n bt.logging.debug(\"Storage statistics updated...\")\n\n if self.should_exit:\n return True\n\n block_handler_substrate.subscribe_block_headers(handler)"},{"identifier":"set_weights","path":"storage/miner/set_weights.py","snippet":"def set_weights_for_miner(\n subtensor: \"bt.subtensor\",\n netuid: int,\n uid: int,\n wallet: \"bt.wallet\",\n metagraph: \"bt.metagraph\",\n wandb_on: bool = False,\n tempo: int = 360,\n wait_for_inclusion: bool = False,\n wait_for_finalization: bool = False,\n) -> bool:"},{"identifier":"compute_subsequent_commitment","path":"storage/miner/utils.py","snippet":"def compute_subsequent_commitment(data, previous_seed, new_seed, verbose=False):\n \"\"\"\n Computes a new commitment based on provided data and a change from an old seed to a new seed.\n This function is typically used in cryptographic operations to update commitments without\n altering the underlying data.\n\n Parameters:\n - data: The original data for which the commitment is being updated.\n - previous_seed: The seed used in the previous commitment.\n - new_seed: The seed to be used for the new commitment.\n - verbose (bool): If True, additional debug information will be printed. Defaults to False.\n\n Returns:\n - A tuple containing the new commitment and the proof of the old commitment.\n\n If verbose is set to True, debug information about the types and contents of the parameters\n will be printed to aid in debugging.\n \"\"\"\n if verbose:\n bt.logging.debug(\"IN COMPUTE SUBESEQUENT COMMITMENT\")\n bt.logging.debug(\"type of data :\", type(data))\n bt.logging.debug(\"type of prev_seed:\", type(previous_seed))\n bt.logging.debug(\"type of new_seed :\", type(new_seed))\n proof = hash_data(data + previous_seed)\n return hash_data(str(proof).encode(\"utf-8\") + new_seed), proof"},{"identifier":"save_data_to_filesystem","path":"storage/miner/utils.py","snippet":"def save_data_to_filesystem(data, directory, filename):\n \"\"\"\n Saves data to the filesystem at the specified directory and filename. If the directory does\n not exist, it is created.\n\n Parameters:\n - data: The data to be saved.\n - directory (str): The directory path where the data should be saved.\n - filename (str): The name of the file to save the data in.\n\n Returns:\n - file_path (str): The full path to the saved file.\n\n This function is useful for persisting data to the disk.\n \"\"\"\n # Ensure the directory exists\n directory = os.path.expanduser(directory)\n os.makedirs(directory, exist_ok=True)\n file_path = os.path.join(directory, filename)\n with open(file_path, \"wb\") as file:\n file.write(data)\n return file_path"},{"identifier":"load_from_filesystem","path":"storage/miner/utils.py","snippet":"def load_from_filesystem(filepath):\n \"\"\"\n Loads data from a file in the filesystem.\n\n Parameters:\n - filepath (str): The path to the file from which data is to be loaded.\n\n Returns:\n - data: The data read from the file.\n\n This function is a straightforward utility for reading binary data from a file.\n \"\"\"\n with open(os.path.expanduser(filepath), \"rb\") as file:\n data = file.read()\n return data"},{"identifier":"commit_data_with_seed","path":"storage/miner/utils.py","snippet":"def commit_data_with_seed(committer, data_chunks, n_chunks, seed):\n \"\"\"\n Commits chunks of data with a seed using a Merkle tree structure to create a proof of\n integrity for each chunk. This function is used in environments where the integrity\n and order of data need to be verifiable.\n\n Parameters:\n - committer: The committing object, which should have a commit method.\n - data_chunks (list): A list of data chunks to be committed.\n - n_chunks (int): The number of chunks expected to be committed.\n - seed: A seed value that is combined with data chunks before commitment.\n\n Returns:\n - randomness (list): A list of randomness values associated with each data chunk's commitment.\n - chunks (list): The list of original data chunks that were committed.\n - points (list): A list of commitment points in hex format.\n - merkle_tree (MerkleTree): A Merkle tree constructed from the commitment points.\n\n This function handles the conversion of commitment points to hex format and adds them to the\n Merkle tree. The completed tree represents the combined commitments.\n \"\"\"\n merkle_tree = MerkleTree()\n\n # Commit each chunk of data\n randomness, chunks, points = [None] * n_chunks, [None] * n_chunks, [None] * n_chunks\n for index, chunk in enumerate(data_chunks):\n c, m_val, r = committer.commit(chunk + str(seed).encode())\n c_hex = ecc_point_to_hex(c)\n randomness[index] = r\n chunks[index] = chunk\n points[index] = c_hex\n merkle_tree.add_leaf(c_hex)\n\n # Create the tree from the leaves\n merkle_tree.make_tree()\n return randomness, chunks, points, merkle_tree"},{"identifier":"init_wandb","path":"storage/miner/utils.py","snippet":"def init_wandb(self, reinit=False):\n \"\"\"Starts a new wandb run.\"\"\"\n tags = [\n self.wallet.hotkey.ss58_address,\n storage.__version__,\n str(storage.__spec_version__),\n f\"netuid_{self.metagraph.netuid}\",\n ]\n\n if self.config.mock:\n tags.append(\"mock\")\n\n wandb_config = {\n key: copy.deepcopy(self.config.get(key, None))\n for key in (\"neuron\", \"reward\", \"netuid\", \"wandb\")\n }\n\n if wandb_config[\"neuron\"] is not None:\n wandb_config[\"neuron\"].pop(\"full_path\", None)\n\n self.wandb = wandb.init(\n anonymous=\"allow\",\n reinit=reinit,\n project=self.config.wandb.project_name,\n entity=self.config.wandb.entity,\n config=wandb_config,\n mode=\"offline\" if self.config.wandb.offline else \"online\",\n dir=self.config.neuron.full_path\n if self.config.neuron is not None\n else \"wandb_logs\",\n tags=tags,\n notes=self.config.wandb.notes,\n )\n bt.logging.success(\n prefix=\"Started a new wandb run\",\n sufix=f\"<blue> {self.wandb.name} </blue>\",\n )"},{"identifier":"get_directory_size","path":"storage/miner/utils.py","snippet":"def get_directory_size(path):\n \"\"\"\n Calculates the total size of files in a specified directory.\n\n This function traverses the directory at the given path, including all subdirectories, and sums up the size\n of each file to calculate the total directory size.\n\n Args:\n path (str): The file path of the directory whose size is to be calculated.\n\n Returns:\n int: The total size of the directory in bytes (B).\n\n Usage:\n directory_size_gb = get_directory_size('/path/to/directory')\n \"\"\"\n total_size = 0\n path = os.path.expanduser(path)\n for dirpath, dirnames, filenames in os.walk(path):\n for f in filenames:\n fp = os.path.join(dirpath, f)\n if not os.path.islink(fp):\n total_size += os.path.getsize(fp)\n return total_size"},{"identifier":"get_free_disk_space","path":"storage/miner/utils.py","snippet":"def get_free_disk_space(path=\".\"):\n \"\"\"\n Retrieves the free disk space for the drive containing the specified path.\n\n This function provides the free disk space of the drive on which the specified path resides.\n It's useful for understanding the storage capacity and usage of the system where the miner is running.\n\n Args:\n path (str): A file path on the drive whose free disk space is to be fetched. Typically, you can\n provide the root path ('/') to get the stats for the primary drive.\n\n Returns:\n int: The free space on the disk in bytes (B).\n\n Usage:\n free_disk_space_gb = get_free_disk_space('/')\n \"\"\"\n stats = get_disk_space_stats(path)\n free = stats.get(\"free_bytes\", 0)\n return free"},{"identifier":"update_storage_stats","path":"storage/miner/utils.py","snippet":"def update_storage_stats(self):\n \"\"\"\n Updates the miner's storage statistics.\n\n This function updates the miner's storage statistics, including the free disk space, current storage usage,\n and percent disk usage. It's useful for understanding the storage capacity and usage of the system where\n the miner is running.\n \"\"\"\n\n self.free_memory = get_free_disk_space()\n bt.logging.info(f\"Free memory: {self.free_memory} bytes\")\n self.current_storage_usage = get_directory_size(self.config.database.directory)\n bt.logging.info(f\"Miner storage usage: {self.current_storage_usage} bytes\")\n self.percent_disk_usage = self.current_storage_usage / self.free_memory\n bt.logging.info(f\"Miner % disk usage : {100 * self.percent_disk_usage:.3f}%\")"},{"identifier":"config","path":"storage/miner/config.py","snippet":"def config(cls):\n parser = argparse.ArgumentParser()\n bt.subtensor.add_args(parser)\n bt.logging.add_args(parser)\n bt.wallet.add_args(parser)\n bt.axon.add_args(parser)\n cls.add_args(parser)\n return bt.config(parser)"},{"identifier":"check_config","path":"storage/miner/config.py","snippet":"def check_config(cls, config: \"bt.Config\"):\n r\"\"\"Checks/validates the config namespace object.\"\"\"\n bt.logging.check_config(config)\n\n if config.mock:\n config.wallet._mock = True\n\n timestamp = datetime.datetime.now().strftime(\"%Y%m%d_%H%M%S\")\n full_path = os.path.expanduser(\n \"{}/{}/{}/netuid{}/{}\".format(\n config.logging.logging_dir,\n config.wallet.name,\n config.wallet.hotkey,\n config.netuid,\n config.miner.name,\n )\n )\n log_path = os.path.join(full_path, \"logs\", timestamp)\n\n config.miner.log_path = os.path.expanduser(log_path)\n config.miner.full_path = os.path.expanduser(full_path)\n\n if not os.path.exists(config.miner.full_path):\n os.makedirs(config.miner.full_path, exist_ok=True)\n if not os.path.exists(config.miner.log_path):\n os.makedirs(config.miner.log_path, exist_ok=True)\n\n if not config.miner.dont_save_events:\n # Add custom event logger for the events.\n logger.level(\"EVENTS\", no=38, icon=\"📝\")\n logger.add(\n config.miner.full_path + \"/\" + \"EVENTS.log\",\n rotation=config.miner.events_retention_size,\n serialize=True,\n enqueue=True,\n backtrace=False,\n diagnose=False,\n level=\"EVENTS\",\n format=\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\",\n )\n\n logger.add(\n config.miner.full_path + \"/\" + \"INFO.log\",\n rotation=config.miner.events_retention_size,\n serialize=True,\n enqueue=True,\n backtrace=False,\n diagnose=False,\n level=\"INFO\",\n format=\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\",\n )\n\n logger.add(\n config.miner.full_path + \"/\" + \"DEBUG.log\",\n rotation=config.miner.events_retention_size,\n serialize=True,\n enqueue=True,\n backtrace=False,\n diagnose=False,\n level=\"DEBUG\",\n format=\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\",\n )\n\n logger.add(\n config.miner.full_path + \"/\" + \"TRACE.log\",\n rotation=config.miner.events_retention_size,\n serialize=True,\n enqueue=True,\n backtrace=False,\n diagnose=False,\n level=\"TRACE\",\n format=\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\",\n )"},{"identifier":"add_args","path":"storage/miner/config.py","snippet":"def add_args(cls, parser):\n parser.add_argument(\"--netuid\", type=int, default=21, help=\"The chain subnet uid.\")\n parser.add_argument(\"--test\", default=False, action=\"store_true\")\n parser.add_argument(\n \"--miner.name\",\n type=str,\n help=\"Trials for this miner go in miner.root / (wallet_cold - wallet_hot) / miner.name. \",\n default=\"core_storage_miner\",\n )\n parser.add_argument(\n \"--miner.device\",\n type=str,\n help=\"Device to run the validator on.\",\n default=\"cuda\" if torch.cuda.is_available() else \"cpu\",\n )\n parser.add_argument(\"--miner.verbose\", default=False, action=\"store_true\")\n\n parser.add_argument(\n \"--database.host\", default=\"localhost\", help=\"The host of the redis database.\"\n )\n parser.add_argument(\n \"--database.port\",\n type=int,\n default=6379,\n help=\"The port of the redis database.\",\n )\n parser.add_argument(\n \"--database.index\",\n type=int,\n default=0,\n help=\"The index of the redis database.\",\n )\n parser.add_argument(\n \"--database.directory\",\n default=\"~/.data\",\n help=\"The directory to store data in.\",\n )\n\n # Run config.\n parser.add_argument(\n \"--miner.set_weights_wait_for_inclusion\",\n action=\"store_true\",\n help=\"Wether to wait for the set_weights extrinsic to enter a block\",\n default=False,\n )\n parser.add_argument(\n \"--miner.set_weights_wait_for_finalization\",\n action=\"store_true\",\n help=\"Wether to wait for the set_weights extrinsic to be finalized on the chain\",\n default=False,\n )\n parser.add_argument(\n \"--miner.seconds_to_wait_to_log_presence_message\",\n type=int,\n help=\"How many seconds to wait before logging a presence message.\",\n default=4,\n )\n\n # Blacklist.\n parser.add_argument(\n \"--miner.blacklist.blacklist\",\n type=str,\n required=False,\n nargs=\"*\",\n help=\"Blacklist certain hotkeys\",\n default=[],\n )\n parser.add_argument(\n \"--miner.blacklist.whitelist\",\n type=str,\n required=False,\n nargs=\"*\",\n help=\"Whitelist certain hotkeys\",\n default=[],\n )\n parser.add_argument(\n \"--miner.blacklist.force_validator_permit\",\n action=\"store_true\",\n help=\"Only allow requests from validators\",\n default=False,\n )\n parser.add_argument(\n \"--miner.blacklist.allow_non_registered\",\n action=\"store_true\",\n help=\"If True, the miner will allow non-registered hotkeys to mine.\",\n default=False,\n )\n parser.add_argument(\n \"--miner.blacklist.minimum_stake_requirement\",\n type=float,\n help=\"Minimum stake requirement\",\n default=0.0,\n )\n parser.add_argument(\n \"--miner.blacklist.min_request_period\",\n type=int,\n help=\"Time period (in minute) to serve a maximum of 50 requests for each hotkey\",\n default=5,\n )\n\n # Priority.\n parser.add_argument(\n \"--miner.priority.default\",\n type=float,\n help=\"Default priority of non-registered requests\",\n default=0.0,\n )\n parser.add_argument(\n \"--miner.priority.time_stake_multiplicate\",\n type=int,\n help=\"Time (in minute) it takes to make the stake twice more important in the priority queue\",\n default=10,\n )\n parser.add_argument(\n \"--miner.priority.len_request_timestamps\",\n type=int,\n help=\"Number of historic request timestamps to record\",\n default=50,\n )\n # Switches.\n parser.add_argument(\n \"--miner.no_set_weights\",\n action=\"store_true\",\n help=\"If True, the miner does not set weights.\",\n default=False,\n )\n parser.add_argument(\n \"--miner.no_serve\",\n action=\"store_true\",\n help=\"If True, the miner doesnt serve the axon.\",\n default=False,\n )\n parser.add_argument(\n \"--miner.no_start_axon\",\n action=\"store_true\",\n help=\"If True, the miner doesnt start the axon.\",\n default=False,\n )\n\n # Mocks.\n parser.add_argument(\n \"--miner.mock_subtensor\",\n action=\"store_true\",\n help=\"If True, the miner will allow non-registered hotkeys to mine.\",\n default=False,\n )\n\n # Wandb args\n parser.add_argument(\n \"--wandb.off\", action=\"store_true\", help=\"Turn off wandb.\", default=False\n )\n parser.add_argument(\n \"--wandb.project_name\",\n type=str,\n help=\"The name of the project where you are sending the new run.\",\n default=\"philanthropic-thunder\",\n )\n parser.add_argument(\n \"--wandb.entity\",\n type=str,\n help=\"An entity is a username or team name where youre sending runs.\",\n default=\"philanthrope\",\n )\n parser.add_argument(\n \"--wandb.offline\",\n action=\"store_true\",\n help=\"Runs wandb in offline mode.\",\n default=False,\n )\n parser.add_argument(\n \"--wandb.weights_step_length\",\n type=int,\n help=\"How many steps before we log the weights.\",\n default=10,\n )\n parser.add_argument(\n \"--wandb.run_step_length\",\n type=int,\n help=\"How many steps before we rollover to a new run.\",\n default=1500,\n )\n parser.add_argument(\n \"--wandb.notes\",\n type=str,\n help=\"Notes to add to the wandb run.\",\n default=\"\",\n )"},{"identifier":"store_chunk_metadata","path":"storage/miner/database.py","snippet":"async def store_chunk_metadata(r, chunk_hash, filepath, hotkey, size, seed):\n \"\"\"\n Stores the metadata of a chunk in a Redis database.\n\n Args:\n r (redis.Redis): The Redis connection instance.\n chunk_hash (str): The unique hash identifying the chunk.\n hotkey (str): Miner hotkey associated with the chunk.\n size (int): The size of the chunk.\n seed (str): The seed associated with the chunk.\n\n This function stores the filepath, size (as a string), and seed for the given chunk hash.\n \"\"\"\n # Ensure that all data are in the correct format\n metadata = {\n \"filepath\": filepath,\n \"hotkey\": hotkey,\n \"size\": str(size), # Convert size to string\n \"seed\": seed, # Store seed directly\n }\n\n # Use hmset (or hset which is its modern equivalent) to store the hash\n for key, value in metadata.items():\n await r.hset(chunk_hash, key, value)"},{"identifier":"update_seed_info","path":"storage/miner/database.py","snippet":"async def update_seed_info(r, chunk_hash, hotkey, seed):\n \"\"\"\n Updates the seed information for a specific chunk in the Redis database.\n\n Args:\n r (redis.Redis): The Redis connection instance.\n chunk_hash (str): The unique hash identifying the chunk.\n hotkey (str): The caller hotkey value to be updated.\n seed (str): The new seed value to be updated.\n\n This function updates the seed information for the specified chunk hash.\n \"\"\"\n # Update the existing seed information\n await r.hset(chunk_hash, \"seed\", seed)\n await r.hset(chunk_hash, \"hotkey\", hotkey)"},{"identifier":"get_chunk_metadata","path":"storage/miner/database.py","snippet":"async def get_chunk_metadata(r, chunk_hash):\n \"\"\"\n Retrieves the metadata for a specific chunk from the Redis database.\n\n Args:\n r (redis.Redis): The Redis connection instance.\n chunk_hash (str): The unique hash identifying the chunk.\n\n Returns:\n dict: A dictionary containing the chunk's metadata, including filepath, size, and seed.\n Size is converted to an integer, and seed is decoded from bytes to a string.\n \"\"\"\n metadata = await r.hgetall(chunk_hash)\n if metadata:\n metadata[b\"size\"] = int(metadata[b\"size\"])\n metadata[b\"seed\"] = metadata[b\"seed\"].decode(\"utf-8\")\n return metadata"}],"string":"[\n {\n \"identifier\": \"hash_data\",\n \"path\": \"storage/shared/ecc.py\",\n \"snippet\": \"def hash_data(data):\\n \\\"\\\"\\\"\\n Compute a SHA3-256 hash of the input data and return its integer representation.\\n\\n The function handles both byte-like and non-byte-like inputs by converting non-byte inputs to\\n strings and then encoding to bytes before hashing.\\n\\n Parameters:\\n - data (bytes | bytearray | object): Data to be hashed.\\n\\n Returns:\\n - int: Integer representation of the SHA3-256 hash of the input data.\\n\\n Raises:\\n - TypeError: If the hashing operation encounters an incompatible data type.\\n \\\"\\\"\\\"\\n if not isinstance(data, (bytes, bytearray)):\\n data_str = str(data)\\n data = data_str.encode()\\n h = hashlib.sha3_256(data).hexdigest()\\n return int(h, 16)\"\n },\n {\n \"identifier\": \"setup_CRS\",\n \"path\": \"storage/shared/ecc.py\",\n \"snippet\": \"def setup_CRS(curve=\\\"P-256\\\"):\\n \\\"\\\"\\\"\\n Generate a pair of random points to serve as a Common Reference String (CRS) for elliptic curve operations.\\n\\n The CRS is essential for various cryptographic protocols that rely on a shared reference\\n between parties, typically for the purpose of ensuring consistent cryptographic operations.\\n\\n Parameters:\\n - curve (str, optional): Name of the elliptic curve to use; defaults to \\\"P-256\\\".\\n\\n Returns:\\n - tuple(ECC.EccPoint, ECC.EccPoint): A 2-tuple of ECC.EccPoint instances representing the base points (g, h).\\n\\n Raises:\\n - ValueError: If the specified elliptic curve name is not recognized.\\n \\\"\\\"\\\"\\n curve_obj = ECC.generate(curve=curve)\\n g = curve_obj.pointQ # Base point\\n h = ECC.generate(curve=curve).pointQ # Another random point\\n return g, h\"\n },\n {\n \"identifier\": \"ECCommitment\",\n \"path\": \"storage/shared/ecc.py\",\n \"snippet\": \"class ECCommitment:\\n \\\"\\\"\\\"\\n Elliptic Curve based commitment scheme allowing one to commit to a chosen value while keeping it hidden to others.\\n\\n Attributes:\\n g (ECC.EccPoint): The base point of the elliptic curve used as part of the commitment.\\n h (ECC.EccPoint): Another random point on the elliptic curve used as part of the commitment.\\n\\n Methods:\\n commit(m): Accepts a message, hashes it, and produces a commitment to the hashed message.\\n open(c, m_val, r): Accepts a commitment, a hashed message, and a random value to verify the commitment.\\n\\n The `commit` method will print the commitment process, and the `open` method will print the verification process.\\n \\\"\\\"\\\"\\n\\n def __init__(self, g, h, verbose=False):\\n self.g = g # Base point of the curve\\n self.h = h # Another random point on the curve\\n self.verbose = verbose\\n\\n def commit(self, m): # AKA Seal.\\n \\\"\\\"\\\"\\n Create a cryptographic commitment to a message.\\n\\n The message is hashed, and the hash is used along with a random number to form the commitment\\n using the public parameters g and h. The commitment can be verified with the `open` method.\\n\\n Parameters:\\n - m (bytes | bytearray | object): The message to commit to.\\n\\n Returns:\\n - tuple: A 3-tuple (commitment, hashed message value, random number used in the commitment).\\n\\n Side Effects:\\n - This method will print the commitment details to the console.\\n\\n Raises:\\n - Exception: If the commitment calculation fails.\\n \\\"\\\"\\\"\\n m_val = hash_data(m) # Compute hash of the data\\n r = random.randint(1, 2**256)\\n c1 = self.g.__mul__(m_val)\\n c2 = self.h.__mul__(r)\\n c = c1.__add__(c2)\\n if self.verbose:\\n print(\\n f\\\"Committing: Data = {m}\\\\nHashed Value = {m_val}\\\\nRandom Value = {r}\\\\nComputed Commitment = {c}\\\\n\\\"\\n )\\n return c, m_val, r\\n\\n def open(self, c, m_val, r):\\n \\\"\\\"\\\"\\n Verify a commitment using the original message hash and randomness.\\n\\n This method recomputes the commitment using the public parameters and compares it with\\n the provided commitment to check its validity.\\n\\n Parameters:\\n - c (ECC.EccPoint): The commitment point to verify.\\n - m_val (int): The integer value of the hashed message used in the commitment.\\n - r (int): The random number used in the commitment.\\n\\n Returns:\\n - bool: True if the verification succeeds (commitment is valid), False otherwise.\\n\\n Side Effects:\\n - This method will print the verification details to the console.\\n\\n Raises:\\n - Exception: If the verification calculation fails.\\n \\\"\\\"\\\"\\n c1 = self.g.__mul__(m_val)\\n c2 = self.h.__mul__(r)\\n computed_c = c1.__add__(c2)\\n if self.verbose:\\n print(\\n f\\\"\\\\nOpening: Hashed Value = {m_val}\\\\nRandom Value = {r}\\\\nRecomputed Commitment = {computed_c}\\\\nOriginal Commitment = {c}\\\"\\n )\\n return computed_c == c\"\n },\n {\n \"identifier\": \"ecc_point_to_hex\",\n \"path\": \"storage/shared/ecc.py\",\n \"snippet\": \"def ecc_point_to_hex(point):\\n \\\"\\\"\\\"\\n Convert an elliptic curve point to a hexadecimal string.\\n\\n This encoding is typically used for compact representation or for preparing the data\\n to be transmitted over protocols that may not support binary data.\\n\\n Parameters:\\n - point (ECC.EccPoint): An ECC point to convert.\\n\\n Returns:\\n - str: Hexadecimal string representing the elliptic curve point.\\n\\n Raises:\\n - AttributeError: If the input is not a valid ECC point with accessible x and y coordinates.\\n \\\"\\\"\\\"\\n point_str = \\\"{},{}\\\".format(point.x, point.y)\\n return binascii.hexlify(point_str.encode()).decode()\"\n },\n {\n \"identifier\": \"hex_to_ecc_point\",\n \"path\": \"storage/shared/ecc.py\",\n \"snippet\": \"def hex_to_ecc_point(hex_str, curve):\\n \\\"\\\"\\\"\\n Convert a hexadecimal string back into an elliptic curve point.\\n\\n This function is typically used to deserialize an ECC point that has been transmitted or stored as a hex string.\\n\\n Parameters:\\n - hex_str (str): The hex string representing an elliptic curve point.\\n - curve (str): The name of the elliptic curve the point belongs to.\\n\\n Returns:\\n - ECC.EccPoint: The elliptic curve point represented by the hex string.\\n\\n Raises:\\n - ValueError: If the hex string is not properly formatted or does not represent a valid point on the specified curve.\\n \\\"\\\"\\\"\\n point_str = binascii.unhexlify(hex_str).decode()\\n x, y = map(int, point_str.split(\\\",\\\"))\\n return ECC.EccPoint(x, y, curve=curve)\"\n },\n {\n \"identifier\": \"MerkleTree\",\n \"path\": \"storage/shared/merkle.py\",\n \"snippet\": \"class MerkleTree(object):\\n \\\"\\\"\\\"\\n Represents a Merkle Tree, a data structure used for efficiently summarizing and verifying the\\n integrity of large sets of data. The Merkle Tree is a binary tree where each leaf node is the hash\\n of a data block and every non-leaf node is the hash of its children nodes.\\n\\n Attributes:\\n hash_function (callable): The hash function used for generating hashes of the blocks\\n and non-leaf nodes in the Merkle Tree.\\n leaves (list): A list where each element is a bytearray representing the hashed value of a leaf.\\n levels (list of lists): A list of lists where each sublist represents a level of the tree, starting\\n from the leaves up to the root.\\n is_ready (bool): Indicates whether the tree has been fully constructed and is ready to provide\\n the Merkle root and proofs.\\n\\n Methods:\\n add_leaf(values, do_hash=False): Adds one or multiple leaves to the tree. If `do_hash` is True,\\n it will hash the values before adding them as leaves.\\n get_leaf(index): Retrieves the hexadecimal string representation of a leaf at the given index.\\n get_leaf_count(): Returns the total number of leaves in the tree.\\n get_tree_ready_state(): Checks if the tree has been fully constructed.\\n make_tree(): Constructs the Merkle Tree from the current leaves. This method must be called\\n after all leaves are added and before retrieving the Merkle root or proofs.\\n get_merkle_root(): Retrieves the Merkle root as a hexadecimal string if the tree is ready.\\n get_proof(index): Generates a proof of inclusion for the leaf at the given index. This proof\\n consists of a list of sibling hashes that, when combined with the target leaf,\\n can reproduce the Merkle root.\\n update_leaf(index, new_value): Updates the value of the leaf at the given index with `new_value`\\n and recalculates the hashes up the tree to reflect this change.\\n serialize(): Converts the Merkle Tree into a JSON-formatted string for storage or transmission.\\n deserialize(json_data, hash_type=\\\"sha3_256\\\"): Reconstructs the Merkle Tree from a JSON string,\\n using the specified hash function.\\n\\n Raises:\\n Exception: If the `hash_type` provided during initialization is not supported or recognized.\\n\\n Example:\\n # Create a Merkle tree using the SHA3-256 hash function\\n merkle_tree = MerkleTree(hash_type='sha3_256')\\n\\n # Add data blocks (as leaves) to the tree\\n merkle_tree.add_leaf(['block1', 'block2', 'block3'], do_hash=True)\\n\\n # Construct the tree\\n merkle_tree.make_tree()\\n\\n # Retrieve the Merkle root\\n root = merkle_tree.get_merkle_root()\\n\\n # Get proof of inclusion for the first data block\\n proof = merkle_tree.get_proof(0)\\n\\n # Update the value of the first leaf and reconstruct the tree\\n merkle_tree.update_leaf(0, 'new_block1_hashed_value')\\n merkle_tree.make_tree()\\n\\n # Serialize the tree for storage\\n serialized_tree = merkle_tree.serialize()\\n\\n # Deserialize the tree for later use\\n deserialized_tree = MerkleTree.deserialize(serialized_tree, hash_type='sha3_256')\\n\\n Note:\\n The hash_function attribute is determined by the hash_type parameter provided at initialization.\\n Only hash types supported by the `hashlib` library can be used. Attempting to use an unsupported\\n hash type will result in an exception.\\n \\\"\\\"\\\"\\n\\n def __init__(self, hash_type=\\\"sha3_256\\\"):\\n hash_type = hash_type.lower()\\n if hash_type in [\\\"sha3_256\\\"]:\\n self.hash_function = getattr(hashlib, hash_type)\\n else:\\n raise Exception(\\\"`hash_type` {} nor supported\\\".format(hash_type))\\n\\n self.reset_tree()\\n\\n def __eq__(self, other):\\n if not isinstance(other, MerkleTree):\\n return False\\n return self.serialize() == other.serialize()\\n\\n def _to_hex(self, x):\\n try: # python3\\n return x.hex()\\n except: # python2\\n return binascii.hexlify(x)\\n\\n def reset_tree(self):\\n self.leaves = list()\\n self.levels = None\\n self.is_ready = False\\n\\n def add_leaf(self, values, do_hash=False):\\n self.is_ready = False\\n # check if single leaf\\n if not isinstance(values, tuple) and not isinstance(values, list):\\n values = [values]\\n for v in values:\\n if do_hash:\\n v = v.encode(\\\"utf-8\\\")\\n v = self.hash_function(v).hexdigest()\\n v = bytearray.fromhex(v)\\n self.leaves.append(v)\\n\\n def get_leaf(self, index):\\n return self._to_hex(self.leaves[index])\\n\\n def get_leaf_count(self):\\n return len(self.leaves)\\n\\n def get_tree_ready_state(self):\\n return self.is_ready\\n\\n def _calculate_next_level(self):\\n solo_leave = None\\n N = len(self.levels[0]) # number of leaves on the level\\n if N % 2 == 1: # if odd number of leaves on the level\\n solo_leave = self.levels[0][-1]\\n N -= 1\\n\\n new_level = []\\n for l, r in zip(self.levels[0][0:N:2], self.levels[0][1:N:2]):\\n new_level.append(self.hash_function(l + r).digest())\\n if solo_leave is not None:\\n new_level.append(solo_leave)\\n self.levels = [\\n new_level,\\n ] + self.levels # prepend new level\\n\\n def make_tree(self):\\n \\\"\\\"\\\"\\n Constructs the Merkle Tree from the leaves that have been added.\\n\\n This must be called after adding all the leaves and before calling\\n get_merkle_root or get_proof to ensure the tree is constructed.\\n \\\"\\\"\\\"\\n self.is_ready = False\\n if self.get_leaf_count() > 0:\\n self.levels = [\\n self.leaves,\\n ]\\n while len(self.levels[0]) > 1:\\n self._calculate_next_level()\\n self.is_ready = True\\n\\n def get_merkle_root(self):\\n if self.is_ready:\\n if self.levels is not None:\\n return self._to_hex(self.levels[0][0])\\n else:\\n return None\\n else:\\n return None\\n\\n def get_proof(self, index):\\n \\\"\\\"\\\"\\n Generates the proof for the existence of a leaf at the specified index within the Merkle Tree.\\n\\n A Merkle proof is a collection of sibling hashes on the path from a leaf to the root of the tree.\\n This proof can be used to independently verify that a leaf is indeed part of the Merkle tree without\\n needing the entire tree. Each element of the proof shows the direction ('left' or 'right') and the\\n corresponding hash that pairs with the path to the root.\\n\\n Parameters:\\n index (int): The index of the target leaf for which to generate the Merkle proof. The index must\\n correspond to the position of the leaf in the original list of leaves when the tree\\n was constructed.\\n\\n Returns:\\n list of dicts: A list where each dictionary contains a single key-value pair. The key is either\\n 'left' or 'right', indicating the side of the sibling hash, and the value is a\\n string representing the hexadecimal hash value of the sibling. If the tree is not\\n ready or the index is out of bounds, None is returned.\\n\\n Raises:\\n IndexError: If the index provided is not within the range of the leaves in the tree.\\n ValueError: If the tree has not been constructed by calling `make_tree` method, or the index\\n is not an integer.\\n\\n Example:\\n # Assuming `merkle_tree` is an instance of `MerkleTree` and has been populated with leaves and made ready\\n proof = merkle_tree.get_proof(2)\\n print(proof) # Outputs something like [{'left': 'abcd...'}, {'right': 'ef01...'}]\\n\\n Note:\\n The Merkle proof is only valid if the tree is in the ready state (`is_ready` attribute is True),\\n which occurs after the `make_tree` method has been called. If the tree is not ready or the index\\n is not valid, the method will return None.\\n \\\"\\\"\\\"\\n if self.levels is None:\\n return None\\n elif not self.is_ready or index > len(self.leaves) - 1 or index < 0:\\n return None\\n else:\\n proof = []\\n for x in range(len(self.levels) - 1, 0, -1):\\n level_len = len(self.levels[x])\\n if (index == level_len - 1) and (\\n level_len % 2 == 1\\n ): # skip if this is an odd end node\\n index = int(index / 2.0)\\n continue\\n is_right_node = index % 2\\n sibling_index = index - 1 if is_right_node else index + 1\\n sibling_pos = \\\"left\\\" if is_right_node else \\\"right\\\"\\n sibling_value = self._to_hex(self.levels[x][sibling_index])\\n proof.append({sibling_pos: sibling_value})\\n index = int(index / 2.0)\\n return proof\\n\\n def update_leaf(self, index, new_value):\\n \\\"\\\"\\\"\\n Updates the value of a leaf at a given index in the Merkle Tree and recalculates the hashes along\\n the path from the updated leaf to the root of the tree to reflect the change.\\n\\n This method allows the Merkle Tree to maintain integrity by ensuring that any updates to the leaf\\n nodes are propagated upwards, resulting in a new Merkle root that represents the current state of\\n the leaves.\\n\\n Parameters:\\n index (int): The index of the leaf to update. The index is zero-based and must be less than\\n the number of leaves in the tree.\\n new_value (str): The new value in hexadecimal format to which the leaf should be updated. This\\n value should be a valid hexadecimal string that represents the hashed data\\n if hashing was applied to the leaves upon tree construction.\\n\\n Returns:\\n None\\n\\n Raises:\\n ValueError: If the tree is not ready for updates (i.e., `is_ready` is False), if the index is\\n not an integer, if the new_value is not a hexadecimal string, or if the index is\\n out of bounds (less than 0 or greater than or equal to the number of leaves).\\n IndexError: If the index is out of the range of current leaves.\\n\\n Example:\\n # Assuming `merkle_tree` is an instance of `MerkleTree`, populated with leaves and made ready.\\n merkle_tree.update_leaf(0, 'a1b2c3d4e5f67890')\\n # The leaf at index 0 is updated, and changes are propagated to the root.\\n\\n Note:\\n The tree must have been constructed and be in a ready state before calling this method. If the\\n tree has not been made by calling the `make_tree` method, or the index is invalid, this method\\n will not perform an update and will return None.\\n \\\"\\\"\\\"\\n if not self.is_ready:\\n return None\\n new_value = bytearray.fromhex(new_value)\\n self.levels[-1][index] = new_value\\n for x in range(len(self.levels) - 1, 0, -1):\\n parent_index = index // 2\\n left_child = self.levels[x][parent_index * 2]\\n try:\\n right_child = self.levels[x][parent_index * 2 + 1]\\n except IndexError:\\n right_child = bytearray()\\n self.levels[x - 1][parent_index] = self.hash_function(\\n left_child + right_child\\n ).digest()\\n index = parent_index\\n\\n def serialize(self):\\n \\\"\\\"\\\"\\n Serializes the MerkleTree object into a JSON string.\\n \\\"\\\"\\\"\\n # Convert the bytearray leaves and levels to hex strings for serialization\\n leaves = [self._to_hex(leaf) for leaf in self.leaves]\\n levels = None\\n if self.levels is not None:\\n levels = []\\n for level in self.levels:\\n levels.append([self._to_hex(item) for item in level])\\n\\n # Construct a dictionary with the MerkleTree properties\\n merkle_tree_data = {\\n \\\"leaves\\\": leaves,\\n \\\"levels\\\": levels,\\n \\\"is_ready\\\": self.is_ready,\\n }\\n\\n # Convert the dictionary to a JSON string\\n return json.dumps(merkle_tree_data)\\n\\n @classmethod\\n def deserialize(cls, json_data, hash_type=\\\"sha3_256\\\"):\\n \\\"\\\"\\\"\\n Deserializes the JSON string into a MerkleTree object.\\n \\\"\\\"\\\"\\n # Convert the JSON string back to a dictionary\\n merkle_tree_data = json.loads(json_data)\\n\\n # Create a new MerkleTree object\\n m_tree = cls(hash_type)\\n\\n # Convert the hex strings back to bytearrays and set the leaves and levels\\n m_tree.leaves = [bytearray.fromhex(leaf) for leaf in merkle_tree_data[\\\"leaves\\\"]]\\n if merkle_tree_data[\\\"levels\\\"] is not None:\\n m_tree.levels = []\\n for level in merkle_tree_data[\\\"levels\\\"]:\\n m_tree.levels.append([bytearray.fromhex(item) for item in level])\\n m_tree.is_ready = merkle_tree_data[\\\"is_ready\\\"]\\n\\n return m_tree\"\n },\n {\n \"identifier\": \"b64_encode\",\n \"path\": \"storage/shared/utils.py\",\n \"snippet\": \"def b64_encode(data: Union[bytes, str, List[str], List[bytes], dict]) -> str:\\n \\\"\\\"\\\"\\n Encodes the given data into a base64 string. If the data is a list or dictionary of bytes, it converts\\n the bytes into hexadecimal strings before encoding.\\n\\n Args:\\n data (list or dict): The data to be base64 encoded. Can be a list of bytes or a dictionary with bytes values.\\n\\n Returns:\\n str: The base64 encoded string of the input data.\\n\\n Raises:\\n TypeError: If the input is not a list, dict, or bytes.\\n \\\"\\\"\\\"\\n if isinstance(data, bytes):\\n data = data.hex()\\n if isinstance(data, list) and len(data) and isinstance(data[0], bytes):\\n data = [d.hex() for d in data]\\n if isinstance(data, dict) and isinstance(data[list(data.keys())[0]], bytes):\\n data = {k: v.hex() for k, v in data.items()}\\n return base64.b64encode(json.dumps(data).encode()).decode(\\\"utf-8\\\")\"\n },\n {\n \"identifier\": \"b64_decode\",\n \"path\": \"storage/shared/utils.py\",\n \"snippet\": \"def b64_decode(data: bytes, decode_hex: bool = False, encrypted: bool = False):\\n \\\"\\\"\\\"\\n Decodes a base64 string into a list or dictionary. If decode_hex is True, it converts any hexadecimal strings\\n within the data back into bytes.\\n\\n Args:\\n data (bytes or str): The base64 encoded data to be decoded.\\n decode_hex (bool): A flag to indicate whether to decode hex strings into bytes. Defaults to False.\\n\\n Returns:\\n list or dict: The decoded data. Returns a list if the original encoded data was a list, and a dict if it was a dict.\\n\\n Raises:\\n ValueError: If the input is not properly base64 encoded or if hex decoding fails.\\n \\\"\\\"\\\"\\n data = data.decode(\\\"utf-8\\\") if isinstance(data, bytes) else data\\n decoded_data = json.loads(\\n base64.b64decode(data) if encrypted else base64.b64decode(data).decode(\\\"utf-8\\\")\\n )\\n if decode_hex:\\n try:\\n decoded_data = (\\n [bytes.fromhex(d) for d in decoded_data]\\n if isinstance(decoded_data, list)\\n else {k: bytes.fromhex(v) for k, v in decoded_data.items()}\\n )\\n except:\\n pass\\n return decoded_data\"\n },\n {\n \"identifier\": \"chunk_data\",\n \"path\": \"storage/shared/utils.py\",\n \"snippet\": \"def chunk_data(data: bytes, chunksize: int) -> List[bytes]:\\n \\\"\\\"\\\"\\n Generator function that chunks the given data into pieces of a specified size.\\n\\n Args:\\n data (bytes): The binary data to be chunked.\\n chunksize (int): The size of each chunk in bytes.\\n\\n Yields:\\n bytes: A chunk of the data with the size equal to 'chunksize' or the remaining size of data.\\n\\n Raises:\\n ValueError: If 'chunksize' is less than or equal to 0.\\n \\\"\\\"\\\"\\n for i in range(0, len(data), chunksize):\\n yield data[i : i + chunksize]\"\n },\n {\n \"identifier\": \"safe_key_search\",\n \"path\": \"storage/shared/utils.py\",\n \"snippet\": \"async def safe_key_search(database: aioredis.Redis, pattern: str) -> List[str]:\\n \\\"\\\"\\\"\\n Safely search for keys in the database that doesn't block.\\n `scan_iter` uses cursor under the hood.\\n \\\"\\\"\\\"\\n return [key for key in await database.scan_iter(pattern)]\"\n },\n {\n \"identifier\": \"run\",\n \"path\": \"storage/miner/run.py\",\n \"snippet\": \"def run(self):\\n \\\"\\\"\\\"\\n Initiates and manages the main loop for the miner on the Bittensor network.\\n\\n This function performs the following primary tasks:\\n 1. Check for registration on the Bittensor network.\\n 2. Attaches the miner's forward, blacklist, and priority functions to its axon.\\n 3. Starts the miner's axon, making it active on the network.\\n 4. Regularly updates the metagraph with the latest network state.\\n 5. Optionally sets weights on the network, defining how much trust to assign to other nodes.\\n 6. Handles graceful shutdown on keyboard interrupts and logs unforeseen errors.\\n\\n The miner continues its operations until `should_exit` is set to True or an external interruption occurs.\\n During each epoch of its operation, the miner waits for new blocks on the Bittensor network, updates its\\n knowledge of the network (metagraph), and sets its weights. This process ensures the miner remains active\\n and up-to-date with the network's latest state.\\n\\n Note:\\n - The function leverages the global configurations set during the initialization of the miner.\\n - The miner's axon serves as its interface to the Bittensor network, handling incoming and outgoing requests.\\n\\n Raises:\\n KeyboardInterrupt: If the miner is stopped by a manual interruption.\\n Exception: For unforeseen errors during the miner's operation, which are logged for diagnosis.\\n \\\"\\\"\\\"\\n block_handler_substrate = SubstrateInterface(\\n ss58_format=bt.__ss58_format__,\\n use_remote_preset=True,\\n url=self.subtensor.chain_endpoint,\\n type_registry=bt.__type_registry__,\\n )\\n\\n netuid = self.config.netuid\\n\\n # --- Check for registration.\\n if not self.subtensor.is_hotkey_registered(\\n netuid=netuid,\\n hotkey_ss58=self.wallet.hotkey.ss58_address,\\n ):\\n bt.logging.error(\\n f\\\"Wallet: {self.wallet} is not registered on netuid {netuid}\\\"\\n f\\\"Please register the hotkey using `btcli subnets register` before trying again\\\"\\n )\\n exit()\\n\\n tempo = block_handler_substrate.query(\\n module=\\\"SubtensorModule\\\", storage_function=\\\"Tempo\\\", params=[netuid]\\n ).value\\n\\n last_extrinsic_hash = None\\n checked_extrinsics_count = 0\\n should_retry = False\\n\\n def handler(obj, update_nr, subscription_id):\\n current_block = obj[\\\"header\\\"][\\\"number\\\"]\\n block_hash = block_handler_substrate.get_block_hash(current_block)\\n bt.logging.debug(f\\\"New block #{current_block}\\\")\\n\\n bt.logging.debug(\\n f\\\"Blocks since epoch: {(current_block + netuid + 1) % (tempo + 1)}\\\"\\n )\\n\\n nonlocal last_extrinsic_hash\\n nonlocal checked_extrinsics_count\\n nonlocal should_retry\\n\\n if last_extrinsic_hash != None:\\n try:\\n receipt = block_handler_substrate.retrieve_extrinsic_by_hash(\\n block_hash, last_extrinsic_hash\\n )\\n bt.logging.debug(\\n f\\\"Last set-weights call: {'Success' if receipt.is_success else format('Failure, reason: %s', receipt.error_message['name'] if receipt.error_message != None else 'nil')}\\\"\\n )\\n\\n should_retry = False\\n last_extrinsic_hash = None\\n checked_extrinsics_count = 0\\n except Exception as e:\\n checked_extrinsics_count += 1\\n bt.logging.debug(f\\\"An error occurred, extrinsic not found in block.\\\")\\n finally:\\n if checked_extrinsics_count >= 20:\\n should_retry = True\\n last_extrinsic_hash = None\\n checked_extrinsics_count = 0\\n\\n if ((current_block + netuid + 1) % (tempo + 1) == 0) or should_retry:\\n bt.logging.info(\\n f\\\"New epoch started, setting weights at block {current_block}\\\"\\n )\\n with self.subtensor.substrate as substrate:\\n call = substrate.compose_call(\\n call_module=\\\"SubtensorModule\\\",\\n call_function=\\\"set_weights\\\",\\n call_params={\\n \\\"dests\\\": [self.my_subnet_uid],\\n \\\"weights\\\": [65535],\\n \\\"netuid\\\": netuid,\\n \\\"version_key\\\": 1,\\n },\\n )\\n\\n # Period dictates how long the extrinsic will stay as part of waiting pool\\n extrinsic = substrate.create_signed_extrinsic(\\n call=call, keypair=self.wallet.hotkey, era={\\\"period\\\": 1000}\\n )\\n\\n dry_run = runtime_call(\\n substrate=substrate,\\n api=\\\"TaggedTransactionQueue\\\",\\n method=\\\"validate_transaction\\\",\\n params=[\\\"InBlock\\\", extrinsic, block_hash],\\n block_hash=block_hash,\\n )\\n bt.logging.debug(dry_run)\\n\\n response = substrate.submit_extrinsic(\\n extrinsic,\\n wait_for_inclusion=False,\\n wait_for_finalization=False,\\n )\\n\\n result_data = substrate.rpc_request(\\\"author_pendingExtrinsics\\\", [])\\n for extrinsic_data in result_data[\\\"result\\\"]:\\n extrinsic = substrate.runtime_config.create_scale_object(\\n \\\"Extrinsic\\\", metadata=substrate.metadata\\n )\\n extrinsic.decode(\\n ScaleBytes(extrinsic_data),\\n check_remaining=substrate.config.get(\\\"strict_scale_decode\\\"),\\n )\\n\\n if extrinsic.value[\\\"extrinsic_hash\\\"] == response.extrinsic_hash:\\n bt.logging.debug(\\n \\\"Weights transaction is in the pending transaction pool\\\"\\n )\\n\\n last_extrinsic_hash = response.extrinsic_hash\\n should_retry = False\\n\\n # --- Update the miner storage information periodically.\\n if not should_retry:\\n update_storage_stats(self)\\n bt.logging.debug(\\\"Storage statistics updated...\\\")\\n\\n if self.should_exit:\\n return True\\n\\n block_handler_substrate.subscribe_block_headers(handler)\"\n },\n {\n \"identifier\": \"set_weights\",\n \"path\": \"storage/miner/set_weights.py\",\n \"snippet\": \"def set_weights_for_miner(\\n subtensor: \\\"bt.subtensor\\\",\\n netuid: int,\\n uid: int,\\n wallet: \\\"bt.wallet\\\",\\n metagraph: \\\"bt.metagraph\\\",\\n wandb_on: bool = False,\\n tempo: int = 360,\\n wait_for_inclusion: bool = False,\\n wait_for_finalization: bool = False,\\n) -> bool:\"\n },\n {\n \"identifier\": \"compute_subsequent_commitment\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def compute_subsequent_commitment(data, previous_seed, new_seed, verbose=False):\\n \\\"\\\"\\\"\\n Computes a new commitment based on provided data and a change from an old seed to a new seed.\\n This function is typically used in cryptographic operations to update commitments without\\n altering the underlying data.\\n\\n Parameters:\\n - data: The original data for which the commitment is being updated.\\n - previous_seed: The seed used in the previous commitment.\\n - new_seed: The seed to be used for the new commitment.\\n - verbose (bool): If True, additional debug information will be printed. Defaults to False.\\n\\n Returns:\\n - A tuple containing the new commitment and the proof of the old commitment.\\n\\n If verbose is set to True, debug information about the types and contents of the parameters\\n will be printed to aid in debugging.\\n \\\"\\\"\\\"\\n if verbose:\\n bt.logging.debug(\\\"IN COMPUTE SUBESEQUENT COMMITMENT\\\")\\n bt.logging.debug(\\\"type of data :\\\", type(data))\\n bt.logging.debug(\\\"type of prev_seed:\\\", type(previous_seed))\\n bt.logging.debug(\\\"type of new_seed :\\\", type(new_seed))\\n proof = hash_data(data + previous_seed)\\n return hash_data(str(proof).encode(\\\"utf-8\\\") + new_seed), proof\"\n },\n {\n \"identifier\": \"save_data_to_filesystem\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def save_data_to_filesystem(data, directory, filename):\\n \\\"\\\"\\\"\\n Saves data to the filesystem at the specified directory and filename. If the directory does\\n not exist, it is created.\\n\\n Parameters:\\n - data: The data to be saved.\\n - directory (str): The directory path where the data should be saved.\\n - filename (str): The name of the file to save the data in.\\n\\n Returns:\\n - file_path (str): The full path to the saved file.\\n\\n This function is useful for persisting data to the disk.\\n \\\"\\\"\\\"\\n # Ensure the directory exists\\n directory = os.path.expanduser(directory)\\n os.makedirs(directory, exist_ok=True)\\n file_path = os.path.join(directory, filename)\\n with open(file_path, \\\"wb\\\") as file:\\n file.write(data)\\n return file_path\"\n },\n {\n \"identifier\": \"load_from_filesystem\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def load_from_filesystem(filepath):\\n \\\"\\\"\\\"\\n Loads data from a file in the filesystem.\\n\\n Parameters:\\n - filepath (str): The path to the file from which data is to be loaded.\\n\\n Returns:\\n - data: The data read from the file.\\n\\n This function is a straightforward utility for reading binary data from a file.\\n \\\"\\\"\\\"\\n with open(os.path.expanduser(filepath), \\\"rb\\\") as file:\\n data = file.read()\\n return data\"\n },\n {\n \"identifier\": \"commit_data_with_seed\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def commit_data_with_seed(committer, data_chunks, n_chunks, seed):\\n \\\"\\\"\\\"\\n Commits chunks of data with a seed using a Merkle tree structure to create a proof of\\n integrity for each chunk. This function is used in environments where the integrity\\n and order of data need to be verifiable.\\n\\n Parameters:\\n - committer: The committing object, which should have a commit method.\\n - data_chunks (list): A list of data chunks to be committed.\\n - n_chunks (int): The number of chunks expected to be committed.\\n - seed: A seed value that is combined with data chunks before commitment.\\n\\n Returns:\\n - randomness (list): A list of randomness values associated with each data chunk's commitment.\\n - chunks (list): The list of original data chunks that were committed.\\n - points (list): A list of commitment points in hex format.\\n - merkle_tree (MerkleTree): A Merkle tree constructed from the commitment points.\\n\\n This function handles the conversion of commitment points to hex format and adds them to the\\n Merkle tree. The completed tree represents the combined commitments.\\n \\\"\\\"\\\"\\n merkle_tree = MerkleTree()\\n\\n # Commit each chunk of data\\n randomness, chunks, points = [None] * n_chunks, [None] * n_chunks, [None] * n_chunks\\n for index, chunk in enumerate(data_chunks):\\n c, m_val, r = committer.commit(chunk + str(seed).encode())\\n c_hex = ecc_point_to_hex(c)\\n randomness[index] = r\\n chunks[index] = chunk\\n points[index] = c_hex\\n merkle_tree.add_leaf(c_hex)\\n\\n # Create the tree from the leaves\\n merkle_tree.make_tree()\\n return randomness, chunks, points, merkle_tree\"\n },\n {\n \"identifier\": \"init_wandb\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def init_wandb(self, reinit=False):\\n \\\"\\\"\\\"Starts a new wandb run.\\\"\\\"\\\"\\n tags = [\\n self.wallet.hotkey.ss58_address,\\n storage.__version__,\\n str(storage.__spec_version__),\\n f\\\"netuid_{self.metagraph.netuid}\\\",\\n ]\\n\\n if self.config.mock:\\n tags.append(\\\"mock\\\")\\n\\n wandb_config = {\\n key: copy.deepcopy(self.config.get(key, None))\\n for key in (\\\"neuron\\\", \\\"reward\\\", \\\"netuid\\\", \\\"wandb\\\")\\n }\\n\\n if wandb_config[\\\"neuron\\\"] is not None:\\n wandb_config[\\\"neuron\\\"].pop(\\\"full_path\\\", None)\\n\\n self.wandb = wandb.init(\\n anonymous=\\\"allow\\\",\\n reinit=reinit,\\n project=self.config.wandb.project_name,\\n entity=self.config.wandb.entity,\\n config=wandb_config,\\n mode=\\\"offline\\\" if self.config.wandb.offline else \\\"online\\\",\\n dir=self.config.neuron.full_path\\n if self.config.neuron is not None\\n else \\\"wandb_logs\\\",\\n tags=tags,\\n notes=self.config.wandb.notes,\\n )\\n bt.logging.success(\\n prefix=\\\"Started a new wandb run\\\",\\n sufix=f\\\"<blue> {self.wandb.name} </blue>\\\",\\n )\"\n },\n {\n \"identifier\": \"get_directory_size\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def get_directory_size(path):\\n \\\"\\\"\\\"\\n Calculates the total size of files in a specified directory.\\n\\n This function traverses the directory at the given path, including all subdirectories, and sums up the size\\n of each file to calculate the total directory size.\\n\\n Args:\\n path (str): The file path of the directory whose size is to be calculated.\\n\\n Returns:\\n int: The total size of the directory in bytes (B).\\n\\n Usage:\\n directory_size_gb = get_directory_size('/path/to/directory')\\n \\\"\\\"\\\"\\n total_size = 0\\n path = os.path.expanduser(path)\\n for dirpath, dirnames, filenames in os.walk(path):\\n for f in filenames:\\n fp = os.path.join(dirpath, f)\\n if not os.path.islink(fp):\\n total_size += os.path.getsize(fp)\\n return total_size\"\n },\n {\n \"identifier\": \"get_free_disk_space\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def get_free_disk_space(path=\\\".\\\"):\\n \\\"\\\"\\\"\\n Retrieves the free disk space for the drive containing the specified path.\\n\\n This function provides the free disk space of the drive on which the specified path resides.\\n It's useful for understanding the storage capacity and usage of the system where the miner is running.\\n\\n Args:\\n path (str): A file path on the drive whose free disk space is to be fetched. Typically, you can\\n provide the root path ('/') to get the stats for the primary drive.\\n\\n Returns:\\n int: The free space on the disk in bytes (B).\\n\\n Usage:\\n free_disk_space_gb = get_free_disk_space('/')\\n \\\"\\\"\\\"\\n stats = get_disk_space_stats(path)\\n free = stats.get(\\\"free_bytes\\\", 0)\\n return free\"\n },\n {\n \"identifier\": \"update_storage_stats\",\n \"path\": \"storage/miner/utils.py\",\n \"snippet\": \"def update_storage_stats(self):\\n \\\"\\\"\\\"\\n Updates the miner's storage statistics.\\n\\n This function updates the miner's storage statistics, including the free disk space, current storage usage,\\n and percent disk usage. It's useful for understanding the storage capacity and usage of the system where\\n the miner is running.\\n \\\"\\\"\\\"\\n\\n self.free_memory = get_free_disk_space()\\n bt.logging.info(f\\\"Free memory: {self.free_memory} bytes\\\")\\n self.current_storage_usage = get_directory_size(self.config.database.directory)\\n bt.logging.info(f\\\"Miner storage usage: {self.current_storage_usage} bytes\\\")\\n self.percent_disk_usage = self.current_storage_usage / self.free_memory\\n bt.logging.info(f\\\"Miner % disk usage : {100 * self.percent_disk_usage:.3f}%\\\")\"\n },\n {\n \"identifier\": \"config\",\n \"path\": \"storage/miner/config.py\",\n \"snippet\": \"def config(cls):\\n parser = argparse.ArgumentParser()\\n bt.subtensor.add_args(parser)\\n bt.logging.add_args(parser)\\n bt.wallet.add_args(parser)\\n bt.axon.add_args(parser)\\n cls.add_args(parser)\\n return bt.config(parser)\"\n },\n {\n \"identifier\": \"check_config\",\n \"path\": \"storage/miner/config.py\",\n \"snippet\": \"def check_config(cls, config: \\\"bt.Config\\\"):\\n r\\\"\\\"\\\"Checks/validates the config namespace object.\\\"\\\"\\\"\\n bt.logging.check_config(config)\\n\\n if config.mock:\\n config.wallet._mock = True\\n\\n timestamp = datetime.datetime.now().strftime(\\\"%Y%m%d_%H%M%S\\\")\\n full_path = os.path.expanduser(\\n \\\"{}/{}/{}/netuid{}/{}\\\".format(\\n config.logging.logging_dir,\\n config.wallet.name,\\n config.wallet.hotkey,\\n config.netuid,\\n config.miner.name,\\n )\\n )\\n log_path = os.path.join(full_path, \\\"logs\\\", timestamp)\\n\\n config.miner.log_path = os.path.expanduser(log_path)\\n config.miner.full_path = os.path.expanduser(full_path)\\n\\n if not os.path.exists(config.miner.full_path):\\n os.makedirs(config.miner.full_path, exist_ok=True)\\n if not os.path.exists(config.miner.log_path):\\n os.makedirs(config.miner.log_path, exist_ok=True)\\n\\n if not config.miner.dont_save_events:\\n # Add custom event logger for the events.\\n logger.level(\\\"EVENTS\\\", no=38, icon=\\\"📝\\\")\\n logger.add(\\n config.miner.full_path + \\\"/\\\" + \\\"EVENTS.log\\\",\\n rotation=config.miner.events_retention_size,\\n serialize=True,\\n enqueue=True,\\n backtrace=False,\\n diagnose=False,\\n level=\\\"EVENTS\\\",\\n format=\\\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\\\",\\n )\\n\\n logger.add(\\n config.miner.full_path + \\\"/\\\" + \\\"INFO.log\\\",\\n rotation=config.miner.events_retention_size,\\n serialize=True,\\n enqueue=True,\\n backtrace=False,\\n diagnose=False,\\n level=\\\"INFO\\\",\\n format=\\\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\\\",\\n )\\n\\n logger.add(\\n config.miner.full_path + \\\"/\\\" + \\\"DEBUG.log\\\",\\n rotation=config.miner.events_retention_size,\\n serialize=True,\\n enqueue=True,\\n backtrace=False,\\n diagnose=False,\\n level=\\\"DEBUG\\\",\\n format=\\\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\\\",\\n )\\n\\n logger.add(\\n config.miner.full_path + \\\"/\\\" + \\\"TRACE.log\\\",\\n rotation=config.miner.events_retention_size,\\n serialize=True,\\n enqueue=True,\\n backtrace=False,\\n diagnose=False,\\n level=\\\"TRACE\\\",\\n format=\\\"{time:YYYY-MM-DD at HH:mm:ss} | {level} | {message}\\\",\\n )\"\n },\n {\n \"identifier\": \"add_args\",\n \"path\": \"storage/miner/config.py\",\n \"snippet\": \"def add_args(cls, parser):\\n parser.add_argument(\\\"--netuid\\\", type=int, default=21, help=\\\"The chain subnet uid.\\\")\\n parser.add_argument(\\\"--test\\\", default=False, action=\\\"store_true\\\")\\n parser.add_argument(\\n \\\"--miner.name\\\",\\n type=str,\\n help=\\\"Trials for this miner go in miner.root / (wallet_cold - wallet_hot) / miner.name. \\\",\\n default=\\\"core_storage_miner\\\",\\n )\\n parser.add_argument(\\n \\\"--miner.device\\\",\\n type=str,\\n help=\\\"Device to run the validator on.\\\",\\n default=\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\",\\n )\\n parser.add_argument(\\\"--miner.verbose\\\", default=False, action=\\\"store_true\\\")\\n\\n parser.add_argument(\\n \\\"--database.host\\\", default=\\\"localhost\\\", help=\\\"The host of the redis database.\\\"\\n )\\n parser.add_argument(\\n \\\"--database.port\\\",\\n type=int,\\n default=6379,\\n help=\\\"The port of the redis database.\\\",\\n )\\n parser.add_argument(\\n \\\"--database.index\\\",\\n type=int,\\n default=0,\\n help=\\\"The index of the redis database.\\\",\\n )\\n parser.add_argument(\\n \\\"--database.directory\\\",\\n default=\\\"~/.data\\\",\\n help=\\\"The directory to store data in.\\\",\\n )\\n\\n # Run config.\\n parser.add_argument(\\n \\\"--miner.set_weights_wait_for_inclusion\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Wether to wait for the set_weights extrinsic to enter a block\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--miner.set_weights_wait_for_finalization\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Wether to wait for the set_weights extrinsic to be finalized on the chain\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--miner.seconds_to_wait_to_log_presence_message\\\",\\n type=int,\\n help=\\\"How many seconds to wait before logging a presence message.\\\",\\n default=4,\\n )\\n\\n # Blacklist.\\n parser.add_argument(\\n \\\"--miner.blacklist.blacklist\\\",\\n type=str,\\n required=False,\\n nargs=\\\"*\\\",\\n help=\\\"Blacklist certain hotkeys\\\",\\n default=[],\\n )\\n parser.add_argument(\\n \\\"--miner.blacklist.whitelist\\\",\\n type=str,\\n required=False,\\n nargs=\\\"*\\\",\\n help=\\\"Whitelist certain hotkeys\\\",\\n default=[],\\n )\\n parser.add_argument(\\n \\\"--miner.blacklist.force_validator_permit\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Only allow requests from validators\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--miner.blacklist.allow_non_registered\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If True, the miner will allow non-registered hotkeys to mine.\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--miner.blacklist.minimum_stake_requirement\\\",\\n type=float,\\n help=\\\"Minimum stake requirement\\\",\\n default=0.0,\\n )\\n parser.add_argument(\\n \\\"--miner.blacklist.min_request_period\\\",\\n type=int,\\n help=\\\"Time period (in minute) to serve a maximum of 50 requests for each hotkey\\\",\\n default=5,\\n )\\n\\n # Priority.\\n parser.add_argument(\\n \\\"--miner.priority.default\\\",\\n type=float,\\n help=\\\"Default priority of non-registered requests\\\",\\n default=0.0,\\n )\\n parser.add_argument(\\n \\\"--miner.priority.time_stake_multiplicate\\\",\\n type=int,\\n help=\\\"Time (in minute) it takes to make the stake twice more important in the priority queue\\\",\\n default=10,\\n )\\n parser.add_argument(\\n \\\"--miner.priority.len_request_timestamps\\\",\\n type=int,\\n help=\\\"Number of historic request timestamps to record\\\",\\n default=50,\\n )\\n # Switches.\\n parser.add_argument(\\n \\\"--miner.no_set_weights\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If True, the miner does not set weights.\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--miner.no_serve\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If True, the miner doesnt serve the axon.\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--miner.no_start_axon\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If True, the miner doesnt start the axon.\\\",\\n default=False,\\n )\\n\\n # Mocks.\\n parser.add_argument(\\n \\\"--miner.mock_subtensor\\\",\\n action=\\\"store_true\\\",\\n help=\\\"If True, the miner will allow non-registered hotkeys to mine.\\\",\\n default=False,\\n )\\n\\n # Wandb args\\n parser.add_argument(\\n \\\"--wandb.off\\\", action=\\\"store_true\\\", help=\\\"Turn off wandb.\\\", default=False\\n )\\n parser.add_argument(\\n \\\"--wandb.project_name\\\",\\n type=str,\\n help=\\\"The name of the project where you are sending the new run.\\\",\\n default=\\\"philanthropic-thunder\\\",\\n )\\n parser.add_argument(\\n \\\"--wandb.entity\\\",\\n type=str,\\n help=\\\"An entity is a username or team name where youre sending runs.\\\",\\n default=\\\"philanthrope\\\",\\n )\\n parser.add_argument(\\n \\\"--wandb.offline\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Runs wandb in offline mode.\\\",\\n default=False,\\n )\\n parser.add_argument(\\n \\\"--wandb.weights_step_length\\\",\\n type=int,\\n help=\\\"How many steps before we log the weights.\\\",\\n default=10,\\n )\\n parser.add_argument(\\n \\\"--wandb.run_step_length\\\",\\n type=int,\\n help=\\\"How many steps before we rollover to a new run.\\\",\\n default=1500,\\n )\\n parser.add_argument(\\n \\\"--wandb.notes\\\",\\n type=str,\\n help=\\\"Notes to add to the wandb run.\\\",\\n default=\\\"\\\",\\n )\"\n },\n {\n \"identifier\": \"store_chunk_metadata\",\n \"path\": \"storage/miner/database.py\",\n \"snippet\": \"async def store_chunk_metadata(r, chunk_hash, filepath, hotkey, size, seed):\\n \\\"\\\"\\\"\\n Stores the metadata of a chunk in a Redis database.\\n\\n Args:\\n r (redis.Redis): The Redis connection instance.\\n chunk_hash (str): The unique hash identifying the chunk.\\n hotkey (str): Miner hotkey associated with the chunk.\\n size (int): The size of the chunk.\\n seed (str): The seed associated with the chunk.\\n\\n This function stores the filepath, size (as a string), and seed for the given chunk hash.\\n \\\"\\\"\\\"\\n # Ensure that all data are in the correct format\\n metadata = {\\n \\\"filepath\\\": filepath,\\n \\\"hotkey\\\": hotkey,\\n \\\"size\\\": str(size), # Convert size to string\\n \\\"seed\\\": seed, # Store seed directly\\n }\\n\\n # Use hmset (or hset which is its modern equivalent) to store the hash\\n for key, value in metadata.items():\\n await r.hset(chunk_hash, key, value)\"\n },\n {\n \"identifier\": \"update_seed_info\",\n \"path\": \"storage/miner/database.py\",\n \"snippet\": \"async def update_seed_info(r, chunk_hash, hotkey, seed):\\n \\\"\\\"\\\"\\n Updates the seed information for a specific chunk in the Redis database.\\n\\n Args:\\n r (redis.Redis): The Redis connection instance.\\n chunk_hash (str): The unique hash identifying the chunk.\\n hotkey (str): The caller hotkey value to be updated.\\n seed (str): The new seed value to be updated.\\n\\n This function updates the seed information for the specified chunk hash.\\n \\\"\\\"\\\"\\n # Update the existing seed information\\n await r.hset(chunk_hash, \\\"seed\\\", seed)\\n await r.hset(chunk_hash, \\\"hotkey\\\", hotkey)\"\n },\n {\n \"identifier\": \"get_chunk_metadata\",\n \"path\": \"storage/miner/database.py\",\n \"snippet\": \"async def get_chunk_metadata(r, chunk_hash):\\n \\\"\\\"\\\"\\n Retrieves the metadata for a specific chunk from the Redis database.\\n\\n Args:\\n r (redis.Redis): The Redis connection instance.\\n chunk_hash (str): The unique hash identifying the chunk.\\n\\n Returns:\\n dict: A dictionary containing the chunk's metadata, including filepath, size, and seed.\\n Size is converted to an integer, and seed is decoded from bytes to a string.\\n \\\"\\\"\\\"\\n metadata = await r.hgetall(chunk_hash)\\n if metadata:\\n metadata[b\\\"size\\\"] = int(metadata[b\\\"size\\\"])\\n metadata[b\\\"seed\\\"] = metadata[b\\\"seed\\\"].decode(\\\"utf-8\\\")\\n return metadata\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import os\nimport sys\nimport copy\nimport json\nimport time\nimport torch\nimport typing\nimport base64\nimport asyncio\nimport aioredis\nimport argparse\nimport threading\nimport traceback\nimport bittensor as bt\nimport storage\nfrom collections import defaultdict\nfrom Crypto.Random import get_random_bytes\nfrom typing import Dict\nfrom pprint import pprint, pformat\nfrom storage.shared.ecc import (\n hash_data,\n setup_CRS,\n ECCommitment,\n ecc_point_to_hex,\n hex_to_ecc_point,\n)\nfrom storage.shared.merkle import (\n MerkleTree,\n)\nfrom storage.shared.utils import b64_encode, b64_decode, chunk_data, safe_key_search\nfrom storage.miner import (\n run,\n set_weights,\n)\nfrom storage.miner.utils import (\n compute_subsequent_commitment,\n save_data_to_filesystem,\n load_from_filesystem,\n commit_data_with_seed,\n init_wandb,\n get_directory_size,\n get_free_disk_space,\n update_storage_stats,\n)\nfrom storage.miner.config import (\n config,\n check_config,\n add_args,\n)\nfrom storage.miner.database import (\n store_chunk_metadata,\n update_seed_info,\n get_chunk_metadata,\n)"},"token_num":{"kind":"number","value":14974,"string":"14,974"},"cropped_code":{"kind":"string","value":"\n If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and\n the function returns (True, \"Unrecognized hotkey\"). Otherwise, it returns (False,\n \"Hotkey recognized!\"), allowing the synapse to interact with the network.\n\n Usage:\n This method is internally used by the network to ensure that only recognized\n entities can participate in communication or transactions.\n \"\"\"\n if synapse.dendrite.hotkey not in self.metagraph.hotkeys:\n # Ignore requests from unrecognized entities.\n bt.logging.trace(\n f\"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}\"\n )\n return True, \"Unrecognized hotkey\"\n bt.logging.trace(\n f\"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}\"\n )\n return False, \"Hotkey recognized!\"\n\n def retrieve_priority_fn(self, synapse: storage.protocol.Retrieve) -> float:\n \"\"\"\n Assigns a priority to a given synapse based on the stake of the calling entity\n in the metagraph. This function is crucial for prioritizing network requests\n and ensuring that higher-stake entities are given precedence in processing.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey of the caller.\n\n Returns:\n - float: The priority value assigned to the synapse, derived from the stake of\n the calling hotkey in the metagraph.\n\n The priority is determined by the stake associated with the caller's UID in the\n metagraph. A higher stake results in a higher priority.\n\n Usage:\n This method is used within the network's request handling mechanism to allocate\n resources and processing time based on the stake-based priority of each request.\n \"\"\"\n caller_uid = self.metagraph.hotkeys.index(\n synapse.dendrite.hotkey\n ) # Get the caller index.\n prirority = float(\n self.metagraph.S[caller_uid]\n ) # Return the stake as the priority.\n bt.logging.trace(\n f\"Prioritizing {synapse.dendrite.hotkey} with value: \", prirority\n )\n return prirority\n\n async def store(self, synapse: storage.protocol.Store) -> storage.protocol.Store:\n \"\"\"\n Processes the storage request from a synapse by securely storing the provided data and returning\n a proof of storage. The data is committed using elliptic curve cryptography, stored on the filesystem,\n and the metadata is recorded in a Redis database. A cryptographic proof of the commitment, along with\n a digital signature from the server's hotkey, is returned in the synapse for verification by the requester.\n\n Args:\n synapse (storage.protocol.Store): An object containing the data to be stored,\n encoded in base64 format, along with associated metadata like the cryptographic\n curve parameters, a seed for the commitment, and the expected commitment group elements.\n\n Returns:\n storage.protocol.Store: The synapse is returned with additional fields populated,\n including the randomness used in the commitment, the commitment point itself, a signature\n from this storage server's hotkey, and a commitment hash that can be used for chained proofs.\n\n The method performs the following operations:\n 1. Decodes the base64-encoded data into raw bytes.\n 2. Commits to the data using the provided elliptic curve parameters and the seed to generate a commitment point.\n 3. Stores the raw byte data in the filesystem using a hash of the data as the filename.\n 4. Records metadata about the stored data in the Redis database, including the file path, previous seed, and data size.\n 5. Updates the synapse object with the commitment details and a digital signature.\n\n This process ensures the integrity and non-repudiation of the data storage, allowing clients to verify\n that their data has been stored correctly without the need to retrieve the full data set.\n\n Example usage:\n Assuming an initialized 'committer' object and 'synapse' with necessary data:\n >>> updated_synapse = self.store(synapse)\n \"\"\"\n bt.logging.info(f\"received store request: {synapse.encrypted_data[:24]}\")\n self.request_count += 1\n\n # Decode the data from base64 to raw bytes\n encrypted_byte_data = base64.b64decode(synapse.encrypted_data)\n bt.logging.trace(f\"store b64decrypted data: {encrypted_byte_data[:24]}\")\n\n # Store the data with the hash as the key in the filesystem\n bt.logging.trace(f\"entering hash_data()\")\n data_hash = hash_data(encrypted_byte_data)\n\n # If already storing this hash, simply update the validator seeds and return challenge\n bt.logging.trace(f\"checking if data already exists...\")\n if await self.database.exists(data_hash):\n # update the validator seed challenge hash in storage\n await update_seed_info(\n self.database, data_hash, synapse.dendrite.hotkey, synapse.seed\n )\n else:\n # Store the data in the filesystem\n filepath = save_data_to_filesystem(\n encrypted_byte_data, self.config.database.directory, str(data_hash)\n )\n bt.logging.trace(f\"stored data {data_hash} in filepath: {filepath}\")\n # Add the initial chunk, size, and validator seed information\n await store_chunk_metadata(\n self.database,\n data_hash,\n filepath,\n synapse.dendrite.hotkey,\n sys.getsizeof(encrypted_byte_data),\n synapse.seed,\n )\n\n # Commit to the entire data block\n bt.logging.trace(f\"entering ECCommitment()\")\n committer = ECCommitment(\n"},"all_code":{"kind":"string","value":"# The MIT License (MIT)\n# Copyright © 2023 Yuma Rao\n# Copyright © 2023 philanthrope\n\n# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated\n# documentation files (the “Software”), to deal in the Software without restriction, including without limitation\n# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,\n# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:\n\n# The above copyright notice and this permission notice shall be included in all copies or substantial portions of\n# the Software.\n\n# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO\n# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL\n# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\n# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\n# DEALINGS IN THE SOFTWARE.\n\n\n\n# import this repo\n\n\n\n\n\n\n\n\nclass miner:\n @classmethod\n def check_config(cls, config: \"bt.Config\"):\n \"\"\"\n Adds neuron-specific arguments to the argument parser.\n\n Args:\n parser (argparse.ArgumentParser): Parser to add arguments to.\n\n This class method enriches the argument parser with options specific to the neuron's configuration.\n \"\"\"\n check_config(cls, config)\n\n @classmethod\n def add_args(cls, parser):\n \"\"\"\n Adds neuron-specific arguments to the argument parser.\n\n Args:\n parser (argparse.ArgumentParser): Parser to add arguments to.\n\n This class method enriches the argument parser with options specific to the neuron's configuration.\n \"\"\"\n add_args(cls, parser)\n\n @classmethod\n def config(cls):\n \"\"\"\n Retrieves the configuration for the neuron.\n\n Returns:\n bt.Config: The configuration object for the neuron.\n\n This class method returns the neuron's configuration, which is used throughout the neuron's lifecycle\n for various functionalities and operations.\n \"\"\"\n return config(cls)\n\n subtensor: \"bt.subtensor\"\n wallet: \"bt.wallet\"\n metagraph: \"bt.metagraph\"\n\n def __init__(self):\n self.config = miner.config()\n self.check_config(self.config)\n bt.logging(config=self.config, logging_dir=self.config.miner.full_path)\n bt.logging.info(f\"{self.config}\")\n\n bt.logging.info(\"miner.__init__()\")\n\n # Init device.\n bt.logging.debug(\"loading device\")\n self.device = torch.device(self.config.miner.device)\n bt.logging.debug(str(self.device))\n\n # Init subtensor\n bt.logging.debug(\"loading subtensor\")\n self.subtensor = bt.subtensor(config=self.config)\n bt.logging.debug(str(self.subtensor))\n self.current_block = self.subtensor.get_current_block()\n\n # Init wallet.\n bt.logging.debug(\"loading wallet\")\n self.wallet = bt.wallet(config=self.config)\n self.wallet.create_if_non_existent()\n if not self.config.wallet._mock:\n if not self.subtensor.is_hotkey_registered_on_subnet(\n hotkey_ss58=self.wallet.hotkey.ss58_address, netuid=self.config.netuid\n ):\n raise Exception(\n f\"Wallet not currently registered on netuid {self.config.netuid}, please first register wallet before running\"\n )\n\n bt.logging.debug(f\"wallet: {str(self.wallet)}\")\n\n # Init metagraph.\n bt.logging.debug(\"loading metagraph\")\n self.metagraph = bt.metagraph(\n netuid=self.config.netuid, network=self.subtensor.network, sync=False\n ) # Make sure not to sync without passing subtensor\n self.metagraph.sync(subtensor=self.subtensor) # Sync metagraph with subtensor.\n bt.logging.debug(str(self.metagraph))\n\n # Setup database\n self.database = aioredis.StrictRedis(\n host=self.config.database.host,\n port=self.config.database.port,\n db=self.config.database.index,\n socket_keepalive=True,\n socket_connect_timeout=300,\n )\n\n self.my_subnet_uid = self.metagraph.hotkeys.index(\n self.wallet.hotkey.ss58_address\n )\n bt.logging.info(f\"Running miner on uid: {self.my_subnet_uid}\")\n\n # Init wandb.\n if not self.config.wandb.off:\n bt.logging.debug(\"loading wandb\")\n init_wandb(self)\n\n # The axon handles request processing, allowing validators to send this process requests.\n self.axon = bt.axon(wallet=self.wallet, config=self.config)\n bt.logging.info(f\"Axon {self.axon}\")\n\n # Attach determiners which functions are called when servicing a request.\n bt.logging.info(f\"Attaching forward functions to axon.\")\n self.axon.attach(\n forward_fn=self.store,\n blacklist_fn=self.store_blacklist_fn,\n priority_fn=self.store_priority_fn,\n ).attach(\n forward_fn=self.challenge,\n blacklist_fn=self.challenge_blacklist_fn,\n priority_fn=self.challenge_priority_fn,\n ).attach(\n forward_fn=self.retrieve,\n blacklist_fn=self.retrieve_blacklist_fn,\n priority_fn=self.retrieve_priority_fn,\n )\n\n # Serve passes the axon information to the network + netuid we are hosting on.\n # This will auto-update if the axon port of external ip have changed.\n bt.logging.info(\n f\"Serving axon {self.axon} on network: {self.subtensor.chain_endpoint} with netuid: {self.config.netuid}\"\n )\n self.axon.serve(netuid=self.config.netuid, subtensor=self.subtensor)\n\n # Start starts the miner's axon, making it active on the network.\n bt.logging.info(f\"Starting axon server on port: {self.config.axon.port}\")\n self.axon.start()\n\n # Init the event loop.\n self.loop = asyncio.get_event_loop()\n\n # Instantiate runners\n self.should_exit: bool = False\n self.is_running: bool = False\n self.thread: threading.Thread = None\n self.lock = asyncio.Lock()\n self.request_timestamps: Dict = {}\n\n self.step = 0\n\n # Init the miner's storage request tracker\n self.request_count = 0\n self.start_request_count_timer()\n self.requests_per_hour = []\n self.average_requests_per_hour = 0\n\n # Init the miner's storage usage tracker\n update_storage_stats(self)\n\n def start_request_count_timer(self):\n \"\"\"\n Initializes and starts a timer for tracking the number of requests received by the miner in an hour.\n\n This method sets up a one-hour timer that, upon expiration, calls the `reset_request_count` method to log\n the number of requests received and reset the count for the next hour. The timer is set to run in a separate\n thread to avoid blocking the main execution.\n\n Usage:\n Should be called during the initialization of the miner to start tracking requests per hour.\n \"\"\"\n self.request_count_timer = threading.Timer(3600, self.reset_request_count)\n self.request_count_timer.start()\n\n def reset_request_count(self):\n \"\"\"\n Logs the number of requests received in the last hour and resets the count.\n\n This method is automatically called when the one-hour timer set by `start_request_count_timer` expires.\n It logs the count of requests received in the last hour and then resets the count. Additionally, it\n restarts the timer for the next hour.\n\n Usage:\n This method is intended to be called automatically by a timer and typically should not be called directly.\n \"\"\"\n bt.logging.info(\n f\"Number of requests received in the last hour: {self.request_count}\"\n )\n self.requests_per_hour.append(self.request_count)\n bt.logging.info(f\"Requests per hour: {self.requests_per_hour}\")\n self.average_requests_per_hour = sum(self.requests_per_hour) / len(\n self.requests_per_hour\n )\n bt.logging.info(f\"Average requests per hour: {self.average_requests_per_hour}\")\n self.request_count = 0\n self.start_request_count_timer()\n\n @property\n async def total_storage(self):\n \"\"\"\n Calculates the total size of data stored by the miner.\n\n This method fetches all data keys from the Redis database and sums up the size of each data object.\n It provides an estimate of the total amount of data currently held by the miner.\n\n Returns:\n int: Total size of data (in bytes) stored by the miner.\n\n Example:\n >>> miner.total_storage()\n 102400 # Example output indicating 102,400 bytes of data stored\n \"\"\"\n # Fetch all keys from Redis\n all_keys = await safe_key_search(self.database, \"*\")\n\n # Filter out keys that contain a period (temporary, remove later)\n filtered_keys = [key for key in all_keys if b\".\" not in key]\n\n # Get the size of each data object and sum them up\n total_size = sum(\n [\n await get_chunk_metadata(self.database, key).get(b\"size\", 0)\n for key in filtered_keys\n ]\n )\n return total_size\n\n def store_blacklist_fn(\n self, synapse: storage.protocol.Store\n ) -> typing.Tuple[bool, str]:\n \"\"\"\n Determines whether a given synapse should be blacklisted based on the recognition\n of the hotkey in the metagraph. This function is used to filter out requests from\n entities that are not part of the network's current state.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey.\n\n Returns:\n - (bool, str): A tuple where the first element is a boolean indicating whether the\n synapse's hotkey is blacklisted, and the second element is a string message explaining\n the reason.\n\n If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and\n the function returns (True, \"Unrecognized hotkey\"). Otherwise, it returns (False,\n \"Hotkey recognized!\"), allowing the synapse to interact with the network.\n\n Usage:\n This method is internally used by the network to ensure that only recognized\n entities can participate in communication or transactions.\n \"\"\"\n if synapse.dendrite.hotkey not in self.metagraph.hotkeys:\n # Ignore requests from unrecognized entities.\n bt.logging.trace(\n f\"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}\"\n )\n return True, \"Unrecognized hotkey\"\n bt.logging.trace(\n f\"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}\"\n )\n return False, \"Hotkey recognized!\"\n\n def store_priority_fn(self, synapse: storage.protocol.Store) -> float:\n \"\"\"\n Assigns a priority to a given synapse based on the stake of the calling entity\n in the metagraph. This function is crucial for prioritizing network requests\n and ensuring that higher-stake entities are given precedence in processing.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey of the caller.\n\n Returns:\n - float: The priority value assigned to the synapse, derived from the stake of\n the calling hotkey in the metagraph.\n\n The priority is determined by the stake associated with the caller's UID in the\n metagraph. A higher stake results in a higher priority.\n\n Usage:\n This method is used within the network's request handling mechanism to allocate\n resources and processing time based on the stake-based priority of each request.\n \"\"\"\n caller_uid = self.metagraph.hotkeys.index(\n synapse.dendrite.hotkey\n ) # Get the caller index.\n prirority = float(\n self.metagraph.S[caller_uid]\n ) # Return the stake as the priority.\n bt.logging.trace(\n f\"Prioritizing {synapse.dendrite.hotkey} with value: \", prirority\n )\n return prirority\n\n def challenge_blacklist_fn(\n self, synapse: storage.protocol.Challenge\n ) -> typing.Tuple[bool, str]:\n \"\"\"\n Determines whether a given synapse should be blacklisted based on the recognition\n of the hotkey in the metagraph. This function is used to filter out requests from\n entities that are not part of the network's current state.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey.\n\n Returns:\n - (bool, str): A tuple where the first element is a boolean indicating whether the\n synapse's hotkey is blacklisted, and the second element is a string message explaining\n the reason.\n\n If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and\n the function returns (True, \"Unrecognized hotkey\"). Otherwise, it returns (False,\n \"Hotkey recognized!\"), allowing the synapse to interact with the network.\n\n Usage:\n This method is internally used by the network to ensure that only recognized\n entities can participate in communication or transactions.\n \"\"\"\n if synapse.dendrite.hotkey not in self.metagraph.hotkeys:\n # Ignore requests from unrecognized entities.\n bt.logging.trace(\n f\"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}\"\n )\n return True, \"Unrecognized hotkey\"\n bt.logging.trace(\n f\"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}\"\n )\n return False, \"Hotkey recognized!\"\n\n def challenge_priority_fn(self, synapse: storage.protocol.Challenge) -> float:\n \"\"\"\n Assigns a priority to a given synapse based on the stake of the calling entity\n in the metagraph. This function is crucial for prioritizing network requests\n and ensuring that higher-stake entities are given precedence in processing.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey of the caller.\n\n Returns:\n - float: The priority value assigned to the synapse, derived from the stake of\n the calling hotkey in the metagraph.\n\n The priority is determined by the stake associated with the caller's UID in the\n metagraph. A higher stake results in a higher priority.\n\n Usage:\n This method is used within the network's request handling mechanism to allocate\n resources and processing time based on the stake-based priority of each request.\n \"\"\"\n caller_uid = self.metagraph.hotkeys.index(\n synapse.dendrite.hotkey\n ) # Get the caller index.\n prirority = float(\n self.metagraph.S[caller_uid]\n ) # Return the stake as the priority.\n bt.logging.trace(\n f\"Prioritizing {synapse.dendrite.hotkey} with value: \", prirority\n )\n return prirority\n\n def retrieve_blacklist_fn(\n self, synapse: storage.protocol.Retrieve\n ) -> typing.Tuple[bool, str]:\n \"\"\"\n Determines whether a given synapse should be blacklisted based on the recognition\n of the hotkey in the metagraph. This function is used to filter out requests from\n entities that are not part of the network's current state.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey.\n\n Returns:\n - (bool, str): A tuple where the first element is a boolean indicating whether the\n synapse's hotkey is blacklisted, and the second element is a string message explaining\n the reason.\n\n If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and\n the function returns (True, \"Unrecognized hotkey\"). Otherwise, it returns (False,\n \"Hotkey recognized!\"), allowing the synapse to interact with the network.\n\n Usage:\n This method is internally used by the network to ensure that only recognized\n entities can participate in communication or transactions.\n \"\"\"\n if synapse.dendrite.hotkey not in self.metagraph.hotkeys:\n # Ignore requests from unrecognized entities.\n bt.logging.trace(\n f\"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}\"\n )\n return True, \"Unrecognized hotkey\"\n bt.logging.trace(\n f\"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}\"\n )\n return False, \"Hotkey recognized!\"\n\n def retrieve_priority_fn(self, synapse: storage.protocol.Retrieve) -> float:\n \"\"\"\n Assigns a priority to a given synapse based on the stake of the calling entity\n in the metagraph. This function is crucial for prioritizing network requests\n and ensuring that higher-stake entities are given precedence in processing.\n\n Parameters:\n - synapse (bt.Synapse): The synapse object which contains the dendrite information\n including the hotkey of the caller.\n\n Returns:\n - float: The priority value assigned to the synapse, derived from the stake of\n the calling hotkey in the metagraph.\n\n The priority is determined by the stake associated with the caller's UID in the\n metagraph. A higher stake results in a higher priority.\n\n Usage:\n This method is used within the network's request handling mechanism to allocate\n resources and processing time based on the stake-based priority of each request.\n \"\"\"\n caller_uid = self.metagraph.hotkeys.index(\n synapse.dendrite.hotkey\n ) # Get the caller index.\n prirority = float(\n self.metagraph.S[caller_uid]\n ) # Return the stake as the priority.\n bt.logging.trace(\n f\"Prioritizing {synapse.dendrite.hotkey} with value: \", prirority\n )\n return prirority\n\n async def store(self, synapse: storage.protocol.Store) -> storage.protocol.Store:\n \"\"\"\n Processes the storage request from a synapse by securely storing the provided data and returning\n a proof of storage. The data is committed using elliptic curve cryptography, stored on the filesystem,\n and the metadata is recorded in a Redis database. A cryptographic proof of the commitment, along with\n a digital signature from the server's hotkey, is returned in the synapse for verification by the requester.\n\n Args:\n synapse (storage.protocol.Store): An object containing the data to be stored,\n encoded in base64 format, along with associated metadata like the cryptographic\n curve parameters, a seed for the commitment, and the expected commitment group elements.\n\n Returns:\n storage.protocol.Store: The synapse is returned with additional fields populated,\n including the randomness used in the commitment, the commitment point itself, a signature\n from this storage server's hotkey, and a commitment hash that can be used for chained proofs.\n\n The method performs the following operations:\n 1. Decodes the base64-encoded data into raw bytes.\n 2. Commits to the data using the provided elliptic curve parameters and the seed to generate a commitment point.\n 3. Stores the raw byte data in the filesystem using a hash of the data as the filename.\n 4. Records metadata about the stored data in the Redis database, including the file path, previous seed, and data size.\n 5. Updates the synapse object with the commitment details and a digital signature.\n\n This process ensures the integrity and non-repudiation of the data storage, allowing clients to verify\n that their data has been stored correctly without the need to retrieve the full data set.\n\n Example usage:\n Assuming an initialized 'committer' object and 'synapse' with necessary data:\n >>> updated_synapse = self.store(synapse)\n \"\"\"\n bt.logging.info(f\"received store request: {synapse.encrypted_data[:24]}\")\n self.request_count += 1\n\n # Decode the data from base64 to raw bytes\n encrypted_byte_data = base64.b64decode(synapse.encrypted_data)\n bt.logging.trace(f\"store b64decrypted data: {encrypted_byte_data[:24]}\")\n\n # Store the data with the hash as the key in the filesystem\n bt.logging.trace(f\"entering hash_data()\")\n data_hash = hash_data(encrypted_byte_data)\n\n # If already storing this hash, simply update the validator seeds and return challenge\n bt.logging.trace(f\"checking if data already exists...\")\n if await self.database.exists(data_hash):\n # update the validator seed challenge hash in storage\n await update_seed_info(\n self.database, data_hash, synapse.dendrite.hotkey, synapse.seed\n )\n else:\n # Store the data in the filesystem\n filepath = save_data_to_filesystem(\n encrypted_byte_data, self.config.database.directory, str(data_hash)\n )\n bt.logging.trace(f\"stored data {data_hash} in filepath: {filepath}\")\n # Add the initial chunk, size, and validator seed information\n await store_chunk_metadata(\n self.database,\n data_hash,\n filepath,\n synapse.dendrite.hotkey,\n sys.getsizeof(encrypted_byte_data),\n synapse.seed,\n )\n\n # Commit to the entire data block\n bt.logging.trace(f\"entering ECCommitment()\")\n committer = ECCommitment("},"next_line":{"kind":"string","value":" hex_to_ecc_point(synapse.g, synapse.curve),"},"gold_snippet_index":{"kind":"number","value":4,"string":"4"},"created_at":{"kind":"string","value":"2023-10-26 18:54:47+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5697,"cells":{"repo_name":{"kind":"string","value":"cpacker/MemGPT"},"file_path":{"kind":"string","value":"memgpt/main.py"},"context":{"kind":"list like","value":[{"identifier":"logger","path":"memgpt/log.py","snippet":""},{"identifier":"CLIInterface","path":"memgpt/interface.py","snippet":"class CLIInterface(AgentInterface):\r\n \"\"\"Basic interface for dumping agent events to the command-line\"\"\"\r\n\r\n @staticmethod\r\n def important_message(msg):\r\n fstr = f\"{Fore.MAGENTA}{Style.BRIGHT}{{msg}}{Style.RESET_ALL}\"\r\n if STRIP_UI:\r\n fstr = \"{msg}\"\r\n print(fstr.format(msg=msg))\r\n\r\n @staticmethod\r\n def warning_message(msg):\r\n fstr = f\"{Fore.RED}{Style.BRIGHT}{{msg}}{Style.RESET_ALL}\"\r\n if STRIP_UI:\r\n fstr = \"{msg}\"\r\n else:\r\n print(fstr.format(msg=msg))\r\n\r\n @staticmethod\r\n def internal_monologue(msg):\r\n # ANSI escape code for italic is '\\x1B[3m'\r\n fstr = f\"\\x1B[3m{Fore.LIGHTBLACK_EX}💭 {{msg}}{Style.RESET_ALL}\"\r\n if STRIP_UI:\r\n fstr = \"{msg}\"\r\n print(fstr.format(msg=msg))\r\n\r\n @staticmethod\r\n def assistant_message(msg):\r\n fstr = f\"{Fore.YELLOW}{Style.BRIGHT}🤖 {Fore.YELLOW}{{msg}}{Style.RESET_ALL}\"\r\n if STRIP_UI:\r\n fstr = \"{msg}\"\r\n print(fstr.format(msg=msg))\r\n\r\n @staticmethod\r\n def memory_message(msg):\r\n fstr = f\"{Fore.LIGHTMAGENTA_EX}{Style.BRIGHT}🧠 {Fore.LIGHTMAGENTA_EX}{{msg}}{Style.RESET_ALL}\"\r\n if STRIP_UI:\r\n fstr = \"{msg}\"\r\n print(fstr.format(msg=msg))\r\n\r\n @staticmethod\r\n def system_message(msg):\r\n fstr = f\"{Fore.MAGENTA}{Style.BRIGHT}🖥️ [system] {Fore.MAGENTA}{msg}{Style.RESET_ALL}\"\r\n if STRIP_UI:\r\n fstr = \"{msg}\"\r\n print(fstr.format(msg=msg))\r\n\r\n @staticmethod\r\n def user_message(msg, raw=False, dump=False, debug=DEBUG):\r\n def print_user_message(icon, msg, printf=print):\r\n if STRIP_UI:\r\n printf(f\"{icon} {msg}\")\r\n else:\r\n printf(f\"{Fore.GREEN}{Style.BRIGHT}{icon} {Fore.GREEN}{msg}{Style.RESET_ALL}\")\r\n\r\n def printd_user_message(icon, msg):\r\n return print_user_message(icon, msg)\r\n\r\n if not (raw or dump or debug):\r\n # we do not want to repeat the message in normal use\r\n return\r\n\r\n if isinstance(msg, str):\r\n if raw:\r\n printd_user_message(\"🧑\", msg)\r\n return\r\n else:\r\n try:\r\n msg_json = json.loads(msg)\r\n except:\r\n printd(f\"{CLI_WARNING_PREFIX}failed to parse user message into json\")\r\n printd_user_message(\"🧑\", msg)\r\n return\r\n if msg_json[\"type\"] == \"user_message\":\r\n if dump:\r\n print_user_message(\"🧑\", msg_json[\"message\"])\r\n return\r\n msg_json.pop(\"type\")\r\n printd_user_message(\"🧑\", msg_json)\r\n elif msg_json[\"type\"] == \"heartbeat\":\r\n if debug:\r\n msg_json.pop(\"type\")\r\n printd_user_message(\"💓\", msg_json)\r\n elif dump:\r\n print_user_message(\"💓\", msg_json)\r\n return\r\n\r\n elif msg_json[\"type\"] == \"system_message\":\r\n msg_json.pop(\"type\")\r\n printd_user_message(\"🖥️\", msg_json)\r\n else:\r\n printd_user_message(\"🧑\", msg_json)\r\n\r\n @staticmethod\r\n def function_message(msg, debug=DEBUG):\r\n def print_function_message(icon, msg, color=Fore.RED, printf=print):\r\n if STRIP_UI:\r\n printf(f\"⚡{icon} [function] {msg}\")\r\n else:\r\n printf(f\"{color}{Style.BRIGHT}⚡{icon} [function] {color}{msg}{Style.RESET_ALL}\")\r\n\r\n def printd_function_message(icon, msg, color=Fore.RED):\r\n return print_function_message(icon, msg, color, printf=(print if debug else printd))\r\n\r\n if isinstance(msg, dict):\r\n printd_function_message(\"\", msg)\r\n return\r\n\r\n if msg.startswith(\"Success\"):\r\n printd_function_message(\"🟢\", msg)\r\n elif msg.startswith(\"Error: \"):\r\n printd_function_message(\"🔴\", msg)\r\n elif msg.startswith(\"Running \"):\r\n if debug:\r\n printd_function_message(\"\", msg)\r\n else:\r\n match = re.search(r\"Running (\\w+)\\((.*)\\)\", msg)\r\n if match:\r\n function_name = match.group(1)\r\n function_args = match.group(2)\r\n if function_name in [\"archival_memory_insert\", \"archival_memory_search\", \"core_memory_replace\", \"core_memory_append\"]:\r\n if function_name in [\"archival_memory_insert\", \"core_memory_append\", \"core_memory_replace\"]:\r\n print_function_message(\"🧠\", f\"updating memory with {function_name}\")\r\n elif function_name == \"archival_memory_search\":\r\n print_function_message(\"🧠\", f\"searching memory with {function_name}\")\r\n try:\r\n msg_dict = eval(function_args)\r\n if function_name == \"archival_memory_search\":\r\n output = f'\\tquery: {msg_dict[\"query\"]}, page: {msg_dict[\"page\"]}'\r\n if STRIP_UI:\r\n print(output)\r\n else:\r\n print(f\"{Fore.RED}{output}{Style.RESET_ALL}\")\r\n elif function_name == \"archival_memory_insert\":\r\n output = f'\\t→ {msg_dict[\"content\"]}'\r\n if STRIP_UI:\r\n print(output)\r\n else:\r\n print(f\"{Style.BRIGHT}{Fore.RED}{output}{Style.RESET_ALL}\")\r\n else:\r\n if STRIP_UI:\r\n print(f'\\t {msg_dict[\"old_content\"]}\\n\\t→ {msg_dict[\"new_content\"]}')\r\n else:\r\n print(\r\n f'{Style.BRIGHT}\\t{Fore.RED} {msg_dict[\"old_content\"]}\\n\\t{Fore.GREEN}→ {msg_dict[\"new_content\"]}{Style.RESET_ALL}'\r\n )\r\n except Exception as e:\r\n printd(str(e))\r\n printd(msg_dict)\r\n pass\r\n elif function_name in [\"conversation_search\", \"conversation_search_date\"]:\r\n print_function_message(\"🧠\", f\"searching memory with {function_name}\")\r\n try:\r\n msg_dict = eval(function_args)\r\n output = f'\\tquery: {msg_dict[\"query\"]}, page: {msg_dict[\"page\"]}'\r\n if STRIP_UI:\r\n print(output)\r\n else:\r\n print(f\"{Fore.RED}{output}{Style.RESET_ALL}\")\r\n except Exception as e:\r\n printd(str(e))\r\n printd(msg_dict)\r\n pass\r\n else:\r\n printd(f\"{CLI_WARNING_PREFIX}did not recognize function message\")\r\n printd_function_message(\"\", msg)\r\n else:\r\n try:\r\n msg_dict = json.loads(msg)\r\n if \"status\" in msg_dict and msg_dict[\"status\"] == \"OK\":\r\n printd_function_message(\"\", str(msg), color=Fore.GREEN)\r\n else:\r\n printd_function_message(\"\", str(msg), color=Fore.RED)\r\n except Exception:\r\n print(f\"{CLI_WARNING_PREFIX}did not recognize function message {type(msg)} {msg}\")\r\n printd_function_message(\"\", msg)\r\n\r\n @staticmethod\r\n def print_messages(message_sequence, dump=False):\r\n idx = len(message_sequence)\r\n for msg in message_sequence:\r\n if dump:\r\n print(f\"[{idx}] \", end=\"\")\r\n idx -= 1\r\n role = msg[\"role\"]\r\n content = msg[\"content\"]\r\n\r\n if role == \"system\":\r\n CLIInterface.system_message(content)\r\n elif role == \"assistant\":\r\n # Differentiate between internal monologue, function calls, and messages\r\n if msg.get(\"function_call\"):\r\n if content is not None:\r\n CLIInterface.internal_monologue(content)\r\n # I think the next one is not up to date\r\n # function_message(msg[\"function_call\"])\r\n args = json.loads(msg[\"function_call\"].get(\"arguments\"))\r\n CLIInterface.assistant_message(args.get(\"message\"))\r\n # assistant_message(content)\r\n else:\r\n CLIInterface.internal_monologue(content)\r\n elif role == \"user\":\r\n CLIInterface.user_message(content, dump=dump)\r\n elif role == \"function\":\r\n CLIInterface.function_message(content, debug=dump)\r\n else:\r\n print(f\"Unknown role: {content}\")\r\n\r\n @staticmethod\r\n def print_messages_simple(message_sequence):\r\n for msg in message_sequence:\r\n role = msg[\"role\"]\r\n content = msg[\"content\"]\r\n\r\n if role == \"system\":\r\n CLIInterface.system_message(content)\r\n elif role == \"assistant\":\r\n CLIInterface.assistant_message(content)\r\n elif role == \"user\":\r\n CLIInterface.user_message(content, raw=True)\r\n else:\r\n print(f\"Unknown role: {content}\")\r\n\r\n @staticmethod\r\n def print_messages_raw(message_sequence):\r\n for msg in message_sequence:\r\n print(msg)\r\n\r\n @staticmethod\r\n def step_yield():\r\n pass\r"},{"identifier":"MemGPTConfig","path":"memgpt/config.py","snippet":"class MemGPTConfig:\n config_path: str = os.path.join(MEMGPT_DIR, \"config\")\n anon_clientid: str = None\n\n # preset\n preset: str = DEFAULT_PRESET\n\n # persona parameters\n persona: str = DEFAULT_PERSONA\n human: str = DEFAULT_HUMAN\n agent: str = None\n\n # model parameters\n default_llm_config: LLMConfig = field(default_factory=LLMConfig)\n\n # embedding parameters\n default_embedding_config: EmbeddingConfig = field(default_factory=EmbeddingConfig)\n\n # database configs: archival\n archival_storage_type: str = \"chroma\" # local, db\n archival_storage_path: str = os.path.join(MEMGPT_DIR, \"chroma\")\n archival_storage_uri: str = None # TODO: eventually allow external vector DB\n\n # database configs: recall\n recall_storage_type: str = \"sqlite\" # local, db\n recall_storage_path: str = MEMGPT_DIR\n recall_storage_uri: str = None # TODO: eventually allow external vector DB\n\n # database configs: metadata storage (sources, agents, data sources)\n metadata_storage_type: str = \"sqlite\"\n metadata_storage_path: str = MEMGPT_DIR\n metadata_storage_uri: str = None\n\n # database configs: agent state\n persistence_manager_type: str = None # in-memory, db\n persistence_manager_save_file: str = None # local file\n persistence_manager_uri: str = None # db URI\n\n # version (for backcompat)\n memgpt_version: str = None\n\n # user info\n policies_accepted: bool = False\n\n def __post_init__(self):\n # ensure types\n # self.embedding_chunk_size = int(self.embedding_chunk_size)\n # self.embedding_dim = int(self.embedding_dim)\n # self.context_window = int(self.context_window)\n pass\n\n @staticmethod\n def generate_uuid() -> str:\n return uuid.UUID(int=uuid.getnode()).hex\n\n @classmethod\n def load(cls) -> \"MemGPTConfig\":\n # avoid circular import\n from memgpt.migrate import config_is_compatible, VERSION_CUTOFF\n\n if not config_is_compatible(allow_empty=True):\n error_message = \" \".join(\n [\n f\"\\nYour current config file is incompatible with MemGPT versions later than {VERSION_CUTOFF}.\",\n f\"\\nTo use MemGPT, you must either downgrade your MemGPT version (<= {VERSION_CUTOFF}) or regenerate your config using `memgpt configure`, or `memgpt migrate` if you would like to migrate old agents.\",\n ]\n )\n raise ValueError(error_message)\n\n config = configparser.ConfigParser()\n\n # allow overriding with env variables\n if os.getenv(\"MEMGPT_CONFIG_PATH\"):\n config_path = os.getenv(\"MEMGPT_CONFIG_PATH\")\n else:\n config_path = MemGPTConfig.config_path\n\n # insure all configuration directories exist\n cls.create_config_dir()\n if os.path.exists(config_path):\n # read existing config\n config.read(config_path)\n\n # Handle extraction of nested LLMConfig and EmbeddingConfig\n llm_config_dict = {\n # Extract relevant LLM configuration from the config file\n \"model\": get_field(config, \"model\", \"model\"),\n \"model_endpoint\": get_field(config, \"model\", \"model_endpoint\"),\n \"model_endpoint_type\": get_field(config, \"model\", \"model_endpoint_type\"),\n \"model_wrapper\": get_field(config, \"model\", \"model_wrapper\"),\n \"context_window\": get_field(config, \"model\", \"context_window\"),\n }\n embedding_config_dict = {\n # Extract relevant Embedding configuration from the config file\n \"embedding_endpoint\": get_field(config, \"embedding\", \"embedding_endpoint\"),\n \"embedding_model\": get_field(config, \"embedding\", \"embedding_model\"),\n \"embedding_endpoint_type\": get_field(config, \"embedding\", \"embedding_endpoint_type\"),\n \"embedding_dim\": get_field(config, \"embedding\", \"embedding_dim\"),\n \"embedding_chunk_size\": get_field(config, \"embedding\", \"chunk_size\"),\n }\n # Correct the types that aren't strings\n if llm_config_dict[\"context_window\"] is not None:\n llm_config_dict[\"context_window\"] = int(llm_config_dict[\"context_window\"])\n if embedding_config_dict[\"embedding_dim\"] is not None:\n embedding_config_dict[\"embedding_dim\"] = int(embedding_config_dict[\"embedding_dim\"])\n if embedding_config_dict[\"embedding_chunk_size\"] is not None:\n embedding_config_dict[\"embedding_chunk_size\"] = int(embedding_config_dict[\"embedding_chunk_size\"])\n # Construct the inner properties\n llm_config = LLMConfig(**llm_config_dict)\n embedding_config = EmbeddingConfig(**embedding_config_dict)\n\n # Everything else\n config_dict = {\n # Two prepared configs\n \"default_llm_config\": llm_config,\n \"default_embedding_config\": embedding_config,\n # Agent related\n \"preset\": get_field(config, \"defaults\", \"preset\"),\n \"persona\": get_field(config, \"defaults\", \"persona\"),\n \"human\": get_field(config, \"defaults\", \"human\"),\n \"agent\": get_field(config, \"defaults\", \"agent\"),\n # Storage related\n \"archival_storage_type\": get_field(config, \"archival_storage\", \"type\"),\n \"archival_storage_path\": get_field(config, \"archival_storage\", \"path\"),\n \"archival_storage_uri\": get_field(config, \"archival_storage\", \"uri\"),\n \"recall_storage_type\": get_field(config, \"recall_storage\", \"type\"),\n \"recall_storage_path\": get_field(config, \"recall_storage\", \"path\"),\n \"recall_storage_uri\": get_field(config, \"recall_storage\", \"uri\"),\n \"metadata_storage_type\": get_field(config, \"metadata_storage\", \"type\"),\n \"metadata_storage_path\": get_field(config, \"metadata_storage\", \"path\"),\n \"metadata_storage_uri\": get_field(config, \"metadata_storage\", \"uri\"),\n # Misc\n \"anon_clientid\": get_field(config, \"client\", \"anon_clientid\"),\n \"config_path\": config_path,\n \"memgpt_version\": get_field(config, \"version\", \"memgpt_version\"),\n }\n\n # Don't include null values\n config_dict = {k: v for k, v in config_dict.items() if v is not None}\n\n return cls(**config_dict)\n\n # create new config\n anon_clientid = MemGPTConfig.generate_uuid()\n config = cls(anon_clientid=anon_clientid, config_path=config_path)\n config.create_config_dir() # create dirs\n config.save() # save updated config\n\n return config\n\n def save(self):\n import memgpt\n\n config = configparser.ConfigParser()\n\n # CLI defaults\n set_field(config, \"defaults\", \"preset\", self.preset)\n set_field(config, \"defaults\", \"persona\", self.persona)\n set_field(config, \"defaults\", \"human\", self.human)\n set_field(config, \"defaults\", \"agent\", self.agent)\n\n # model defaults\n set_field(config, \"model\", \"model\", self.default_llm_config.model)\n set_field(config, \"model\", \"model_endpoint\", self.default_llm_config.model_endpoint)\n set_field(config, \"model\", \"model_endpoint_type\", self.default_llm_config.model_endpoint_type)\n set_field(config, \"model\", \"model_wrapper\", self.default_llm_config.model_wrapper)\n set_field(config, \"model\", \"context_window\", str(self.default_llm_config.context_window))\n\n # embeddings\n set_field(config, \"embedding\", \"embedding_endpoint_type\", self.default_embedding_config.embedding_endpoint_type)\n set_field(config, \"embedding\", \"embedding_endpoint\", self.default_embedding_config.embedding_endpoint)\n set_field(config, \"embedding\", \"embedding_model\", self.default_embedding_config.embedding_model)\n set_field(config, \"embedding\", \"embedding_dim\", str(self.default_embedding_config.embedding_dim))\n set_field(config, \"embedding\", \"embedding_chunk_size\", str(self.default_embedding_config.embedding_chunk_size))\n\n # archival storage\n set_field(config, \"archival_storage\", \"type\", self.archival_storage_type)\n set_field(config, \"archival_storage\", \"path\", self.archival_storage_path)\n set_field(config, \"archival_storage\", \"uri\", self.archival_storage_uri)\n\n # recall storage\n set_field(config, \"recall_storage\", \"type\", self.recall_storage_type)\n set_field(config, \"recall_storage\", \"path\", self.recall_storage_path)\n set_field(config, \"recall_storage\", \"uri\", self.recall_storage_uri)\n\n # metadata storage\n set_field(config, \"metadata_storage\", \"type\", self.metadata_storage_type)\n set_field(config, \"metadata_storage\", \"path\", self.metadata_storage_path)\n set_field(config, \"metadata_storage\", \"uri\", self.metadata_storage_uri)\n\n # set version\n set_field(config, \"version\", \"memgpt_version\", memgpt.__version__)\n\n # client\n if not self.anon_clientid:\n self.anon_clientid = self.generate_uuid()\n set_field(config, \"client\", \"anon_clientid\", self.anon_clientid)\n\n # always make sure all directories are present\n self.create_config_dir()\n\n with open(self.config_path, \"w\") as f:\n config.write(f)\n logger.debug(f\"Saved Config: {self.config_path}\")\n\n @staticmethod\n def exists():\n # allow overriding with env variables\n if os.getenv(\"MEMGPT_CONFIG_PATH\"):\n config_path = os.getenv(\"MEMGPT_CONFIG_PATH\")\n else:\n config_path = MemGPTConfig.config_path\n\n assert not os.path.isdir(config_path), f\"Config path {config_path} cannot be set to a directory.\"\n return os.path.exists(config_path)\n\n @staticmethod\n def create_config_dir():\n if not os.path.exists(MEMGPT_DIR):\n os.makedirs(MEMGPT_DIR, exist_ok=True)\n\n folders = [\"personas\", \"humans\", \"archival\", \"agents\", \"functions\", \"system_prompts\", \"presets\", \"settings\"]\n\n for folder in folders:\n if not os.path.exists(os.path.join(MEMGPT_DIR, folder)):\n os.makedirs(os.path.join(MEMGPT_DIR, folder))"},{"identifier":"run","path":"memgpt/cli/cli.py","snippet":"def run(\n persona: str = typer.Option(None, help=\"Specify persona\"),\n agent: str = typer.Option(None, help=\"Specify agent save file\"),\n human: str = typer.Option(None, help=\"Specify human\"),\n preset: str = typer.Option(None, help=\"Specify preset\"),\n # model flags\n model: str = typer.Option(None, help=\"Specify the LLM model\"),\n model_wrapper: str = typer.Option(None, help=\"Specify the LLM model wrapper\"),\n model_endpoint: str = typer.Option(None, help=\"Specify the LLM model endpoint\"),\n model_endpoint_type: str = typer.Option(None, help=\"Specify the LLM model endpoint type\"),\n context_window: int = typer.Option(None, help=\"The context window of the LLM you are using (e.g. 8k for most Mistral 7B variants)\"),\n # other\n first: bool = typer.Option(False, \"--first\", help=\"Use --first to send the first message in the sequence\"),\n strip_ui: bool = typer.Option(False, help=\"Remove all the bells and whistles in CLI output (helpful for testing)\"),\n debug: bool = typer.Option(False, \"--debug\", help=\"Use --debug to enable debugging output\"),\n no_verify: bool = typer.Option(False, help=\"Bypass message verification\"),\n yes: bool = typer.Option(False, \"-y\", help=\"Skip confirmation prompt and use defaults\"),\n):\n \"\"\"Start chatting with an MemGPT agent\n\n Example usage: `memgpt run --agent myagent --data-source mydata --persona mypersona --human myhuman --model gpt-3.5-turbo`\n\n :param persona: Specify persona\n :param agent: Specify agent name (will load existing state if the agent exists, or create a new one with that name)\n :param human: Specify human\n :param model: Specify the LLM model\n\n \"\"\"\n\n # setup logger\n # TODO: remove Utils Debug after global logging is complete.\n utils.DEBUG = debug\n # TODO: add logging command line options for runtime log level\n\n if debug:\n logger.setLevel(logging.DEBUG)\n else:\n logger.setLevel(logging.CRITICAL)\n\n from memgpt.migrate import config_is_compatible, wipe_config_and_reconfigure, VERSION_CUTOFF\n\n if not config_is_compatible(allow_empty=True):\n typer.secho(f\"\\nYour current config file is incompatible with MemGPT versions later than {VERSION_CUTOFF}\\n\", fg=typer.colors.RED)\n choices = [\n \"Run the full config setup (recommended)\",\n \"Create a new config using defaults\",\n \"Cancel\",\n ]\n selection = questionary.select(\n f\"To use MemGPT, you must either downgrade your MemGPT version (<= {VERSION_CUTOFF}), or regenerate your config. Would you like to proceed?\",\n choices=choices,\n default=choices[0],\n ).ask()\n if selection == choices[0]:\n try:\n wipe_config_and_reconfigure()\n except Exception as e:\n typer.secho(f\"Fresh config generation failed - error:\\n{e}\", fg=typer.colors.RED)\n raise\n elif selection == choices[1]:\n try:\n wipe_config_and_reconfigure(run_configure=False)\n except Exception as e:\n typer.secho(f\"Fresh config generation failed - error:\\n{e}\", fg=typer.colors.RED)\n raise\n else:\n typer.secho(\"Migration cancelled (to migrate old agents, run `memgpt migrate`)\", fg=typer.colors.RED)\n raise KeyboardInterrupt()\n\n if not MemGPTConfig.exists():\n # if no config, ask about quickstart\n # do you want to do:\n # - openai (run quickstart)\n # - memgpt hosted (run quickstart)\n # - other (run configure)\n if yes:\n # if user is passing '-y' to bypass all inputs, use memgpt hosted\n # since it can't fail out if you don't have an API key\n quickstart(backend=QuickstartChoice.memgpt_hosted)\n config = MemGPTConfig()\n\n else:\n config_choices = {\n \"memgpt\": \"Use the free MemGPT endpoints\",\n \"openai\": \"Use OpenAI (requires an OpenAI API key)\",\n \"other\": \"Other (OpenAI Azure, custom LLM endpoint, etc)\",\n }\n print()\n config_selection = questionary.select(\n \"How would you like to set up MemGPT?\",\n choices=list(config_choices.values()),\n default=config_choices[\"memgpt\"],\n ).ask()\n\n if config_selection == config_choices[\"memgpt\"]:\n print()\n quickstart(backend=QuickstartChoice.memgpt_hosted, debug=debug, terminal=False, latest=False)\n elif config_selection == config_choices[\"openai\"]:\n print()\n quickstart(backend=QuickstartChoice.openai, debug=debug, terminal=False, latest=False)\n elif config_selection == config_choices[\"other\"]:\n configure()\n else:\n raise ValueError(config_selection)\n\n config = MemGPTConfig.load()\n\n else: # load config\n config = MemGPTConfig.load()\n\n # force re-configuration is config is from old version\n if config.memgpt_version is None: # TODO: eventually add checks for older versions, if config changes again\n typer.secho(\"MemGPT has been updated to a newer version, so re-running configuration.\", fg=typer.colors.YELLOW)\n configure()\n config = MemGPTConfig.load()\n\n # read user id from config\n ms = MetadataStore(config)\n user_id = uuid.UUID(config.anon_clientid)\n user = ms.get_user(user_id=user_id)\n if user is None:\n ms.create_user(User(id=user_id))\n user = ms.get_user(user_id=user_id)\n if user is None:\n typer.secho(f\"Failed to create default user in database.\", fg=typer.colors.RED)\n sys.exit(1)\n\n # override with command line arguments\n if debug:\n config.debug = debug\n if no_verify:\n config.no_verify = no_verify\n # determine agent to use, if not provided\n if not yes and not agent:\n agents = ms.list_agents(user_id=user.id)\n agents = [a.name for a in agents]\n\n if len(agents) > 0 and not any([persona, human, model]):\n print()\n select_agent = questionary.confirm(\"Would you like to select an existing agent?\").ask()\n if select_agent is None:\n raise KeyboardInterrupt\n if select_agent:\n agent = questionary.select(\"Select agent:\", choices=agents).ask()\n\n # create agent config\n if agent and ms.get_agent(agent_name=agent, user_id=user.id): # use existing agent\n typer.secho(f\"\\n🔁 Using existing agent {agent}\", fg=typer.colors.GREEN)\n # agent_config = AgentConfig.load(agent)\n agent_state = ms.get_agent(agent_name=agent, user_id=user_id)\n printd(\"Loading agent state:\", agent_state.id)\n printd(\"Agent state:\", agent_state.state)\n # printd(\"State path:\", agent_config.save_state_dir())\n # printd(\"Persistent manager path:\", agent_config.save_persistence_manager_dir())\n # printd(\"Index path:\", agent_config.save_agent_index_dir())\n # persistence_manager = LocalStateManager(agent_config).load() # TODO: implement load\n # TODO: load prior agent state\n if persona and persona != agent_state.persona:\n typer.secho(f\"{CLI_WARNING_PREFIX}Overriding existing persona {agent_state.persona} with {persona}\", fg=typer.colors.YELLOW)\n agent_state.persona = persona\n # raise ValueError(f\"Cannot override {agent_state.name} existing persona {agent_state.persona} with {persona}\")\n if human and human != agent_state.human:\n typer.secho(f\"{CLI_WARNING_PREFIX}Overriding existing human {agent_state.human} with {human}\", fg=typer.colors.YELLOW)\n agent_state.human = human\n # raise ValueError(f\"Cannot override {agent_config.name} existing human {agent_config.human} with {human}\")\n\n # Allow overriding model specifics (model, model wrapper, model endpoint IP + type, context_window)\n if model and model != agent_state.llm_config.model:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model {agent_state.llm_config.model} with {model}\", fg=typer.colors.YELLOW\n )\n agent_state.llm_config.model = model\n if context_window is not None and int(context_window) != agent_state.llm_config.context_window:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing context window {agent_state.llm_config.context_window} with {context_window}\",\n fg=typer.colors.YELLOW,\n )\n agent_state.llm_config.context_window = context_window\n if model_wrapper and model_wrapper != agent_state.llm_config.model_wrapper:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model wrapper {agent_state.llm_config.model_wrapper} with {model_wrapper}\",\n fg=typer.colors.YELLOW,\n )\n agent_state.llm_config.model_wrapper = model_wrapper\n if model_endpoint and model_endpoint != agent_state.llm_config.model_endpoint:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model endpoint {agent_state.llm_config.model_endpoint} with {model_endpoint}\",\n fg=typer.colors.YELLOW,\n )\n agent_state.llm_config.model_endpoint = model_endpoint\n if model_endpoint_type and model_endpoint_type != agent_state.llm_config.model_endpoint_type:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model endpoint type {agent_state.llm_config.model_endpoint_type} with {model_endpoint_type}\",\n fg=typer.colors.YELLOW,\n )\n agent_state.llm_config.model_endpoint_type = model_endpoint_type\n\n # Update the agent with any overrides\n ms.update_agent(agent_state)\n\n # create agent\n memgpt_agent = Agent(agent_state, interface=interface)\n\n else: # create new agent\n # create new agent config: override defaults with args if provided\n typer.secho(\"\\n🧬 Creating new agent...\", fg=typer.colors.WHITE)\n\n if agent is None:\n # determine agent name\n # agent_count = len(ms.list_agents(user_id=user.id))\n # agent = f\"agent_{agent_count}\"\n agent = utils.create_random_username()\n\n llm_config = config.default_llm_config\n embedding_config = config.default_embedding_config # TODO allow overriding embedding params via CLI run\n\n # Allow overriding model specifics (model, model wrapper, model endpoint IP + type, context_window)\n if model and model != llm_config.model:\n typer.secho(f\"{CLI_WARNING_PREFIX}Overriding default model {llm_config.model} with {model}\", fg=typer.colors.YELLOW)\n llm_config.model = model\n if context_window is not None and int(context_window) != llm_config.context_window:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding default context window {llm_config.context_window} with {context_window}\",\n fg=typer.colors.YELLOW,\n )\n llm_config.context_window = context_window\n if model_wrapper and model_wrapper != llm_config.model_wrapper:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model wrapper {llm_config.model_wrapper} with {model_wrapper}\",\n fg=typer.colors.YELLOW,\n )\n llm_config.model_wrapper = model_wrapper\n if model_endpoint and model_endpoint != llm_config.model_endpoint:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model endpoint {llm_config.model_endpoint} with {model_endpoint}\",\n fg=typer.colors.YELLOW,\n )\n llm_config.model_endpoint = model_endpoint\n if model_endpoint_type and model_endpoint_type != llm_config.model_endpoint_type:\n typer.secho(\n f\"{CLI_WARNING_PREFIX}Overriding existing model endpoint type {llm_config.model_endpoint_type} with {model_endpoint_type}\",\n fg=typer.colors.YELLOW,\n )\n llm_config.model_endpoint_type = model_endpoint_type\n\n agent_state = AgentState(\n name=agent,\n user_id=user.id,\n persona=persona if persona else user.default_persona,\n human=human if human else user.default_human,\n preset=preset if preset else user.default_preset,\n llm_config=llm_config,\n embedding_config=embedding_config,\n )\n ms.create_agent(agent_state)\n\n typer.secho(f\"-> 🤖 Using persona profile '{agent_state.persona}'\", fg=typer.colors.WHITE)\n typer.secho(f\"-> 🧑 Using human profile '{agent_state.human}'\", fg=typer.colors.WHITE)\n\n # Supress llama-index noise\n # TODO(swooders) add persistence manager code? or comment out?\n # with suppress_stdout():\n # TODO: allow configrable state manager (only local is supported right now)\n # persistence_manager = LocalStateManager(agent_config) # TODO: insert dataset/pre-fill\n\n # create agent\n try:\n memgpt_agent = presets.create_agent_from_preset(\n agent_state=agent_state,\n interface=interface,\n )\n except ValueError as e:\n # TODO(swooders) what's the equivalent cleanup code for the new DB refactor?\n typer.secho(f\"Failed to create agent from provided information:\\n{e}\", fg=typer.colors.RED)\n # # Delete the directory of the failed agent\n # try:\n # # Path to the specific file\n # agent_config_file = agent_config.agent_config_path\n\n # # Check if the file exists\n # if os.path.isfile(agent_config_file):\n # # Delete the file\n # os.remove(agent_config_file)\n\n # # Now, delete the directory along with any remaining files in it\n # agent_save_dir = os.path.join(MEMGPT_DIR, \"agents\", agent_config.name)\n # shutil.rmtree(agent_save_dir)\n # except:\n # typer.secho(f\"Failed to delete agent directory during cleanup:\\n{e}\", fg=typer.colors.RED)\n sys.exit(1)\n typer.secho(f\"🎉 Created new agent '{agent_state.name}'\", fg=typer.colors.GREEN)\n\n # pretty print agent config\n # printd(json.dumps(vars(agent_config), indent=4, sort_keys=True, ensure_ascii=JSON_ENSURE_ASCII))\n # printd(json.dumps(agent_init_state), indent=4, sort_keys=True, ensure_ascii=JSON_ENSURE_ASCII))\n\n # configure llama index\n original_stdout = sys.stdout # unfortunate hack required to suppress confusing print statements from llama index\n sys.stdout = io.StringIO()\n embed_model = embedding_model(config=agent_state.embedding_config, user_id=user.id)\n service_context = ServiceContext.from_defaults(\n llm=None, embed_model=embed_model, chunk_size=agent_state.embedding_config.embedding_chunk_size\n )\n set_global_service_context(service_context)\n sys.stdout = original_stdout\n\n # start event loop\n from memgpt.main import run_agent_loop\n\n print() # extra space\n run_agent_loop(memgpt_agent, config, first, ms, no_verify) # TODO: add back no_verify"},{"identifier":"attach","path":"memgpt/cli/cli.py","snippet":"def attach(\n agent: str = typer.Option(help=\"Specify agent to attach data to\"),\n data_source: str = typer.Option(help=\"Data source to attach to avent\"),\n user_id: uuid.UUID = None,\n):\n # use client ID is no user_id provided\n config = MemGPTConfig.load()\n if user_id is None:\n user_id = uuid.UUID(config.anon_clientid)\n try:\n # loads the data contained in data source into the agent's memory\n from memgpt.agent_store.storage import StorageConnector, TableType\n from tqdm import tqdm\n\n ms = MetadataStore(config)\n agent = ms.get_agent(agent_name=agent, user_id=user_id)\n source = ms.get_source(source_name=data_source, user_id=user_id)\n assert source is not None, f\"Source {data_source} does not exist for user {user_id}\"\n\n # get storage connectors\n with suppress_stdout():\n source_storage = StorageConnector.get_storage_connector(TableType.PASSAGES, config, user_id=user_id)\n dest_storage = StorageConnector.get_storage_connector(TableType.ARCHIVAL_MEMORY, config, user_id=user_id, agent_id=agent.id)\n\n size = source_storage.size({\"data_source\": data_source})\n typer.secho(f\"Ingesting {size} passages into {agent.name}\", fg=typer.colors.GREEN)\n page_size = 100\n generator = source_storage.get_all_paginated(filters={\"data_source\": data_source}, page_size=page_size) # yields List[Passage]\n passages = []\n for i in tqdm(range(0, size, page_size)):\n passages = next(generator)\n print(\"inserting\", passages)\n\n # need to associated passage with agent (for filtering)\n for passage in passages:\n passage.agent_id = agent.id\n\n # insert into agent archival memory\n dest_storage.insert_many(passages)\n\n # save destination storage\n dest_storage.save()\n\n # attach to agent\n source_id = ms.get_source(source_name=data_source, user_id=user_id).id\n ms.attach_source(agent_id=agent.id, source_id=source_id, user_id=user_id)\n\n total_agent_passages = dest_storage.size()\n\n typer.secho(\n f\"Attached data source {data_source} to agent {agent}, consisting of {len(passages)}. Agent now has {total_agent_passages} embeddings in archival memory.\",\n fg=typer.colors.GREEN,\n )\n except KeyboardInterrupt:\n typer.secho(\"Operation interrupted by KeyboardInterrupt.\", fg=typer.colors.YELLOW)"},{"identifier":"version","path":"memgpt/cli/cli.py","snippet":"def version():\n import memgpt\n\n print(memgpt.__version__)\n return memgpt.__version__"},{"identifier":"server","path":"memgpt/cli/cli.py","snippet":"def server(\n type: ServerChoice = typer.Option(\"rest\", help=\"Server to run\"),\n port: int = typer.Option(None, help=\"Port to run the server on\"),\n host: str = typer.Option(None, help=\"Host to run the server on (default to localhost)\"),\n debug: bool = typer.Option(True, help=\"Turn debugging output on\"),\n):\n \"\"\"Launch a MemGPT server process\"\"\"\n\n if debug:\n from memgpt.server.server import logger as server_logger\n\n # Set the logging level\n server_logger.setLevel(logging.DEBUG)\n # Create a StreamHandler\n stream_handler = logging.StreamHandler()\n # Set the formatter (optional)\n formatter = logging.Formatter(\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\")\n stream_handler.setFormatter(formatter)\n # Add the handler to the logger\n server_logger.addHandler(stream_handler)\n\n if type == ServerChoice.rest_api:\n import uvicorn\n from memgpt.server.rest_api.server import app\n\n try:\n # Start the subprocess in a new session\n uvicorn.run(app, host=host or \"localhost\", port=port or REST_DEFAULT_PORT)\n\n except KeyboardInterrupt:\n # Handle CTRL-C\n print(\"Terminating the server...\")\n sys.exit(0)\n\n elif type == ServerChoice.ws_api:\n if port is None:\n port = WS_DEFAULT_PORT\n\n # Change to the desired directory\n script_path = Path(__file__).resolve()\n script_dir = script_path.parent\n\n server_directory = os.path.join(script_dir.parent, \"server\", \"ws_api\")\n command = f\"python server.py {port}\"\n\n # Run the command\n print(f\"Running WS (websockets) server: {command} (inside {server_directory})\")\n\n try:\n # Start the subprocess in a new session\n process = subprocess.Popen(command, shell=True, start_new_session=True, cwd=server_directory)\n process.wait()\n except KeyboardInterrupt:\n # Handle CTRL-C\n print(\"Terminating the server...\")\n process.terminate()\n try:\n process.wait(timeout=5)\n except subprocess.TimeoutExpired:\n process.kill()\n print(\"Server terminated with kill()\")\n sys.exit(0)"},{"identifier":"open_folder","path":"memgpt/cli/cli.py","snippet":"def open_folder():\n \"\"\"Open a folder viewer of the MemGPT home directory\"\"\"\n try:\n print(f\"Opening home folder: {MEMGPT_DIR}\")\n open_folder_in_explorer(MEMGPT_DIR)\n except Exception as e:\n print(f\"Failed to open folder with system viewer, error:\\n{e}\")"},{"identifier":"quickstart","path":"memgpt/cli/cli.py","snippet":"def quickstart(\n backend: QuickstartChoice = typer.Option(\"memgpt\", help=\"Quickstart setup backend\"),\n latest: bool = typer.Option(False, \"--latest\", help=\"Use --latest to pull the latest config from online\"),\n debug: bool = typer.Option(False, \"--debug\", help=\"Use --debug to enable debugging output\"),\n terminal: bool = True,\n):\n \"\"\"Set the base config file with a single command\"\"\"\n\n # setup logger\n utils.DEBUG = debug\n logging.getLogger().setLevel(logging.CRITICAL)\n if debug:\n logging.getLogger().setLevel(logging.DEBUG)\n\n # make sure everything is set up properly\n MemGPTConfig.create_config_dir()\n credentials = MemGPTCredentials.load()\n\n config_was_modified = False\n if backend == QuickstartChoice.memgpt_hosted:\n # if latest, try to pull the config from the repo\n # fallback to using local\n if latest:\n # Download the latest memgpt hosted config\n url = \"https://raw.githubusercontent.com/cpacker/MemGPT/main/memgpt/configs/memgpt_hosted.json\"\n response = requests.get(url)\n\n # Check if the request was successful\n if response.status_code == 200:\n # Parse the response content as JSON\n config = response.json()\n # Output a success message and the first few items in the dictionary as a sample\n printd(\"JSON config file downloaded successfully.\")\n config_was_modified = set_config_with_dict(config)\n else:\n typer.secho(f\"Failed to download config from {url}. Status code: {response.status_code}\", fg=typer.colors.RED)\n\n # Load the file from the relative path\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\n backup_config_path = os.path.join(script_dir, \"..\", \"configs\", \"memgpt_hosted.json\")\n try:\n with open(backup_config_path, \"r\") as file:\n backup_config = json.load(file)\n printd(\"Loaded backup config file successfully.\")\n config_was_modified = set_config_with_dict(backup_config)\n except FileNotFoundError:\n typer.secho(f\"Backup config file not found at {backup_config_path}\", fg=typer.colors.RED)\n return\n else:\n # Load the file from the relative path\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\n backup_config_path = os.path.join(script_dir, \"..\", \"configs\", \"memgpt_hosted.json\")\n try:\n with open(backup_config_path, \"r\") as file:\n backup_config = json.load(file)\n printd(\"Loaded config file successfully.\")\n config_was_modified = set_config_with_dict(backup_config)\n except FileNotFoundError:\n typer.secho(f\"Config file not found at {backup_config_path}\", fg=typer.colors.RED)\n return\n\n elif backend == QuickstartChoice.openai:\n # Make sure we have an API key\n api_key = os.getenv(\"OPENAI_API_KEY\")\n while api_key is None or len(api_key) == 0:\n # Ask for API key as input\n api_key = questionary.password(\"Enter your OpenAI API key (starts with 'sk-', see https://platform.openai.com/api-keys):\").ask()\n credentials.openai_key = api_key\n credentials.save()\n\n # if latest, try to pull the config from the repo\n # fallback to using local\n if latest:\n url = \"https://raw.githubusercontent.com/cpacker/MemGPT/main/memgpt/configs/openai.json\"\n response = requests.get(url)\n\n # Check if the request was successful\n if response.status_code == 200:\n # Parse the response content as JSON\n config = response.json()\n # Output a success message and the first few items in the dictionary as a sample\n print(\"JSON config file downloaded successfully.\")\n config_was_modified = set_config_with_dict(config)\n else:\n typer.secho(f\"Failed to download config from {url}. Status code: {response.status_code}\", fg=typer.colors.RED)\n\n # Load the file from the relative path\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\n backup_config_path = os.path.join(script_dir, \"..\", \"configs\", \"openai.json\")\n try:\n with open(backup_config_path, \"r\") as file:\n backup_config = json.load(file)\n printd(\"Loaded backup config file successfully.\")\n config_was_modified = set_config_with_dict(backup_config)\n except FileNotFoundError:\n typer.secho(f\"Backup config file not found at {backup_config_path}\", fg=typer.colors.RED)\n return\n else:\n # Load the file from the relative path\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\n backup_config_path = os.path.join(script_dir, \"..\", \"configs\", \"openai.json\")\n try:\n with open(backup_config_path, \"r\") as file:\n backup_config = json.load(file)\n printd(\"Loaded config file successfully.\")\n config_was_modified = set_config_with_dict(backup_config)\n except FileNotFoundError:\n typer.secho(f\"Config file not found at {backup_config_path}\", fg=typer.colors.RED)\n return\n\n else:\n raise NotImplementedError(backend)\n\n # 'terminal' = quickstart was run alone, in which case we should guide the user on the next command\n if terminal:\n if config_was_modified:\n typer.secho('⚡ Run \"memgpt run\" to create an agent with the new config.', fg=typer.colors.YELLOW)\n else:\n typer.secho('⚡ Run \"memgpt run\" to create an agent.', fg=typer.colors.YELLOW)"},{"identifier":"migrate","path":"memgpt/cli/cli.py","snippet":"def migrate():\n \"\"\"Migrate old agents (pre 0.2.12) to the new database system\"\"\"\n migrate_all_agents()\n migrate_all_sources()"},{"identifier":"configure","path":"memgpt/cli/cli_config.py","snippet":"@app.command()\ndef configure():\n \"\"\"Updates default MemGPT configurations\"\"\"\n\n # check credentials\n credentials = MemGPTCredentials.load()\n openai_key = get_openai_credentials()\n azure_creds = get_azure_credentials()\n\n MemGPTConfig.create_config_dir()\n\n # Will pre-populate with defaults, or what the user previously set\n config = MemGPTConfig.load()\n try:\n model_endpoint_type, model_endpoint = configure_llm_endpoint(\n config=config,\n credentials=credentials,\n )\n model, model_wrapper, context_window = configure_model(\n config=config,\n credentials=credentials,\n model_endpoint_type=model_endpoint_type,\n model_endpoint=model_endpoint,\n )\n embedding_endpoint_type, embedding_endpoint, embedding_dim, embedding_model = configure_embedding_endpoint(\n config=config,\n credentials=credentials,\n )\n default_preset, default_persona, default_human, default_agent = configure_cli(\n config=config,\n credentials=credentials,\n )\n archival_storage_type, archival_storage_uri, archival_storage_path = configure_archival_storage(\n config=config,\n credentials=credentials,\n )\n recall_storage_type, recall_storage_uri, recall_storage_path = configure_recall_storage(\n config=config,\n credentials=credentials,\n )\n except ValueError as e:\n typer.secho(str(e), fg=typer.colors.RED)\n return\n\n # openai key might have gotten added along the way\n openai_key = credentials.openai_key if credentials.openai_key is not None else openai_key\n\n # TODO: remove most of this (deplicated with User table)\n config = MemGPTConfig(\n default_llm_config=LLMConfig(\n model=model,\n model_endpoint=model_endpoint,\n model_endpoint_type=model_endpoint_type,\n model_wrapper=model_wrapper,\n context_window=context_window,\n ),\n default_embedding_config=EmbeddingConfig(\n embedding_endpoint_type=embedding_endpoint_type,\n embedding_endpoint=embedding_endpoint,\n embedding_dim=embedding_dim,\n embedding_model=embedding_model,\n ),\n # cli configs\n preset=default_preset,\n persona=default_persona,\n human=default_human,\n agent=default_agent,\n # storage\n archival_storage_type=archival_storage_type,\n archival_storage_uri=archival_storage_uri,\n archival_storage_path=archival_storage_path,\n # recall storage\n recall_storage_type=recall_storage_type,\n recall_storage_uri=recall_storage_uri,\n recall_storage_path=recall_storage_path,\n # metadata storage (currently forced to match recall storage)\n metadata_storage_type=recall_storage_type,\n metadata_storage_uri=recall_storage_uri,\n metadata_storage_path=recall_storage_path,\n )\n\n typer.secho(f\"📖 Saving config to {config.config_path}\", fg=typer.colors.GREEN)\n config.save()\n\n # create user records\n ms = MetadataStore(config)\n user_id = uuid.UUID(config.anon_clientid)\n user = User(\n id=uuid.UUID(config.anon_clientid),\n default_preset=default_preset,\n default_persona=default_persona,\n default_human=default_human,\n default_agent=default_agent,\n )\n if ms.get_user(user_id):\n # update user\n ms.update_user(user)\n else:\n ms.create_user(user)"},{"identifier":"list","path":"memgpt/cli/cli_config.py","snippet":"@app.command()\ndef list(arg: Annotated[ListChoice, typer.Argument]):\n config = MemGPTConfig.load()\n ms = MetadataStore(config)\n user_id = uuid.UUID(config.anon_clientid)\n if arg == ListChoice.agents:\n \"\"\"List all agents\"\"\"\n table = PrettyTable()\n table.field_names = [\"Name\", \"Model\", \"Persona\", \"Human\", \"Data Source\", \"Create Time\"]\n for agent in tqdm(ms.list_agents(user_id=user_id)):\n source_ids = ms.list_attached_sources(agent_id=agent.id)\n source_names = [ms.get_source(source_id=source_id).name for source_id in source_ids]\n table.add_row(\n [\n agent.name,\n agent.llm_config.model,\n agent.persona,\n agent.human,\n \",\".join(source_names),\n utils.format_datetime(agent.created_at),\n ]\n )\n print(table)\n elif arg == ListChoice.humans:\n \"\"\"List all humans\"\"\"\n table = PrettyTable()\n table.field_names = [\"Name\", \"Text\"]\n for human_file in utils.list_human_files():\n text = open(human_file, \"r\").read()\n name = os.path.basename(human_file).replace(\"txt\", \"\")\n table.add_row([name, text])\n print(table)\n elif arg == ListChoice.personas:\n \"\"\"List all personas\"\"\"\n table = PrettyTable()\n table.field_names = [\"Name\", \"Text\"]\n for persona_file in utils.list_persona_files():\n print(persona_file)\n text = open(persona_file, \"r\").read()\n name = os.path.basename(persona_file).replace(\".txt\", \"\")\n table.add_row([name, text])\n print(table)\n elif arg == ListChoice.sources:\n \"\"\"List all data sources\"\"\"\n\n # create table\n table = PrettyTable()\n table.field_names = [\"Name\", \"Created At\", \"Agents\"]\n # TODO: eventually look accross all storage connections\n # TODO: add data source stats\n # TODO: connect to agents\n\n # get all sources\n for source in ms.list_sources(user_id=user_id):\n # get attached agents\n agent_ids = ms.list_attached_agents(source_id=source.id)\n agent_names = [ms.get_agent(agent_id=agent_id).name for agent_id in agent_ids]\n\n table.add_row([source.name, utils.format_datetime(source.created_at), \",\".join(agent_names)])\n\n print(table)\n else:\n raise ValueError(f\"Unknown argument {arg}\")"},{"identifier":"add","path":"memgpt/cli/cli_config.py","snippet":"@app.command()\ndef add(\n option: str, # [human, persona]\n name: str = typer.Option(help=\"Name of human/persona\"),\n text: str = typer.Option(None, help=\"Text of human/persona\"),\n filename: str = typer.Option(None, \"-f\", help=\"Specify filename\"),\n):\n \"\"\"Add a person/human\"\"\"\n\n if option == \"persona\":\n directory = os.path.join(MEMGPT_DIR, \"personas\")\n elif option == \"human\":\n directory = os.path.join(MEMGPT_DIR, \"humans\")\n else:\n raise ValueError(f\"Unknown kind {option}\")\n\n if filename:\n assert text is None, f\"Cannot provide both filename and text\"\n # copy file to directory\n shutil.copyfile(filename, os.path.join(directory, name))\n if text:\n assert filename is None, f\"Cannot provide both filename and text\"\n # write text to file\n with open(os.path.join(directory, name), \"w\") as f:\n f.write(text)"},{"identifier":"delete","path":"memgpt/cli/cli_config.py","snippet":"@app.command()\ndef delete(option: str, name: str):\n \"\"\"Delete a source from the archival memory.\"\"\"\n\n config = MemGPTConfig.load()\n user_id = uuid.UUID(config.anon_clientid)\n ms = MetadataStore(config)\n assert ms.get_user(user_id=user_id), f\"User {user_id} does not exist\"\n\n try:\n # delete from metadata\n if option == \"source\":\n # delete metadata\n source = ms.get_source(source_name=name, user_id=user_id)\n ms.delete_source(source_id=source.id)\n\n # delete from passages\n conn = StorageConnector.get_storage_connector(TableType.PASSAGES, config, user_id=user_id)\n conn.delete({\"data_source\": name})\n\n assert (\n conn.get_all({\"data_source\": name}) == []\n ), f\"Expected no passages with source {name}, but got {conn.get_all({'data_source': name})}\"\n\n # TODO: should we also delete from agents?\n elif option == \"agent\":\n agent = ms.get_agent(agent_name=name, user_id=user_id)\n\n # recall memory\n recall_conn = StorageConnector.get_storage_connector(TableType.RECALL_MEMORY, config, user_id=user_id, agent_id=agent.id)\n recall_conn.delete({\"agent_id\": agent.id})\n\n # archival memory\n archival_conn = StorageConnector.get_storage_connector(TableType.ARCHIVAL_MEMORY, config, user_id=user_id, agent_id=agent.id)\n archival_conn.delete({\"agent_id\": agent.id})\n\n # metadata\n ms.delete_agent(agent_id=agent.id)\n\n else:\n raise ValueError(f\"Option {option} not implemented\")\n\n typer.secho(f\"Deleted source '{name}'\", fg=typer.colors.GREEN)\n\n except Exception as e:\n typer.secho(f\"Failed to deleted source '{name}'\\n{e}\", fg=typer.colors.RED)"},{"identifier":"app","path":"memgpt/cli/cli_load.py","snippet":"def insert_passages_into_source(passages: List[Passage], source_name: str, user_id: uuid.UUID, config: MemGPTConfig):\ndef insert_passages_into_source(passages: List[Passage], source_name: str, user_id: uuid.UUID, config: MemGPTConfig):\ndef store_docs(name, docs, user_id=None, show_progress=True):\ndef load_index(\n name: str = typer.Option(help=\"Name of dataset to load.\"),\n dir: str = typer.Option(help=\"Path to directory containing index.\"),\n user_id: uuid.UUID = None,\n):\ndef load_directory(\n name: str = typer.Option(help=\"Name of dataset to load.\"),\n input_dir: str = typer.Option(None, help=\"Path to directory containing dataset.\"),\n input_files: List[str] = typer.Option(None, help=\"List of paths to files containing dataset.\"),\n recursive: bool = typer.Option(False, help=\"Recursively search for files in directory.\"),\n extensions: str = typer.Option(default_extensions, help=\"Comma separated list of file extensions to load\"),\n user_id: str = typer.Option(None, help=\"User ID to associate with dataset.\"),\n):\ndef load_webpage(\n name: str = typer.Option(help=\"Name of dataset to load.\"),\n urls: List[str] = typer.Option(None, help=\"List of urls to load.\"),\n):\ndef load_database(\n name: str = typer.Option(help=\"Name of dataset to load.\"),\n query: str = typer.Option(help=\"Database query.\"),\n dump_path: str = typer.Option(None, help=\"Path to dump file.\"),\n scheme: str = typer.Option(None, help=\"Database scheme.\"),\n host: str = typer.Option(None, help=\"Database host.\"),\n port: int = typer.Option(None, help=\"Database port.\"),\n user: str = typer.Option(None, help=\"Database user.\"),\n password: str = typer.Option(None, help=\"Database password.\"),\n dbname: str = typer.Option(None, help=\"Database name.\"),\n):\ndef load_vector_database(\n name: str = typer.Option(help=\"Name of dataset to load.\"),\n uri: str = typer.Option(help=\"Database URI.\"),\n table_name: str = typer.Option(help=\"Name of table containing data.\"),\n text_column: str = typer.Option(help=\"Name of column containing text.\"),\n embedding_column: str = typer.Option(help=\"Name of column containing embedding.\"),\n user_id: uuid.UUID = None,\n):"},{"identifier":"StorageConnector","path":"memgpt/agent_store/storage.py","snippet":"class StorageConnector:\n \"\"\"Defines a DB connection that is user-specific to access data: Documents, Passages, Archival/Recall Memory\"\"\"\n\n def __init__(self, table_type: TableType, config: MemGPTConfig, user_id, agent_id=None):\n self.user_id = user_id\n self.agent_id = agent_id\n self.table_type = table_type\n\n # get object type\n if table_type == TableType.ARCHIVAL_MEMORY:\n self.type = Passage\n self.table_name = ARCHIVAL_TABLE_NAME\n elif table_type == TableType.RECALL_MEMORY:\n self.type = Message\n self.table_name = RECALL_TABLE_NAME\n elif table_type == TableType.DOCUMENTS:\n self.type = Document\n self.table_name == DOCUMENT_TABLE_NAME\n elif table_type == TableType.PASSAGES:\n self.type = Passage\n self.table_name = PASSAGE_TABLE_NAME\n else:\n raise ValueError(f\"Table type {table_type} not implemented\")\n printd(f\"Using table name {self.table_name}\")\n\n # setup base filters for agent-specific tables\n if self.table_type == TableType.ARCHIVAL_MEMORY or self.table_type == TableType.RECALL_MEMORY:\n # agent-specific table\n assert agent_id is not None, \"Agent ID must be provided for agent-specific tables\"\n self.filters = {\"user_id\": self.user_id, \"agent_id\": self.agent_id}\n elif self.table_type == TableType.PASSAGES or self.table_type == TableType.DOCUMENTS:\n # setup base filters for user-specific tables\n assert agent_id is None, \"Agent ID must not be provided for user-specific tables\"\n self.filters = {\"user_id\": self.user_id}\n else:\n raise ValueError(f\"Table type {table_type} not implemented\")\n\n def get_filters(self, filters: Optional[Dict] = {}):\n # get all filters for query\n if filters is not None:\n filter_conditions = {**self.filters, **filters}\n else:\n filter_conditions = self.filters\n return filter_conditions\n\n @staticmethod\n def get_storage_connector(table_type: TableType, config: MemGPTConfig, user_id, agent_id=None):\n if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:\n storage_type = config.archival_storage_type\n elif table_type == TableType.RECALL_MEMORY:\n storage_type = config.recall_storage_type\n else:\n raise ValueError(f\"Table type {table_type} not implemented\")\n\n if storage_type == \"postgres\":\n from memgpt.agent_store.db import PostgresStorageConnector\n\n return PostgresStorageConnector(table_type, config, user_id, agent_id)\n elif storage_type == \"chroma\":\n from memgpt.agent_store.chroma import ChromaStorageConnector\n\n return ChromaStorageConnector(table_type, config, user_id, agent_id)\n\n # TODO: add back\n # elif storage_type == \"lancedb\":\n # from memgpt.agent_store.db import LanceDBConnector\n\n # return LanceDBConnector(agent_config=agent_config, table_type=table_type)\n\n elif storage_type == \"sqlite\":\n from memgpt.agent_store.db import SQLLiteStorageConnector\n\n return SQLLiteStorageConnector(table_type, config, user_id, agent_id)\n\n else:\n raise NotImplementedError(f\"Storage type {storage_type} not implemented\")\n\n @staticmethod\n def get_archival_storage_connector(user_id, agent_id):\n config = MemGPTConfig.load()\n return StorageConnector.get_storage_connector(TableType.ARCHIVAL_MEMORY, config, user_id, agent_id)\n\n @staticmethod\n def get_recall_storage_connector(user_id, agent_id):\n config = MemGPTConfig.load()\n return StorageConnector.get_storage_connector(TableType.RECALL_MEMORY, config, user_id, agent_id)\n\n @abstractmethod\n def get_filters(self, filters: Optional[Dict] = {}):\n pass\n\n @abstractmethod\n def get_all_paginated(self, filters: Optional[Dict] = {}, page_size: Optional[int] = 1000) -> Iterator[List[Record]]:\n pass\n\n @abstractmethod\n def get_all(self, filters: Optional[Dict] = {}, limit=10) -> List[Record]:\n pass\n\n @abstractmethod\n def get(self, id: str) -> Optional[Record]:\n pass\n\n @abstractmethod\n def size(self, filters: Optional[Dict] = {}) -> int:\n pass\n\n @abstractmethod\n def insert(self, record: Record):\n pass\n\n @abstractmethod\n def insert_many(self, records: List[Record], show_progress=False):\n pass\n\n @abstractmethod\n def query(self, query: str, query_vec: List[float], top_k: int = 10, filters: Optional[Dict] = {}) -> List[Record]:\n pass\n\n @abstractmethod\n def query_date(self, start_date, end_date):\n pass\n\n @abstractmethod\n def query_text(self, query):\n pass\n\n @abstractmethod\n def delete_table(self):\n pass\n\n @abstractmethod\n def delete(self, filters: Optional[Dict] = {}):\n pass\n\n @abstractmethod\n def save(self):\n pass"},{"identifier":"TableType","path":"memgpt/agent_store/storage.py","snippet":"class TableType:\n ARCHIVAL_MEMORY = \"archival_memory\" # recall memory table: memgpt_agent_{agent_id}\n RECALL_MEMORY = \"recall_memory\" # archival memory table: memgpt_agent_recall_{agent_id}\n PASSAGES = \"passages\" # TODO\n DOCUMENTS = \"documents\" # TODO"},{"identifier":"MetadataStore","path":"memgpt/metadata.py","snippet":"class MetadataStore:\n def __init__(self, config: MemGPTConfig):\n # TODO: get DB URI or path\n if config.metadata_storage_type == \"postgres\":\n self.uri = config.metadata_storage_uri\n elif config.metadata_storage_type == \"sqlite\":\n path = os.path.join(config.metadata_storage_path, \"sqlite.db\")\n self.uri = f\"sqlite:///{path}\"\n else:\n raise ValueError(f\"Invalid metadata storage type: {config.metadata_storage_type}\")\n\n # TODO: check to see if table(s) need to be greated or not\n\n self.engine = create_engine(self.uri)\n Base.metadata.create_all(\n self.engine, tables=[UserModel.__table__, AgentModel.__table__, SourceModel.__table__, AgentSourceMappingModel.__table__]\n )\n session_maker = sessionmaker(bind=self.engine)\n self.session = session_maker()\n\n @enforce_types\n def create_agent(self, agent: AgentState):\n # insert into agent table\n # make sure agent.name does not already exist for user user_id\n if self.session.query(AgentModel).filter(AgentModel.name == agent.name).filter(AgentModel.user_id == agent.user_id).count() > 0:\n raise ValueError(f\"Agent with name {agent.name} already exists\")\n self.session.add(AgentModel(**vars(agent)))\n self.session.commit()\n\n @enforce_types\n def create_source(self, source: Source):\n # make sure source.name does not already exist for user\n if (\n self.session.query(SourceModel).filter(SourceModel.name == source.name).filter(SourceModel.user_id == source.user_id).count()\n > 0\n ):\n raise ValueError(f\"Source with name {source.name} already exists\")\n self.session.add(SourceModel(**vars(source)))\n self.session.commit()\n\n @enforce_types\n def create_user(self, user: User):\n if self.session.query(UserModel).filter(UserModel.id == user.id).count() > 0:\n raise ValueError(f\"User with id {user.id} already exists\")\n self.session.add(UserModel(**vars(user)))\n self.session.commit()\n\n @enforce_types\n def update_agent(self, agent: AgentState):\n self.session.query(AgentModel).filter(AgentModel.id == agent.id).update(vars(agent))\n self.session.commit()\n\n @enforce_types\n def update_user(self, user: User):\n self.session.query(UserModel).filter(UserModel.id == user.id).update(vars(user))\n self.session.commit()\n\n @enforce_types\n def update_source(self, source: Source):\n self.session.query(SourceModel).filter(SourceModel.id == source.id).update(vars(source))\n self.session.commit()\n\n @enforce_types\n def delete_agent(self, agent_id: uuid.UUID):\n self.session.query(AgentModel).filter(AgentModel.id == agent_id).delete()\n self.session.commit()\n\n @enforce_types\n def delete_source(self, source_id: uuid.UUID):\n # delete from sources table\n self.session.query(SourceModel).filter(SourceModel.id == source_id).delete()\n\n # delete any mappings\n self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.source_id == source_id).delete()\n\n self.session.commit()\n\n @enforce_types\n def delete_user(self, user_id: uuid.UUID):\n # delete from users table\n self.session.query(UserModel).filter(UserModel.id == user_id).delete()\n\n # delete associated agents\n self.session.query(AgentModel).filter(AgentModel.user_id == user_id).delete()\n\n # delete associated sources\n self.session.query(SourceModel).filter(SourceModel.user_id == user_id).delete()\n\n # delete associated mappings\n self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.user_id == user_id).delete()\n\n self.session.commit()\n\n @enforce_types\n def list_agents(self, user_id: uuid.UUID) -> List[AgentState]:\n results = self.session.query(AgentModel).filter(AgentModel.user_id == user_id).all()\n return [r.to_record() for r in results]\n\n @enforce_types\n def list_sources(self, user_id: uuid.UUID) -> List[Source]:\n results = self.session.query(SourceModel).filter(SourceModel.user_id == user_id).all()\n return [r.to_record() for r in results]\n\n @enforce_types\n def get_agent(\n self, agent_id: Optional[uuid.UUID] = None, agent_name: Optional[str] = None, user_id: Optional[uuid.UUID] = None\n ) -> Optional[AgentState]:\n if agent_id:\n results = self.session.query(AgentModel).filter(AgentModel.id == agent_id).all()\n else:\n assert agent_name is not None and user_id is not None, \"Must provide either agent_id or agent_name\"\n results = self.session.query(AgentModel).filter(AgentModel.name == agent_name).filter(AgentModel.user_id == user_id).all()\n\n if len(results) == 0:\n return None\n assert len(results) == 1, f\"Expected 1 result, got {len(results)}\" # should only be one result\n return results[0].to_record()\n\n @enforce_types\n def get_user(self, user_id: uuid.UUID) -> Optional[User]:\n results = self.session.query(UserModel).filter(UserModel.id == user_id).all()\n if len(results) == 0:\n return None\n assert len(results) == 1, f\"Expected 1 result, got {len(results)}\"\n return results[0].to_record()\n\n @enforce_types\n def get_source(\n self, source_id: Optional[uuid.UUID] = None, user_id: Optional[uuid.UUID] = None, source_name: Optional[str] = None\n ) -> Optional[Source]:\n if source_id:\n results = self.session.query(SourceModel).filter(SourceModel.id == source_id).all()\n else:\n assert user_id is not None and source_name is not None\n results = self.session.query(SourceModel).filter(SourceModel.name == source_name).filter(SourceModel.user_id == user_id).all()\n if len(results) == 0:\n return None\n assert len(results) == 1, f\"Expected 1 result, got {len(results)}\"\n return results[0].to_record()\n\n # agent source metadata\n @enforce_types\n def attach_source(self, user_id: uuid.UUID, agent_id: uuid.UUID, source_id: uuid.UUID):\n self.session.add(AgentSourceMappingModel(user_id=user_id, agent_id=agent_id, source_id=source_id))\n self.session.commit()\n\n @enforce_types\n def list_attached_sources(self, agent_id: uuid.UUID) -> List[Column]:\n results = self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.agent_id == agent_id).all()\n return [r.source_id for r in results]\n\n @enforce_types\n def list_attached_agents(self, source_id: uuid.UUID):\n results = self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.source_id == source_id).all()\n return [r.agent_id for r in results]\n\n @enforce_types\n def detach_source(self, agent_id: uuid.UUID, source_id: uuid.UUID):\n self.session.query(AgentSourceMappingModel).filter(\n AgentSourceMappingModel.agent_id == agent_id, AgentSourceMappingModel.source_id == source_id\n ).delete()\n self.session.commit()"},{"identifier":"save_agent","path":"memgpt/metadata.py","snippet":"def save_agent(agent: Agent, ms: MetadataStore):\n \"\"\"Save agent to metadata store\"\"\"\n\n agent.update_state()\n agent_state = agent.agent_state\n\n if ms.get_agent(agent_id=agent_state.id):\n ms.update_agent(agent_state)\n else:\n ms.create_agent(agent_state)"}],"string":"[\n {\n \"identifier\": \"logger\",\n \"path\": \"memgpt/log.py\",\n \"snippet\": \"\"\n },\n {\n \"identifier\": \"CLIInterface\",\n \"path\": \"memgpt/interface.py\",\n \"snippet\": \"class CLIInterface(AgentInterface):\\r\\n \\\"\\\"\\\"Basic interface for dumping agent events to the command-line\\\"\\\"\\\"\\r\\n\\r\\n @staticmethod\\r\\n def important_message(msg):\\r\\n fstr = f\\\"{Fore.MAGENTA}{Style.BRIGHT}{{msg}}{Style.RESET_ALL}\\\"\\r\\n if STRIP_UI:\\r\\n fstr = \\\"{msg}\\\"\\r\\n print(fstr.format(msg=msg))\\r\\n\\r\\n @staticmethod\\r\\n def warning_message(msg):\\r\\n fstr = f\\\"{Fore.RED}{Style.BRIGHT}{{msg}}{Style.RESET_ALL}\\\"\\r\\n if STRIP_UI:\\r\\n fstr = \\\"{msg}\\\"\\r\\n else:\\r\\n print(fstr.format(msg=msg))\\r\\n\\r\\n @staticmethod\\r\\n def internal_monologue(msg):\\r\\n # ANSI escape code for italic is '\\\\x1B[3m'\\r\\n fstr = f\\\"\\\\x1B[3m{Fore.LIGHTBLACK_EX}💭 {{msg}}{Style.RESET_ALL}\\\"\\r\\n if STRIP_UI:\\r\\n fstr = \\\"{msg}\\\"\\r\\n print(fstr.format(msg=msg))\\r\\n\\r\\n @staticmethod\\r\\n def assistant_message(msg):\\r\\n fstr = f\\\"{Fore.YELLOW}{Style.BRIGHT}🤖 {Fore.YELLOW}{{msg}}{Style.RESET_ALL}\\\"\\r\\n if STRIP_UI:\\r\\n fstr = \\\"{msg}\\\"\\r\\n print(fstr.format(msg=msg))\\r\\n\\r\\n @staticmethod\\r\\n def memory_message(msg):\\r\\n fstr = f\\\"{Fore.LIGHTMAGENTA_EX}{Style.BRIGHT}🧠 {Fore.LIGHTMAGENTA_EX}{{msg}}{Style.RESET_ALL}\\\"\\r\\n if STRIP_UI:\\r\\n fstr = \\\"{msg}\\\"\\r\\n print(fstr.format(msg=msg))\\r\\n\\r\\n @staticmethod\\r\\n def system_message(msg):\\r\\n fstr = f\\\"{Fore.MAGENTA}{Style.BRIGHT}🖥️ [system] {Fore.MAGENTA}{msg}{Style.RESET_ALL}\\\"\\r\\n if STRIP_UI:\\r\\n fstr = \\\"{msg}\\\"\\r\\n print(fstr.format(msg=msg))\\r\\n\\r\\n @staticmethod\\r\\n def user_message(msg, raw=False, dump=False, debug=DEBUG):\\r\\n def print_user_message(icon, msg, printf=print):\\r\\n if STRIP_UI:\\r\\n printf(f\\\"{icon} {msg}\\\")\\r\\n else:\\r\\n printf(f\\\"{Fore.GREEN}{Style.BRIGHT}{icon} {Fore.GREEN}{msg}{Style.RESET_ALL}\\\")\\r\\n\\r\\n def printd_user_message(icon, msg):\\r\\n return print_user_message(icon, msg)\\r\\n\\r\\n if not (raw or dump or debug):\\r\\n # we do not want to repeat the message in normal use\\r\\n return\\r\\n\\r\\n if isinstance(msg, str):\\r\\n if raw:\\r\\n printd_user_message(\\\"🧑\\\", msg)\\r\\n return\\r\\n else:\\r\\n try:\\r\\n msg_json = json.loads(msg)\\r\\n except:\\r\\n printd(f\\\"{CLI_WARNING_PREFIX}failed to parse user message into json\\\")\\r\\n printd_user_message(\\\"🧑\\\", msg)\\r\\n return\\r\\n if msg_json[\\\"type\\\"] == \\\"user_message\\\":\\r\\n if dump:\\r\\n print_user_message(\\\"🧑\\\", msg_json[\\\"message\\\"])\\r\\n return\\r\\n msg_json.pop(\\\"type\\\")\\r\\n printd_user_message(\\\"🧑\\\", msg_json)\\r\\n elif msg_json[\\\"type\\\"] == \\\"heartbeat\\\":\\r\\n if debug:\\r\\n msg_json.pop(\\\"type\\\")\\r\\n printd_user_message(\\\"💓\\\", msg_json)\\r\\n elif dump:\\r\\n print_user_message(\\\"💓\\\", msg_json)\\r\\n return\\r\\n\\r\\n elif msg_json[\\\"type\\\"] == \\\"system_message\\\":\\r\\n msg_json.pop(\\\"type\\\")\\r\\n printd_user_message(\\\"🖥️\\\", msg_json)\\r\\n else:\\r\\n printd_user_message(\\\"🧑\\\", msg_json)\\r\\n\\r\\n @staticmethod\\r\\n def function_message(msg, debug=DEBUG):\\r\\n def print_function_message(icon, msg, color=Fore.RED, printf=print):\\r\\n if STRIP_UI:\\r\\n printf(f\\\"⚡{icon} [function] {msg}\\\")\\r\\n else:\\r\\n printf(f\\\"{color}{Style.BRIGHT}⚡{icon} [function] {color}{msg}{Style.RESET_ALL}\\\")\\r\\n\\r\\n def printd_function_message(icon, msg, color=Fore.RED):\\r\\n return print_function_message(icon, msg, color, printf=(print if debug else printd))\\r\\n\\r\\n if isinstance(msg, dict):\\r\\n printd_function_message(\\\"\\\", msg)\\r\\n return\\r\\n\\r\\n if msg.startswith(\\\"Success\\\"):\\r\\n printd_function_message(\\\"🟢\\\", msg)\\r\\n elif msg.startswith(\\\"Error: \\\"):\\r\\n printd_function_message(\\\"🔴\\\", msg)\\r\\n elif msg.startswith(\\\"Running \\\"):\\r\\n if debug:\\r\\n printd_function_message(\\\"\\\", msg)\\r\\n else:\\r\\n match = re.search(r\\\"Running (\\\\w+)\\\\((.*)\\\\)\\\", msg)\\r\\n if match:\\r\\n function_name = match.group(1)\\r\\n function_args = match.group(2)\\r\\n if function_name in [\\\"archival_memory_insert\\\", \\\"archival_memory_search\\\", \\\"core_memory_replace\\\", \\\"core_memory_append\\\"]:\\r\\n if function_name in [\\\"archival_memory_insert\\\", \\\"core_memory_append\\\", \\\"core_memory_replace\\\"]:\\r\\n print_function_message(\\\"🧠\\\", f\\\"updating memory with {function_name}\\\")\\r\\n elif function_name == \\\"archival_memory_search\\\":\\r\\n print_function_message(\\\"🧠\\\", f\\\"searching memory with {function_name}\\\")\\r\\n try:\\r\\n msg_dict = eval(function_args)\\r\\n if function_name == \\\"archival_memory_search\\\":\\r\\n output = f'\\\\tquery: {msg_dict[\\\"query\\\"]}, page: {msg_dict[\\\"page\\\"]}'\\r\\n if STRIP_UI:\\r\\n print(output)\\r\\n else:\\r\\n print(f\\\"{Fore.RED}{output}{Style.RESET_ALL}\\\")\\r\\n elif function_name == \\\"archival_memory_insert\\\":\\r\\n output = f'\\\\t→ {msg_dict[\\\"content\\\"]}'\\r\\n if STRIP_UI:\\r\\n print(output)\\r\\n else:\\r\\n print(f\\\"{Style.BRIGHT}{Fore.RED}{output}{Style.RESET_ALL}\\\")\\r\\n else:\\r\\n if STRIP_UI:\\r\\n print(f'\\\\t {msg_dict[\\\"old_content\\\"]}\\\\n\\\\t→ {msg_dict[\\\"new_content\\\"]}')\\r\\n else:\\r\\n print(\\r\\n f'{Style.BRIGHT}\\\\t{Fore.RED} {msg_dict[\\\"old_content\\\"]}\\\\n\\\\t{Fore.GREEN}→ {msg_dict[\\\"new_content\\\"]}{Style.RESET_ALL}'\\r\\n )\\r\\n except Exception as e:\\r\\n printd(str(e))\\r\\n printd(msg_dict)\\r\\n pass\\r\\n elif function_name in [\\\"conversation_search\\\", \\\"conversation_search_date\\\"]:\\r\\n print_function_message(\\\"🧠\\\", f\\\"searching memory with {function_name}\\\")\\r\\n try:\\r\\n msg_dict = eval(function_args)\\r\\n output = f'\\\\tquery: {msg_dict[\\\"query\\\"]}, page: {msg_dict[\\\"page\\\"]}'\\r\\n if STRIP_UI:\\r\\n print(output)\\r\\n else:\\r\\n print(f\\\"{Fore.RED}{output}{Style.RESET_ALL}\\\")\\r\\n except Exception as e:\\r\\n printd(str(e))\\r\\n printd(msg_dict)\\r\\n pass\\r\\n else:\\r\\n printd(f\\\"{CLI_WARNING_PREFIX}did not recognize function message\\\")\\r\\n printd_function_message(\\\"\\\", msg)\\r\\n else:\\r\\n try:\\r\\n msg_dict = json.loads(msg)\\r\\n if \\\"status\\\" in msg_dict and msg_dict[\\\"status\\\"] == \\\"OK\\\":\\r\\n printd_function_message(\\\"\\\", str(msg), color=Fore.GREEN)\\r\\n else:\\r\\n printd_function_message(\\\"\\\", str(msg), color=Fore.RED)\\r\\n except Exception:\\r\\n print(f\\\"{CLI_WARNING_PREFIX}did not recognize function message {type(msg)} {msg}\\\")\\r\\n printd_function_message(\\\"\\\", msg)\\r\\n\\r\\n @staticmethod\\r\\n def print_messages(message_sequence, dump=False):\\r\\n idx = len(message_sequence)\\r\\n for msg in message_sequence:\\r\\n if dump:\\r\\n print(f\\\"[{idx}] \\\", end=\\\"\\\")\\r\\n idx -= 1\\r\\n role = msg[\\\"role\\\"]\\r\\n content = msg[\\\"content\\\"]\\r\\n\\r\\n if role == \\\"system\\\":\\r\\n CLIInterface.system_message(content)\\r\\n elif role == \\\"assistant\\\":\\r\\n # Differentiate between internal monologue, function calls, and messages\\r\\n if msg.get(\\\"function_call\\\"):\\r\\n if content is not None:\\r\\n CLIInterface.internal_monologue(content)\\r\\n # I think the next one is not up to date\\r\\n # function_message(msg[\\\"function_call\\\"])\\r\\n args = json.loads(msg[\\\"function_call\\\"].get(\\\"arguments\\\"))\\r\\n CLIInterface.assistant_message(args.get(\\\"message\\\"))\\r\\n # assistant_message(content)\\r\\n else:\\r\\n CLIInterface.internal_monologue(content)\\r\\n elif role == \\\"user\\\":\\r\\n CLIInterface.user_message(content, dump=dump)\\r\\n elif role == \\\"function\\\":\\r\\n CLIInterface.function_message(content, debug=dump)\\r\\n else:\\r\\n print(f\\\"Unknown role: {content}\\\")\\r\\n\\r\\n @staticmethod\\r\\n def print_messages_simple(message_sequence):\\r\\n for msg in message_sequence:\\r\\n role = msg[\\\"role\\\"]\\r\\n content = msg[\\\"content\\\"]\\r\\n\\r\\n if role == \\\"system\\\":\\r\\n CLIInterface.system_message(content)\\r\\n elif role == \\\"assistant\\\":\\r\\n CLIInterface.assistant_message(content)\\r\\n elif role == \\\"user\\\":\\r\\n CLIInterface.user_message(content, raw=True)\\r\\n else:\\r\\n print(f\\\"Unknown role: {content}\\\")\\r\\n\\r\\n @staticmethod\\r\\n def print_messages_raw(message_sequence):\\r\\n for msg in message_sequence:\\r\\n print(msg)\\r\\n\\r\\n @staticmethod\\r\\n def step_yield():\\r\\n pass\\r\"\n },\n {\n \"identifier\": \"MemGPTConfig\",\n \"path\": \"memgpt/config.py\",\n \"snippet\": \"class MemGPTConfig:\\n config_path: str = os.path.join(MEMGPT_DIR, \\\"config\\\")\\n anon_clientid: str = None\\n\\n # preset\\n preset: str = DEFAULT_PRESET\\n\\n # persona parameters\\n persona: str = DEFAULT_PERSONA\\n human: str = DEFAULT_HUMAN\\n agent: str = None\\n\\n # model parameters\\n default_llm_config: LLMConfig = field(default_factory=LLMConfig)\\n\\n # embedding parameters\\n default_embedding_config: EmbeddingConfig = field(default_factory=EmbeddingConfig)\\n\\n # database configs: archival\\n archival_storage_type: str = \\\"chroma\\\" # local, db\\n archival_storage_path: str = os.path.join(MEMGPT_DIR, \\\"chroma\\\")\\n archival_storage_uri: str = None # TODO: eventually allow external vector DB\\n\\n # database configs: recall\\n recall_storage_type: str = \\\"sqlite\\\" # local, db\\n recall_storage_path: str = MEMGPT_DIR\\n recall_storage_uri: str = None # TODO: eventually allow external vector DB\\n\\n # database configs: metadata storage (sources, agents, data sources)\\n metadata_storage_type: str = \\\"sqlite\\\"\\n metadata_storage_path: str = MEMGPT_DIR\\n metadata_storage_uri: str = None\\n\\n # database configs: agent state\\n persistence_manager_type: str = None # in-memory, db\\n persistence_manager_save_file: str = None # local file\\n persistence_manager_uri: str = None # db URI\\n\\n # version (for backcompat)\\n memgpt_version: str = None\\n\\n # user info\\n policies_accepted: bool = False\\n\\n def __post_init__(self):\\n # ensure types\\n # self.embedding_chunk_size = int(self.embedding_chunk_size)\\n # self.embedding_dim = int(self.embedding_dim)\\n # self.context_window = int(self.context_window)\\n pass\\n\\n @staticmethod\\n def generate_uuid() -> str:\\n return uuid.UUID(int=uuid.getnode()).hex\\n\\n @classmethod\\n def load(cls) -> \\\"MemGPTConfig\\\":\\n # avoid circular import\\n from memgpt.migrate import config_is_compatible, VERSION_CUTOFF\\n\\n if not config_is_compatible(allow_empty=True):\\n error_message = \\\" \\\".join(\\n [\\n f\\\"\\\\nYour current config file is incompatible with MemGPT versions later than {VERSION_CUTOFF}.\\\",\\n f\\\"\\\\nTo use MemGPT, you must either downgrade your MemGPT version (<= {VERSION_CUTOFF}) or regenerate your config using `memgpt configure`, or `memgpt migrate` if you would like to migrate old agents.\\\",\\n ]\\n )\\n raise ValueError(error_message)\\n\\n config = configparser.ConfigParser()\\n\\n # allow overriding with env variables\\n if os.getenv(\\\"MEMGPT_CONFIG_PATH\\\"):\\n config_path = os.getenv(\\\"MEMGPT_CONFIG_PATH\\\")\\n else:\\n config_path = MemGPTConfig.config_path\\n\\n # insure all configuration directories exist\\n cls.create_config_dir()\\n if os.path.exists(config_path):\\n # read existing config\\n config.read(config_path)\\n\\n # Handle extraction of nested LLMConfig and EmbeddingConfig\\n llm_config_dict = {\\n # Extract relevant LLM configuration from the config file\\n \\\"model\\\": get_field(config, \\\"model\\\", \\\"model\\\"),\\n \\\"model_endpoint\\\": get_field(config, \\\"model\\\", \\\"model_endpoint\\\"),\\n \\\"model_endpoint_type\\\": get_field(config, \\\"model\\\", \\\"model_endpoint_type\\\"),\\n \\\"model_wrapper\\\": get_field(config, \\\"model\\\", \\\"model_wrapper\\\"),\\n \\\"context_window\\\": get_field(config, \\\"model\\\", \\\"context_window\\\"),\\n }\\n embedding_config_dict = {\\n # Extract relevant Embedding configuration from the config file\\n \\\"embedding_endpoint\\\": get_field(config, \\\"embedding\\\", \\\"embedding_endpoint\\\"),\\n \\\"embedding_model\\\": get_field(config, \\\"embedding\\\", \\\"embedding_model\\\"),\\n \\\"embedding_endpoint_type\\\": get_field(config, \\\"embedding\\\", \\\"embedding_endpoint_type\\\"),\\n \\\"embedding_dim\\\": get_field(config, \\\"embedding\\\", \\\"embedding_dim\\\"),\\n \\\"embedding_chunk_size\\\": get_field(config, \\\"embedding\\\", \\\"chunk_size\\\"),\\n }\\n # Correct the types that aren't strings\\n if llm_config_dict[\\\"context_window\\\"] is not None:\\n llm_config_dict[\\\"context_window\\\"] = int(llm_config_dict[\\\"context_window\\\"])\\n if embedding_config_dict[\\\"embedding_dim\\\"] is not None:\\n embedding_config_dict[\\\"embedding_dim\\\"] = int(embedding_config_dict[\\\"embedding_dim\\\"])\\n if embedding_config_dict[\\\"embedding_chunk_size\\\"] is not None:\\n embedding_config_dict[\\\"embedding_chunk_size\\\"] = int(embedding_config_dict[\\\"embedding_chunk_size\\\"])\\n # Construct the inner properties\\n llm_config = LLMConfig(**llm_config_dict)\\n embedding_config = EmbeddingConfig(**embedding_config_dict)\\n\\n # Everything else\\n config_dict = {\\n # Two prepared configs\\n \\\"default_llm_config\\\": llm_config,\\n \\\"default_embedding_config\\\": embedding_config,\\n # Agent related\\n \\\"preset\\\": get_field(config, \\\"defaults\\\", \\\"preset\\\"),\\n \\\"persona\\\": get_field(config, \\\"defaults\\\", \\\"persona\\\"),\\n \\\"human\\\": get_field(config, \\\"defaults\\\", \\\"human\\\"),\\n \\\"agent\\\": get_field(config, \\\"defaults\\\", \\\"agent\\\"),\\n # Storage related\\n \\\"archival_storage_type\\\": get_field(config, \\\"archival_storage\\\", \\\"type\\\"),\\n \\\"archival_storage_path\\\": get_field(config, \\\"archival_storage\\\", \\\"path\\\"),\\n \\\"archival_storage_uri\\\": get_field(config, \\\"archival_storage\\\", \\\"uri\\\"),\\n \\\"recall_storage_type\\\": get_field(config, \\\"recall_storage\\\", \\\"type\\\"),\\n \\\"recall_storage_path\\\": get_field(config, \\\"recall_storage\\\", \\\"path\\\"),\\n \\\"recall_storage_uri\\\": get_field(config, \\\"recall_storage\\\", \\\"uri\\\"),\\n \\\"metadata_storage_type\\\": get_field(config, \\\"metadata_storage\\\", \\\"type\\\"),\\n \\\"metadata_storage_path\\\": get_field(config, \\\"metadata_storage\\\", \\\"path\\\"),\\n \\\"metadata_storage_uri\\\": get_field(config, \\\"metadata_storage\\\", \\\"uri\\\"),\\n # Misc\\n \\\"anon_clientid\\\": get_field(config, \\\"client\\\", \\\"anon_clientid\\\"),\\n \\\"config_path\\\": config_path,\\n \\\"memgpt_version\\\": get_field(config, \\\"version\\\", \\\"memgpt_version\\\"),\\n }\\n\\n # Don't include null values\\n config_dict = {k: v for k, v in config_dict.items() if v is not None}\\n\\n return cls(**config_dict)\\n\\n # create new config\\n anon_clientid = MemGPTConfig.generate_uuid()\\n config = cls(anon_clientid=anon_clientid, config_path=config_path)\\n config.create_config_dir() # create dirs\\n config.save() # save updated config\\n\\n return config\\n\\n def save(self):\\n import memgpt\\n\\n config = configparser.ConfigParser()\\n\\n # CLI defaults\\n set_field(config, \\\"defaults\\\", \\\"preset\\\", self.preset)\\n set_field(config, \\\"defaults\\\", \\\"persona\\\", self.persona)\\n set_field(config, \\\"defaults\\\", \\\"human\\\", self.human)\\n set_field(config, \\\"defaults\\\", \\\"agent\\\", self.agent)\\n\\n # model defaults\\n set_field(config, \\\"model\\\", \\\"model\\\", self.default_llm_config.model)\\n set_field(config, \\\"model\\\", \\\"model_endpoint\\\", self.default_llm_config.model_endpoint)\\n set_field(config, \\\"model\\\", \\\"model_endpoint_type\\\", self.default_llm_config.model_endpoint_type)\\n set_field(config, \\\"model\\\", \\\"model_wrapper\\\", self.default_llm_config.model_wrapper)\\n set_field(config, \\\"model\\\", \\\"context_window\\\", str(self.default_llm_config.context_window))\\n\\n # embeddings\\n set_field(config, \\\"embedding\\\", \\\"embedding_endpoint_type\\\", self.default_embedding_config.embedding_endpoint_type)\\n set_field(config, \\\"embedding\\\", \\\"embedding_endpoint\\\", self.default_embedding_config.embedding_endpoint)\\n set_field(config, \\\"embedding\\\", \\\"embedding_model\\\", self.default_embedding_config.embedding_model)\\n set_field(config, \\\"embedding\\\", \\\"embedding_dim\\\", str(self.default_embedding_config.embedding_dim))\\n set_field(config, \\\"embedding\\\", \\\"embedding_chunk_size\\\", str(self.default_embedding_config.embedding_chunk_size))\\n\\n # archival storage\\n set_field(config, \\\"archival_storage\\\", \\\"type\\\", self.archival_storage_type)\\n set_field(config, \\\"archival_storage\\\", \\\"path\\\", self.archival_storage_path)\\n set_field(config, \\\"archival_storage\\\", \\\"uri\\\", self.archival_storage_uri)\\n\\n # recall storage\\n set_field(config, \\\"recall_storage\\\", \\\"type\\\", self.recall_storage_type)\\n set_field(config, \\\"recall_storage\\\", \\\"path\\\", self.recall_storage_path)\\n set_field(config, \\\"recall_storage\\\", \\\"uri\\\", self.recall_storage_uri)\\n\\n # metadata storage\\n set_field(config, \\\"metadata_storage\\\", \\\"type\\\", self.metadata_storage_type)\\n set_field(config, \\\"metadata_storage\\\", \\\"path\\\", self.metadata_storage_path)\\n set_field(config, \\\"metadata_storage\\\", \\\"uri\\\", self.metadata_storage_uri)\\n\\n # set version\\n set_field(config, \\\"version\\\", \\\"memgpt_version\\\", memgpt.__version__)\\n\\n # client\\n if not self.anon_clientid:\\n self.anon_clientid = self.generate_uuid()\\n set_field(config, \\\"client\\\", \\\"anon_clientid\\\", self.anon_clientid)\\n\\n # always make sure all directories are present\\n self.create_config_dir()\\n\\n with open(self.config_path, \\\"w\\\") as f:\\n config.write(f)\\n logger.debug(f\\\"Saved Config: {self.config_path}\\\")\\n\\n @staticmethod\\n def exists():\\n # allow overriding with env variables\\n if os.getenv(\\\"MEMGPT_CONFIG_PATH\\\"):\\n config_path = os.getenv(\\\"MEMGPT_CONFIG_PATH\\\")\\n else:\\n config_path = MemGPTConfig.config_path\\n\\n assert not os.path.isdir(config_path), f\\\"Config path {config_path} cannot be set to a directory.\\\"\\n return os.path.exists(config_path)\\n\\n @staticmethod\\n def create_config_dir():\\n if not os.path.exists(MEMGPT_DIR):\\n os.makedirs(MEMGPT_DIR, exist_ok=True)\\n\\n folders = [\\\"personas\\\", \\\"humans\\\", \\\"archival\\\", \\\"agents\\\", \\\"functions\\\", \\\"system_prompts\\\", \\\"presets\\\", \\\"settings\\\"]\\n\\n for folder in folders:\\n if not os.path.exists(os.path.join(MEMGPT_DIR, folder)):\\n os.makedirs(os.path.join(MEMGPT_DIR, folder))\"\n },\n {\n \"identifier\": \"run\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def run(\\n persona: str = typer.Option(None, help=\\\"Specify persona\\\"),\\n agent: str = typer.Option(None, help=\\\"Specify agent save file\\\"),\\n human: str = typer.Option(None, help=\\\"Specify human\\\"),\\n preset: str = typer.Option(None, help=\\\"Specify preset\\\"),\\n # model flags\\n model: str = typer.Option(None, help=\\\"Specify the LLM model\\\"),\\n model_wrapper: str = typer.Option(None, help=\\\"Specify the LLM model wrapper\\\"),\\n model_endpoint: str = typer.Option(None, help=\\\"Specify the LLM model endpoint\\\"),\\n model_endpoint_type: str = typer.Option(None, help=\\\"Specify the LLM model endpoint type\\\"),\\n context_window: int = typer.Option(None, help=\\\"The context window of the LLM you are using (e.g. 8k for most Mistral 7B variants)\\\"),\\n # other\\n first: bool = typer.Option(False, \\\"--first\\\", help=\\\"Use --first to send the first message in the sequence\\\"),\\n strip_ui: bool = typer.Option(False, help=\\\"Remove all the bells and whistles in CLI output (helpful for testing)\\\"),\\n debug: bool = typer.Option(False, \\\"--debug\\\", help=\\\"Use --debug to enable debugging output\\\"),\\n no_verify: bool = typer.Option(False, help=\\\"Bypass message verification\\\"),\\n yes: bool = typer.Option(False, \\\"-y\\\", help=\\\"Skip confirmation prompt and use defaults\\\"),\\n):\\n \\\"\\\"\\\"Start chatting with an MemGPT agent\\n\\n Example usage: `memgpt run --agent myagent --data-source mydata --persona mypersona --human myhuman --model gpt-3.5-turbo`\\n\\n :param persona: Specify persona\\n :param agent: Specify agent name (will load existing state if the agent exists, or create a new one with that name)\\n :param human: Specify human\\n :param model: Specify the LLM model\\n\\n \\\"\\\"\\\"\\n\\n # setup logger\\n # TODO: remove Utils Debug after global logging is complete.\\n utils.DEBUG = debug\\n # TODO: add logging command line options for runtime log level\\n\\n if debug:\\n logger.setLevel(logging.DEBUG)\\n else:\\n logger.setLevel(logging.CRITICAL)\\n\\n from memgpt.migrate import config_is_compatible, wipe_config_and_reconfigure, VERSION_CUTOFF\\n\\n if not config_is_compatible(allow_empty=True):\\n typer.secho(f\\\"\\\\nYour current config file is incompatible with MemGPT versions later than {VERSION_CUTOFF}\\\\n\\\", fg=typer.colors.RED)\\n choices = [\\n \\\"Run the full config setup (recommended)\\\",\\n \\\"Create a new config using defaults\\\",\\n \\\"Cancel\\\",\\n ]\\n selection = questionary.select(\\n f\\\"To use MemGPT, you must either downgrade your MemGPT version (<= {VERSION_CUTOFF}), or regenerate your config. Would you like to proceed?\\\",\\n choices=choices,\\n default=choices[0],\\n ).ask()\\n if selection == choices[0]:\\n try:\\n wipe_config_and_reconfigure()\\n except Exception as e:\\n typer.secho(f\\\"Fresh config generation failed - error:\\\\n{e}\\\", fg=typer.colors.RED)\\n raise\\n elif selection == choices[1]:\\n try:\\n wipe_config_and_reconfigure(run_configure=False)\\n except Exception as e:\\n typer.secho(f\\\"Fresh config generation failed - error:\\\\n{e}\\\", fg=typer.colors.RED)\\n raise\\n else:\\n typer.secho(\\\"Migration cancelled (to migrate old agents, run `memgpt migrate`)\\\", fg=typer.colors.RED)\\n raise KeyboardInterrupt()\\n\\n if not MemGPTConfig.exists():\\n # if no config, ask about quickstart\\n # do you want to do:\\n # - openai (run quickstart)\\n # - memgpt hosted (run quickstart)\\n # - other (run configure)\\n if yes:\\n # if user is passing '-y' to bypass all inputs, use memgpt hosted\\n # since it can't fail out if you don't have an API key\\n quickstart(backend=QuickstartChoice.memgpt_hosted)\\n config = MemGPTConfig()\\n\\n else:\\n config_choices = {\\n \\\"memgpt\\\": \\\"Use the free MemGPT endpoints\\\",\\n \\\"openai\\\": \\\"Use OpenAI (requires an OpenAI API key)\\\",\\n \\\"other\\\": \\\"Other (OpenAI Azure, custom LLM endpoint, etc)\\\",\\n }\\n print()\\n config_selection = questionary.select(\\n \\\"How would you like to set up MemGPT?\\\",\\n choices=list(config_choices.values()),\\n default=config_choices[\\\"memgpt\\\"],\\n ).ask()\\n\\n if config_selection == config_choices[\\\"memgpt\\\"]:\\n print()\\n quickstart(backend=QuickstartChoice.memgpt_hosted, debug=debug, terminal=False, latest=False)\\n elif config_selection == config_choices[\\\"openai\\\"]:\\n print()\\n quickstart(backend=QuickstartChoice.openai, debug=debug, terminal=False, latest=False)\\n elif config_selection == config_choices[\\\"other\\\"]:\\n configure()\\n else:\\n raise ValueError(config_selection)\\n\\n config = MemGPTConfig.load()\\n\\n else: # load config\\n config = MemGPTConfig.load()\\n\\n # force re-configuration is config is from old version\\n if config.memgpt_version is None: # TODO: eventually add checks for older versions, if config changes again\\n typer.secho(\\\"MemGPT has been updated to a newer version, so re-running configuration.\\\", fg=typer.colors.YELLOW)\\n configure()\\n config = MemGPTConfig.load()\\n\\n # read user id from config\\n ms = MetadataStore(config)\\n user_id = uuid.UUID(config.anon_clientid)\\n user = ms.get_user(user_id=user_id)\\n if user is None:\\n ms.create_user(User(id=user_id))\\n user = ms.get_user(user_id=user_id)\\n if user is None:\\n typer.secho(f\\\"Failed to create default user in database.\\\", fg=typer.colors.RED)\\n sys.exit(1)\\n\\n # override with command line arguments\\n if debug:\\n config.debug = debug\\n if no_verify:\\n config.no_verify = no_verify\\n # determine agent to use, if not provided\\n if not yes and not agent:\\n agents = ms.list_agents(user_id=user.id)\\n agents = [a.name for a in agents]\\n\\n if len(agents) > 0 and not any([persona, human, model]):\\n print()\\n select_agent = questionary.confirm(\\\"Would you like to select an existing agent?\\\").ask()\\n if select_agent is None:\\n raise KeyboardInterrupt\\n if select_agent:\\n agent = questionary.select(\\\"Select agent:\\\", choices=agents).ask()\\n\\n # create agent config\\n if agent and ms.get_agent(agent_name=agent, user_id=user.id): # use existing agent\\n typer.secho(f\\\"\\\\n🔁 Using existing agent {agent}\\\", fg=typer.colors.GREEN)\\n # agent_config = AgentConfig.load(agent)\\n agent_state = ms.get_agent(agent_name=agent, user_id=user_id)\\n printd(\\\"Loading agent state:\\\", agent_state.id)\\n printd(\\\"Agent state:\\\", agent_state.state)\\n # printd(\\\"State path:\\\", agent_config.save_state_dir())\\n # printd(\\\"Persistent manager path:\\\", agent_config.save_persistence_manager_dir())\\n # printd(\\\"Index path:\\\", agent_config.save_agent_index_dir())\\n # persistence_manager = LocalStateManager(agent_config).load() # TODO: implement load\\n # TODO: load prior agent state\\n if persona and persona != agent_state.persona:\\n typer.secho(f\\\"{CLI_WARNING_PREFIX}Overriding existing persona {agent_state.persona} with {persona}\\\", fg=typer.colors.YELLOW)\\n agent_state.persona = persona\\n # raise ValueError(f\\\"Cannot override {agent_state.name} existing persona {agent_state.persona} with {persona}\\\")\\n if human and human != agent_state.human:\\n typer.secho(f\\\"{CLI_WARNING_PREFIX}Overriding existing human {agent_state.human} with {human}\\\", fg=typer.colors.YELLOW)\\n agent_state.human = human\\n # raise ValueError(f\\\"Cannot override {agent_config.name} existing human {agent_config.human} with {human}\\\")\\n\\n # Allow overriding model specifics (model, model wrapper, model endpoint IP + type, context_window)\\n if model and model != agent_state.llm_config.model:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model {agent_state.llm_config.model} with {model}\\\", fg=typer.colors.YELLOW\\n )\\n agent_state.llm_config.model = model\\n if context_window is not None and int(context_window) != agent_state.llm_config.context_window:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing context window {agent_state.llm_config.context_window} with {context_window}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n agent_state.llm_config.context_window = context_window\\n if model_wrapper and model_wrapper != agent_state.llm_config.model_wrapper:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model wrapper {agent_state.llm_config.model_wrapper} with {model_wrapper}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n agent_state.llm_config.model_wrapper = model_wrapper\\n if model_endpoint and model_endpoint != agent_state.llm_config.model_endpoint:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model endpoint {agent_state.llm_config.model_endpoint} with {model_endpoint}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n agent_state.llm_config.model_endpoint = model_endpoint\\n if model_endpoint_type and model_endpoint_type != agent_state.llm_config.model_endpoint_type:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model endpoint type {agent_state.llm_config.model_endpoint_type} with {model_endpoint_type}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n agent_state.llm_config.model_endpoint_type = model_endpoint_type\\n\\n # Update the agent with any overrides\\n ms.update_agent(agent_state)\\n\\n # create agent\\n memgpt_agent = Agent(agent_state, interface=interface)\\n\\n else: # create new agent\\n # create new agent config: override defaults with args if provided\\n typer.secho(\\\"\\\\n🧬 Creating new agent...\\\", fg=typer.colors.WHITE)\\n\\n if agent is None:\\n # determine agent name\\n # agent_count = len(ms.list_agents(user_id=user.id))\\n # agent = f\\\"agent_{agent_count}\\\"\\n agent = utils.create_random_username()\\n\\n llm_config = config.default_llm_config\\n embedding_config = config.default_embedding_config # TODO allow overriding embedding params via CLI run\\n\\n # Allow overriding model specifics (model, model wrapper, model endpoint IP + type, context_window)\\n if model and model != llm_config.model:\\n typer.secho(f\\\"{CLI_WARNING_PREFIX}Overriding default model {llm_config.model} with {model}\\\", fg=typer.colors.YELLOW)\\n llm_config.model = model\\n if context_window is not None and int(context_window) != llm_config.context_window:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding default context window {llm_config.context_window} with {context_window}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n llm_config.context_window = context_window\\n if model_wrapper and model_wrapper != llm_config.model_wrapper:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model wrapper {llm_config.model_wrapper} with {model_wrapper}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n llm_config.model_wrapper = model_wrapper\\n if model_endpoint and model_endpoint != llm_config.model_endpoint:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model endpoint {llm_config.model_endpoint} with {model_endpoint}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n llm_config.model_endpoint = model_endpoint\\n if model_endpoint_type and model_endpoint_type != llm_config.model_endpoint_type:\\n typer.secho(\\n f\\\"{CLI_WARNING_PREFIX}Overriding existing model endpoint type {llm_config.model_endpoint_type} with {model_endpoint_type}\\\",\\n fg=typer.colors.YELLOW,\\n )\\n llm_config.model_endpoint_type = model_endpoint_type\\n\\n agent_state = AgentState(\\n name=agent,\\n user_id=user.id,\\n persona=persona if persona else user.default_persona,\\n human=human if human else user.default_human,\\n preset=preset if preset else user.default_preset,\\n llm_config=llm_config,\\n embedding_config=embedding_config,\\n )\\n ms.create_agent(agent_state)\\n\\n typer.secho(f\\\"-> 🤖 Using persona profile '{agent_state.persona}'\\\", fg=typer.colors.WHITE)\\n typer.secho(f\\\"-> 🧑 Using human profile '{agent_state.human}'\\\", fg=typer.colors.WHITE)\\n\\n # Supress llama-index noise\\n # TODO(swooders) add persistence manager code? or comment out?\\n # with suppress_stdout():\\n # TODO: allow configrable state manager (only local is supported right now)\\n # persistence_manager = LocalStateManager(agent_config) # TODO: insert dataset/pre-fill\\n\\n # create agent\\n try:\\n memgpt_agent = presets.create_agent_from_preset(\\n agent_state=agent_state,\\n interface=interface,\\n )\\n except ValueError as e:\\n # TODO(swooders) what's the equivalent cleanup code for the new DB refactor?\\n typer.secho(f\\\"Failed to create agent from provided information:\\\\n{e}\\\", fg=typer.colors.RED)\\n # # Delete the directory of the failed agent\\n # try:\\n # # Path to the specific file\\n # agent_config_file = agent_config.agent_config_path\\n\\n # # Check if the file exists\\n # if os.path.isfile(agent_config_file):\\n # # Delete the file\\n # os.remove(agent_config_file)\\n\\n # # Now, delete the directory along with any remaining files in it\\n # agent_save_dir = os.path.join(MEMGPT_DIR, \\\"agents\\\", agent_config.name)\\n # shutil.rmtree(agent_save_dir)\\n # except:\\n # typer.secho(f\\\"Failed to delete agent directory during cleanup:\\\\n{e}\\\", fg=typer.colors.RED)\\n sys.exit(1)\\n typer.secho(f\\\"🎉 Created new agent '{agent_state.name}'\\\", fg=typer.colors.GREEN)\\n\\n # pretty print agent config\\n # printd(json.dumps(vars(agent_config), indent=4, sort_keys=True, ensure_ascii=JSON_ENSURE_ASCII))\\n # printd(json.dumps(agent_init_state), indent=4, sort_keys=True, ensure_ascii=JSON_ENSURE_ASCII))\\n\\n # configure llama index\\n original_stdout = sys.stdout # unfortunate hack required to suppress confusing print statements from llama index\\n sys.stdout = io.StringIO()\\n embed_model = embedding_model(config=agent_state.embedding_config, user_id=user.id)\\n service_context = ServiceContext.from_defaults(\\n llm=None, embed_model=embed_model, chunk_size=agent_state.embedding_config.embedding_chunk_size\\n )\\n set_global_service_context(service_context)\\n sys.stdout = original_stdout\\n\\n # start event loop\\n from memgpt.main import run_agent_loop\\n\\n print() # extra space\\n run_agent_loop(memgpt_agent, config, first, ms, no_verify) # TODO: add back no_verify\"\n },\n {\n \"identifier\": \"attach\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def attach(\\n agent: str = typer.Option(help=\\\"Specify agent to attach data to\\\"),\\n data_source: str = typer.Option(help=\\\"Data source to attach to avent\\\"),\\n user_id: uuid.UUID = None,\\n):\\n # use client ID is no user_id provided\\n config = MemGPTConfig.load()\\n if user_id is None:\\n user_id = uuid.UUID(config.anon_clientid)\\n try:\\n # loads the data contained in data source into the agent's memory\\n from memgpt.agent_store.storage import StorageConnector, TableType\\n from tqdm import tqdm\\n\\n ms = MetadataStore(config)\\n agent = ms.get_agent(agent_name=agent, user_id=user_id)\\n source = ms.get_source(source_name=data_source, user_id=user_id)\\n assert source is not None, f\\\"Source {data_source} does not exist for user {user_id}\\\"\\n\\n # get storage connectors\\n with suppress_stdout():\\n source_storage = StorageConnector.get_storage_connector(TableType.PASSAGES, config, user_id=user_id)\\n dest_storage = StorageConnector.get_storage_connector(TableType.ARCHIVAL_MEMORY, config, user_id=user_id, agent_id=agent.id)\\n\\n size = source_storage.size({\\\"data_source\\\": data_source})\\n typer.secho(f\\\"Ingesting {size} passages into {agent.name}\\\", fg=typer.colors.GREEN)\\n page_size = 100\\n generator = source_storage.get_all_paginated(filters={\\\"data_source\\\": data_source}, page_size=page_size) # yields List[Passage]\\n passages = []\\n for i in tqdm(range(0, size, page_size)):\\n passages = next(generator)\\n print(\\\"inserting\\\", passages)\\n\\n # need to associated passage with agent (for filtering)\\n for passage in passages:\\n passage.agent_id = agent.id\\n\\n # insert into agent archival memory\\n dest_storage.insert_many(passages)\\n\\n # save destination storage\\n dest_storage.save()\\n\\n # attach to agent\\n source_id = ms.get_source(source_name=data_source, user_id=user_id).id\\n ms.attach_source(agent_id=agent.id, source_id=source_id, user_id=user_id)\\n\\n total_agent_passages = dest_storage.size()\\n\\n typer.secho(\\n f\\\"Attached data source {data_source} to agent {agent}, consisting of {len(passages)}. Agent now has {total_agent_passages} embeddings in archival memory.\\\",\\n fg=typer.colors.GREEN,\\n )\\n except KeyboardInterrupt:\\n typer.secho(\\\"Operation interrupted by KeyboardInterrupt.\\\", fg=typer.colors.YELLOW)\"\n },\n {\n \"identifier\": \"version\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def version():\\n import memgpt\\n\\n print(memgpt.__version__)\\n return memgpt.__version__\"\n },\n {\n \"identifier\": \"server\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def server(\\n type: ServerChoice = typer.Option(\\\"rest\\\", help=\\\"Server to run\\\"),\\n port: int = typer.Option(None, help=\\\"Port to run the server on\\\"),\\n host: str = typer.Option(None, help=\\\"Host to run the server on (default to localhost)\\\"),\\n debug: bool = typer.Option(True, help=\\\"Turn debugging output on\\\"),\\n):\\n \\\"\\\"\\\"Launch a MemGPT server process\\\"\\\"\\\"\\n\\n if debug:\\n from memgpt.server.server import logger as server_logger\\n\\n # Set the logging level\\n server_logger.setLevel(logging.DEBUG)\\n # Create a StreamHandler\\n stream_handler = logging.StreamHandler()\\n # Set the formatter (optional)\\n formatter = logging.Formatter(\\\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\\\")\\n stream_handler.setFormatter(formatter)\\n # Add the handler to the logger\\n server_logger.addHandler(stream_handler)\\n\\n if type == ServerChoice.rest_api:\\n import uvicorn\\n from memgpt.server.rest_api.server import app\\n\\n try:\\n # Start the subprocess in a new session\\n uvicorn.run(app, host=host or \\\"localhost\\\", port=port or REST_DEFAULT_PORT)\\n\\n except KeyboardInterrupt:\\n # Handle CTRL-C\\n print(\\\"Terminating the server...\\\")\\n sys.exit(0)\\n\\n elif type == ServerChoice.ws_api:\\n if port is None:\\n port = WS_DEFAULT_PORT\\n\\n # Change to the desired directory\\n script_path = Path(__file__).resolve()\\n script_dir = script_path.parent\\n\\n server_directory = os.path.join(script_dir.parent, \\\"server\\\", \\\"ws_api\\\")\\n command = f\\\"python server.py {port}\\\"\\n\\n # Run the command\\n print(f\\\"Running WS (websockets) server: {command} (inside {server_directory})\\\")\\n\\n try:\\n # Start the subprocess in a new session\\n process = subprocess.Popen(command, shell=True, start_new_session=True, cwd=server_directory)\\n process.wait()\\n except KeyboardInterrupt:\\n # Handle CTRL-C\\n print(\\\"Terminating the server...\\\")\\n process.terminate()\\n try:\\n process.wait(timeout=5)\\n except subprocess.TimeoutExpired:\\n process.kill()\\n print(\\\"Server terminated with kill()\\\")\\n sys.exit(0)\"\n },\n {\n \"identifier\": \"open_folder\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def open_folder():\\n \\\"\\\"\\\"Open a folder viewer of the MemGPT home directory\\\"\\\"\\\"\\n try:\\n print(f\\\"Opening home folder: {MEMGPT_DIR}\\\")\\n open_folder_in_explorer(MEMGPT_DIR)\\n except Exception as e:\\n print(f\\\"Failed to open folder with system viewer, error:\\\\n{e}\\\")\"\n },\n {\n \"identifier\": \"quickstart\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def quickstart(\\n backend: QuickstartChoice = typer.Option(\\\"memgpt\\\", help=\\\"Quickstart setup backend\\\"),\\n latest: bool = typer.Option(False, \\\"--latest\\\", help=\\\"Use --latest to pull the latest config from online\\\"),\\n debug: bool = typer.Option(False, \\\"--debug\\\", help=\\\"Use --debug to enable debugging output\\\"),\\n terminal: bool = True,\\n):\\n \\\"\\\"\\\"Set the base config file with a single command\\\"\\\"\\\"\\n\\n # setup logger\\n utils.DEBUG = debug\\n logging.getLogger().setLevel(logging.CRITICAL)\\n if debug:\\n logging.getLogger().setLevel(logging.DEBUG)\\n\\n # make sure everything is set up properly\\n MemGPTConfig.create_config_dir()\\n credentials = MemGPTCredentials.load()\\n\\n config_was_modified = False\\n if backend == QuickstartChoice.memgpt_hosted:\\n # if latest, try to pull the config from the repo\\n # fallback to using local\\n if latest:\\n # Download the latest memgpt hosted config\\n url = \\\"https://raw.githubusercontent.com/cpacker/MemGPT/main/memgpt/configs/memgpt_hosted.json\\\"\\n response = requests.get(url)\\n\\n # Check if the request was successful\\n if response.status_code == 200:\\n # Parse the response content as JSON\\n config = response.json()\\n # Output a success message and the first few items in the dictionary as a sample\\n printd(\\\"JSON config file downloaded successfully.\\\")\\n config_was_modified = set_config_with_dict(config)\\n else:\\n typer.secho(f\\\"Failed to download config from {url}. Status code: {response.status_code}\\\", fg=typer.colors.RED)\\n\\n # Load the file from the relative path\\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\\n backup_config_path = os.path.join(script_dir, \\\"..\\\", \\\"configs\\\", \\\"memgpt_hosted.json\\\")\\n try:\\n with open(backup_config_path, \\\"r\\\") as file:\\n backup_config = json.load(file)\\n printd(\\\"Loaded backup config file successfully.\\\")\\n config_was_modified = set_config_with_dict(backup_config)\\n except FileNotFoundError:\\n typer.secho(f\\\"Backup config file not found at {backup_config_path}\\\", fg=typer.colors.RED)\\n return\\n else:\\n # Load the file from the relative path\\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\\n backup_config_path = os.path.join(script_dir, \\\"..\\\", \\\"configs\\\", \\\"memgpt_hosted.json\\\")\\n try:\\n with open(backup_config_path, \\\"r\\\") as file:\\n backup_config = json.load(file)\\n printd(\\\"Loaded config file successfully.\\\")\\n config_was_modified = set_config_with_dict(backup_config)\\n except FileNotFoundError:\\n typer.secho(f\\\"Config file not found at {backup_config_path}\\\", fg=typer.colors.RED)\\n return\\n\\n elif backend == QuickstartChoice.openai:\\n # Make sure we have an API key\\n api_key = os.getenv(\\\"OPENAI_API_KEY\\\")\\n while api_key is None or len(api_key) == 0:\\n # Ask for API key as input\\n api_key = questionary.password(\\\"Enter your OpenAI API key (starts with 'sk-', see https://platform.openai.com/api-keys):\\\").ask()\\n credentials.openai_key = api_key\\n credentials.save()\\n\\n # if latest, try to pull the config from the repo\\n # fallback to using local\\n if latest:\\n url = \\\"https://raw.githubusercontent.com/cpacker/MemGPT/main/memgpt/configs/openai.json\\\"\\n response = requests.get(url)\\n\\n # Check if the request was successful\\n if response.status_code == 200:\\n # Parse the response content as JSON\\n config = response.json()\\n # Output a success message and the first few items in the dictionary as a sample\\n print(\\\"JSON config file downloaded successfully.\\\")\\n config_was_modified = set_config_with_dict(config)\\n else:\\n typer.secho(f\\\"Failed to download config from {url}. Status code: {response.status_code}\\\", fg=typer.colors.RED)\\n\\n # Load the file from the relative path\\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\\n backup_config_path = os.path.join(script_dir, \\\"..\\\", \\\"configs\\\", \\\"openai.json\\\")\\n try:\\n with open(backup_config_path, \\\"r\\\") as file:\\n backup_config = json.load(file)\\n printd(\\\"Loaded backup config file successfully.\\\")\\n config_was_modified = set_config_with_dict(backup_config)\\n except FileNotFoundError:\\n typer.secho(f\\\"Backup config file not found at {backup_config_path}\\\", fg=typer.colors.RED)\\n return\\n else:\\n # Load the file from the relative path\\n script_dir = os.path.dirname(__file__) # Get the directory where the script is located\\n backup_config_path = os.path.join(script_dir, \\\"..\\\", \\\"configs\\\", \\\"openai.json\\\")\\n try:\\n with open(backup_config_path, \\\"r\\\") as file:\\n backup_config = json.load(file)\\n printd(\\\"Loaded config file successfully.\\\")\\n config_was_modified = set_config_with_dict(backup_config)\\n except FileNotFoundError:\\n typer.secho(f\\\"Config file not found at {backup_config_path}\\\", fg=typer.colors.RED)\\n return\\n\\n else:\\n raise NotImplementedError(backend)\\n\\n # 'terminal' = quickstart was run alone, in which case we should guide the user on the next command\\n if terminal:\\n if config_was_modified:\\n typer.secho('⚡ Run \\\"memgpt run\\\" to create an agent with the new config.', fg=typer.colors.YELLOW)\\n else:\\n typer.secho('⚡ Run \\\"memgpt run\\\" to create an agent.', fg=typer.colors.YELLOW)\"\n },\n {\n \"identifier\": \"migrate\",\n \"path\": \"memgpt/cli/cli.py\",\n \"snippet\": \"def migrate():\\n \\\"\\\"\\\"Migrate old agents (pre 0.2.12) to the new database system\\\"\\\"\\\"\\n migrate_all_agents()\\n migrate_all_sources()\"\n },\n {\n \"identifier\": \"configure\",\n \"path\": \"memgpt/cli/cli_config.py\",\n \"snippet\": \"@app.command()\\ndef configure():\\n \\\"\\\"\\\"Updates default MemGPT configurations\\\"\\\"\\\"\\n\\n # check credentials\\n credentials = MemGPTCredentials.load()\\n openai_key = get_openai_credentials()\\n azure_creds = get_azure_credentials()\\n\\n MemGPTConfig.create_config_dir()\\n\\n # Will pre-populate with defaults, or what the user previously set\\n config = MemGPTConfig.load()\\n try:\\n model_endpoint_type, model_endpoint = configure_llm_endpoint(\\n config=config,\\n credentials=credentials,\\n )\\n model, model_wrapper, context_window = configure_model(\\n config=config,\\n credentials=credentials,\\n model_endpoint_type=model_endpoint_type,\\n model_endpoint=model_endpoint,\\n )\\n embedding_endpoint_type, embedding_endpoint, embedding_dim, embedding_model = configure_embedding_endpoint(\\n config=config,\\n credentials=credentials,\\n )\\n default_preset, default_persona, default_human, default_agent = configure_cli(\\n config=config,\\n credentials=credentials,\\n )\\n archival_storage_type, archival_storage_uri, archival_storage_path = configure_archival_storage(\\n config=config,\\n credentials=credentials,\\n )\\n recall_storage_type, recall_storage_uri, recall_storage_path = configure_recall_storage(\\n config=config,\\n credentials=credentials,\\n )\\n except ValueError as e:\\n typer.secho(str(e), fg=typer.colors.RED)\\n return\\n\\n # openai key might have gotten added along the way\\n openai_key = credentials.openai_key if credentials.openai_key is not None else openai_key\\n\\n # TODO: remove most of this (deplicated with User table)\\n config = MemGPTConfig(\\n default_llm_config=LLMConfig(\\n model=model,\\n model_endpoint=model_endpoint,\\n model_endpoint_type=model_endpoint_type,\\n model_wrapper=model_wrapper,\\n context_window=context_window,\\n ),\\n default_embedding_config=EmbeddingConfig(\\n embedding_endpoint_type=embedding_endpoint_type,\\n embedding_endpoint=embedding_endpoint,\\n embedding_dim=embedding_dim,\\n embedding_model=embedding_model,\\n ),\\n # cli configs\\n preset=default_preset,\\n persona=default_persona,\\n human=default_human,\\n agent=default_agent,\\n # storage\\n archival_storage_type=archival_storage_type,\\n archival_storage_uri=archival_storage_uri,\\n archival_storage_path=archival_storage_path,\\n # recall storage\\n recall_storage_type=recall_storage_type,\\n recall_storage_uri=recall_storage_uri,\\n recall_storage_path=recall_storage_path,\\n # metadata storage (currently forced to match recall storage)\\n metadata_storage_type=recall_storage_type,\\n metadata_storage_uri=recall_storage_uri,\\n metadata_storage_path=recall_storage_path,\\n )\\n\\n typer.secho(f\\\"📖 Saving config to {config.config_path}\\\", fg=typer.colors.GREEN)\\n config.save()\\n\\n # create user records\\n ms = MetadataStore(config)\\n user_id = uuid.UUID(config.anon_clientid)\\n user = User(\\n id=uuid.UUID(config.anon_clientid),\\n default_preset=default_preset,\\n default_persona=default_persona,\\n default_human=default_human,\\n default_agent=default_agent,\\n )\\n if ms.get_user(user_id):\\n # update user\\n ms.update_user(user)\\n else:\\n ms.create_user(user)\"\n },\n {\n \"identifier\": \"list\",\n \"path\": \"memgpt/cli/cli_config.py\",\n \"snippet\": \"@app.command()\\ndef list(arg: Annotated[ListChoice, typer.Argument]):\\n config = MemGPTConfig.load()\\n ms = MetadataStore(config)\\n user_id = uuid.UUID(config.anon_clientid)\\n if arg == ListChoice.agents:\\n \\\"\\\"\\\"List all agents\\\"\\\"\\\"\\n table = PrettyTable()\\n table.field_names = [\\\"Name\\\", \\\"Model\\\", \\\"Persona\\\", \\\"Human\\\", \\\"Data Source\\\", \\\"Create Time\\\"]\\n for agent in tqdm(ms.list_agents(user_id=user_id)):\\n source_ids = ms.list_attached_sources(agent_id=agent.id)\\n source_names = [ms.get_source(source_id=source_id).name for source_id in source_ids]\\n table.add_row(\\n [\\n agent.name,\\n agent.llm_config.model,\\n agent.persona,\\n agent.human,\\n \\\",\\\".join(source_names),\\n utils.format_datetime(agent.created_at),\\n ]\\n )\\n print(table)\\n elif arg == ListChoice.humans:\\n \\\"\\\"\\\"List all humans\\\"\\\"\\\"\\n table = PrettyTable()\\n table.field_names = [\\\"Name\\\", \\\"Text\\\"]\\n for human_file in utils.list_human_files():\\n text = open(human_file, \\\"r\\\").read()\\n name = os.path.basename(human_file).replace(\\\"txt\\\", \\\"\\\")\\n table.add_row([name, text])\\n print(table)\\n elif arg == ListChoice.personas:\\n \\\"\\\"\\\"List all personas\\\"\\\"\\\"\\n table = PrettyTable()\\n table.field_names = [\\\"Name\\\", \\\"Text\\\"]\\n for persona_file in utils.list_persona_files():\\n print(persona_file)\\n text = open(persona_file, \\\"r\\\").read()\\n name = os.path.basename(persona_file).replace(\\\".txt\\\", \\\"\\\")\\n table.add_row([name, text])\\n print(table)\\n elif arg == ListChoice.sources:\\n \\\"\\\"\\\"List all data sources\\\"\\\"\\\"\\n\\n # create table\\n table = PrettyTable()\\n table.field_names = [\\\"Name\\\", \\\"Created At\\\", \\\"Agents\\\"]\\n # TODO: eventually look accross all storage connections\\n # TODO: add data source stats\\n # TODO: connect to agents\\n\\n # get all sources\\n for source in ms.list_sources(user_id=user_id):\\n # get attached agents\\n agent_ids = ms.list_attached_agents(source_id=source.id)\\n agent_names = [ms.get_agent(agent_id=agent_id).name for agent_id in agent_ids]\\n\\n table.add_row([source.name, utils.format_datetime(source.created_at), \\\",\\\".join(agent_names)])\\n\\n print(table)\\n else:\\n raise ValueError(f\\\"Unknown argument {arg}\\\")\"\n },\n {\n \"identifier\": \"add\",\n \"path\": \"memgpt/cli/cli_config.py\",\n \"snippet\": \"@app.command()\\ndef add(\\n option: str, # [human, persona]\\n name: str = typer.Option(help=\\\"Name of human/persona\\\"),\\n text: str = typer.Option(None, help=\\\"Text of human/persona\\\"),\\n filename: str = typer.Option(None, \\\"-f\\\", help=\\\"Specify filename\\\"),\\n):\\n \\\"\\\"\\\"Add a person/human\\\"\\\"\\\"\\n\\n if option == \\\"persona\\\":\\n directory = os.path.join(MEMGPT_DIR, \\\"personas\\\")\\n elif option == \\\"human\\\":\\n directory = os.path.join(MEMGPT_DIR, \\\"humans\\\")\\n else:\\n raise ValueError(f\\\"Unknown kind {option}\\\")\\n\\n if filename:\\n assert text is None, f\\\"Cannot provide both filename and text\\\"\\n # copy file to directory\\n shutil.copyfile(filename, os.path.join(directory, name))\\n if text:\\n assert filename is None, f\\\"Cannot provide both filename and text\\\"\\n # write text to file\\n with open(os.path.join(directory, name), \\\"w\\\") as f:\\n f.write(text)\"\n },\n {\n \"identifier\": \"delete\",\n \"path\": \"memgpt/cli/cli_config.py\",\n \"snippet\": \"@app.command()\\ndef delete(option: str, name: str):\\n \\\"\\\"\\\"Delete a source from the archival memory.\\\"\\\"\\\"\\n\\n config = MemGPTConfig.load()\\n user_id = uuid.UUID(config.anon_clientid)\\n ms = MetadataStore(config)\\n assert ms.get_user(user_id=user_id), f\\\"User {user_id} does not exist\\\"\\n\\n try:\\n # delete from metadata\\n if option == \\\"source\\\":\\n # delete metadata\\n source = ms.get_source(source_name=name, user_id=user_id)\\n ms.delete_source(source_id=source.id)\\n\\n # delete from passages\\n conn = StorageConnector.get_storage_connector(TableType.PASSAGES, config, user_id=user_id)\\n conn.delete({\\\"data_source\\\": name})\\n\\n assert (\\n conn.get_all({\\\"data_source\\\": name}) == []\\n ), f\\\"Expected no passages with source {name}, but got {conn.get_all({'data_source': name})}\\\"\\n\\n # TODO: should we also delete from agents?\\n elif option == \\\"agent\\\":\\n agent = ms.get_agent(agent_name=name, user_id=user_id)\\n\\n # recall memory\\n recall_conn = StorageConnector.get_storage_connector(TableType.RECALL_MEMORY, config, user_id=user_id, agent_id=agent.id)\\n recall_conn.delete({\\\"agent_id\\\": agent.id})\\n\\n # archival memory\\n archival_conn = StorageConnector.get_storage_connector(TableType.ARCHIVAL_MEMORY, config, user_id=user_id, agent_id=agent.id)\\n archival_conn.delete({\\\"agent_id\\\": agent.id})\\n\\n # metadata\\n ms.delete_agent(agent_id=agent.id)\\n\\n else:\\n raise ValueError(f\\\"Option {option} not implemented\\\")\\n\\n typer.secho(f\\\"Deleted source '{name}'\\\", fg=typer.colors.GREEN)\\n\\n except Exception as e:\\n typer.secho(f\\\"Failed to deleted source '{name}'\\\\n{e}\\\", fg=typer.colors.RED)\"\n },\n {\n \"identifier\": \"app\",\n \"path\": \"memgpt/cli/cli_load.py\",\n \"snippet\": \"def insert_passages_into_source(passages: List[Passage], source_name: str, user_id: uuid.UUID, config: MemGPTConfig):\\ndef insert_passages_into_source(passages: List[Passage], source_name: str, user_id: uuid.UUID, config: MemGPTConfig):\\ndef store_docs(name, docs, user_id=None, show_progress=True):\\ndef load_index(\\n name: str = typer.Option(help=\\\"Name of dataset to load.\\\"),\\n dir: str = typer.Option(help=\\\"Path to directory containing index.\\\"),\\n user_id: uuid.UUID = None,\\n):\\ndef load_directory(\\n name: str = typer.Option(help=\\\"Name of dataset to load.\\\"),\\n input_dir: str = typer.Option(None, help=\\\"Path to directory containing dataset.\\\"),\\n input_files: List[str] = typer.Option(None, help=\\\"List of paths to files containing dataset.\\\"),\\n recursive: bool = typer.Option(False, help=\\\"Recursively search for files in directory.\\\"),\\n extensions: str = typer.Option(default_extensions, help=\\\"Comma separated list of file extensions to load\\\"),\\n user_id: str = typer.Option(None, help=\\\"User ID to associate with dataset.\\\"),\\n):\\ndef load_webpage(\\n name: str = typer.Option(help=\\\"Name of dataset to load.\\\"),\\n urls: List[str] = typer.Option(None, help=\\\"List of urls to load.\\\"),\\n):\\ndef load_database(\\n name: str = typer.Option(help=\\\"Name of dataset to load.\\\"),\\n query: str = typer.Option(help=\\\"Database query.\\\"),\\n dump_path: str = typer.Option(None, help=\\\"Path to dump file.\\\"),\\n scheme: str = typer.Option(None, help=\\\"Database scheme.\\\"),\\n host: str = typer.Option(None, help=\\\"Database host.\\\"),\\n port: int = typer.Option(None, help=\\\"Database port.\\\"),\\n user: str = typer.Option(None, help=\\\"Database user.\\\"),\\n password: str = typer.Option(None, help=\\\"Database password.\\\"),\\n dbname: str = typer.Option(None, help=\\\"Database name.\\\"),\\n):\\ndef load_vector_database(\\n name: str = typer.Option(help=\\\"Name of dataset to load.\\\"),\\n uri: str = typer.Option(help=\\\"Database URI.\\\"),\\n table_name: str = typer.Option(help=\\\"Name of table containing data.\\\"),\\n text_column: str = typer.Option(help=\\\"Name of column containing text.\\\"),\\n embedding_column: str = typer.Option(help=\\\"Name of column containing embedding.\\\"),\\n user_id: uuid.UUID = None,\\n):\"\n },\n {\n \"identifier\": \"StorageConnector\",\n \"path\": \"memgpt/agent_store/storage.py\",\n \"snippet\": \"class StorageConnector:\\n \\\"\\\"\\\"Defines a DB connection that is user-specific to access data: Documents, Passages, Archival/Recall Memory\\\"\\\"\\\"\\n\\n def __init__(self, table_type: TableType, config: MemGPTConfig, user_id, agent_id=None):\\n self.user_id = user_id\\n self.agent_id = agent_id\\n self.table_type = table_type\\n\\n # get object type\\n if table_type == TableType.ARCHIVAL_MEMORY:\\n self.type = Passage\\n self.table_name = ARCHIVAL_TABLE_NAME\\n elif table_type == TableType.RECALL_MEMORY:\\n self.type = Message\\n self.table_name = RECALL_TABLE_NAME\\n elif table_type == TableType.DOCUMENTS:\\n self.type = Document\\n self.table_name == DOCUMENT_TABLE_NAME\\n elif table_type == TableType.PASSAGES:\\n self.type = Passage\\n self.table_name = PASSAGE_TABLE_NAME\\n else:\\n raise ValueError(f\\\"Table type {table_type} not implemented\\\")\\n printd(f\\\"Using table name {self.table_name}\\\")\\n\\n # setup base filters for agent-specific tables\\n if self.table_type == TableType.ARCHIVAL_MEMORY or self.table_type == TableType.RECALL_MEMORY:\\n # agent-specific table\\n assert agent_id is not None, \\\"Agent ID must be provided for agent-specific tables\\\"\\n self.filters = {\\\"user_id\\\": self.user_id, \\\"agent_id\\\": self.agent_id}\\n elif self.table_type == TableType.PASSAGES or self.table_type == TableType.DOCUMENTS:\\n # setup base filters for user-specific tables\\n assert agent_id is None, \\\"Agent ID must not be provided for user-specific tables\\\"\\n self.filters = {\\\"user_id\\\": self.user_id}\\n else:\\n raise ValueError(f\\\"Table type {table_type} not implemented\\\")\\n\\n def get_filters(self, filters: Optional[Dict] = {}):\\n # get all filters for query\\n if filters is not None:\\n filter_conditions = {**self.filters, **filters}\\n else:\\n filter_conditions = self.filters\\n return filter_conditions\\n\\n @staticmethod\\n def get_storage_connector(table_type: TableType, config: MemGPTConfig, user_id, agent_id=None):\\n if table_type == TableType.ARCHIVAL_MEMORY or table_type == TableType.PASSAGES:\\n storage_type = config.archival_storage_type\\n elif table_type == TableType.RECALL_MEMORY:\\n storage_type = config.recall_storage_type\\n else:\\n raise ValueError(f\\\"Table type {table_type} not implemented\\\")\\n\\n if storage_type == \\\"postgres\\\":\\n from memgpt.agent_store.db import PostgresStorageConnector\\n\\n return PostgresStorageConnector(table_type, config, user_id, agent_id)\\n elif storage_type == \\\"chroma\\\":\\n from memgpt.agent_store.chroma import ChromaStorageConnector\\n\\n return ChromaStorageConnector(table_type, config, user_id, agent_id)\\n\\n # TODO: add back\\n # elif storage_type == \\\"lancedb\\\":\\n # from memgpt.agent_store.db import LanceDBConnector\\n\\n # return LanceDBConnector(agent_config=agent_config, table_type=table_type)\\n\\n elif storage_type == \\\"sqlite\\\":\\n from memgpt.agent_store.db import SQLLiteStorageConnector\\n\\n return SQLLiteStorageConnector(table_type, config, user_id, agent_id)\\n\\n else:\\n raise NotImplementedError(f\\\"Storage type {storage_type} not implemented\\\")\\n\\n @staticmethod\\n def get_archival_storage_connector(user_id, agent_id):\\n config = MemGPTConfig.load()\\n return StorageConnector.get_storage_connector(TableType.ARCHIVAL_MEMORY, config, user_id, agent_id)\\n\\n @staticmethod\\n def get_recall_storage_connector(user_id, agent_id):\\n config = MemGPTConfig.load()\\n return StorageConnector.get_storage_connector(TableType.RECALL_MEMORY, config, user_id, agent_id)\\n\\n @abstractmethod\\n def get_filters(self, filters: Optional[Dict] = {}):\\n pass\\n\\n @abstractmethod\\n def get_all_paginated(self, filters: Optional[Dict] = {}, page_size: Optional[int] = 1000) -> Iterator[List[Record]]:\\n pass\\n\\n @abstractmethod\\n def get_all(self, filters: Optional[Dict] = {}, limit=10) -> List[Record]:\\n pass\\n\\n @abstractmethod\\n def get(self, id: str) -> Optional[Record]:\\n pass\\n\\n @abstractmethod\\n def size(self, filters: Optional[Dict] = {}) -> int:\\n pass\\n\\n @abstractmethod\\n def insert(self, record: Record):\\n pass\\n\\n @abstractmethod\\n def insert_many(self, records: List[Record], show_progress=False):\\n pass\\n\\n @abstractmethod\\n def query(self, query: str, query_vec: List[float], top_k: int = 10, filters: Optional[Dict] = {}) -> List[Record]:\\n pass\\n\\n @abstractmethod\\n def query_date(self, start_date, end_date):\\n pass\\n\\n @abstractmethod\\n def query_text(self, query):\\n pass\\n\\n @abstractmethod\\n def delete_table(self):\\n pass\\n\\n @abstractmethod\\n def delete(self, filters: Optional[Dict] = {}):\\n pass\\n\\n @abstractmethod\\n def save(self):\\n pass\"\n },\n {\n \"identifier\": \"TableType\",\n \"path\": \"memgpt/agent_store/storage.py\",\n \"snippet\": \"class TableType:\\n ARCHIVAL_MEMORY = \\\"archival_memory\\\" # recall memory table: memgpt_agent_{agent_id}\\n RECALL_MEMORY = \\\"recall_memory\\\" # archival memory table: memgpt_agent_recall_{agent_id}\\n PASSAGES = \\\"passages\\\" # TODO\\n DOCUMENTS = \\\"documents\\\" # TODO\"\n },\n {\n \"identifier\": \"MetadataStore\",\n \"path\": \"memgpt/metadata.py\",\n \"snippet\": \"class MetadataStore:\\n def __init__(self, config: MemGPTConfig):\\n # TODO: get DB URI or path\\n if config.metadata_storage_type == \\\"postgres\\\":\\n self.uri = config.metadata_storage_uri\\n elif config.metadata_storage_type == \\\"sqlite\\\":\\n path = os.path.join(config.metadata_storage_path, \\\"sqlite.db\\\")\\n self.uri = f\\\"sqlite:///{path}\\\"\\n else:\\n raise ValueError(f\\\"Invalid metadata storage type: {config.metadata_storage_type}\\\")\\n\\n # TODO: check to see if table(s) need to be greated or not\\n\\n self.engine = create_engine(self.uri)\\n Base.metadata.create_all(\\n self.engine, tables=[UserModel.__table__, AgentModel.__table__, SourceModel.__table__, AgentSourceMappingModel.__table__]\\n )\\n session_maker = sessionmaker(bind=self.engine)\\n self.session = session_maker()\\n\\n @enforce_types\\n def create_agent(self, agent: AgentState):\\n # insert into agent table\\n # make sure agent.name does not already exist for user user_id\\n if self.session.query(AgentModel).filter(AgentModel.name == agent.name).filter(AgentModel.user_id == agent.user_id).count() > 0:\\n raise ValueError(f\\\"Agent with name {agent.name} already exists\\\")\\n self.session.add(AgentModel(**vars(agent)))\\n self.session.commit()\\n\\n @enforce_types\\n def create_source(self, source: Source):\\n # make sure source.name does not already exist for user\\n if (\\n self.session.query(SourceModel).filter(SourceModel.name == source.name).filter(SourceModel.user_id == source.user_id).count()\\n > 0\\n ):\\n raise ValueError(f\\\"Source with name {source.name} already exists\\\")\\n self.session.add(SourceModel(**vars(source)))\\n self.session.commit()\\n\\n @enforce_types\\n def create_user(self, user: User):\\n if self.session.query(UserModel).filter(UserModel.id == user.id).count() > 0:\\n raise ValueError(f\\\"User with id {user.id} already exists\\\")\\n self.session.add(UserModel(**vars(user)))\\n self.session.commit()\\n\\n @enforce_types\\n def update_agent(self, agent: AgentState):\\n self.session.query(AgentModel).filter(AgentModel.id == agent.id).update(vars(agent))\\n self.session.commit()\\n\\n @enforce_types\\n def update_user(self, user: User):\\n self.session.query(UserModel).filter(UserModel.id == user.id).update(vars(user))\\n self.session.commit()\\n\\n @enforce_types\\n def update_source(self, source: Source):\\n self.session.query(SourceModel).filter(SourceModel.id == source.id).update(vars(source))\\n self.session.commit()\\n\\n @enforce_types\\n def delete_agent(self, agent_id: uuid.UUID):\\n self.session.query(AgentModel).filter(AgentModel.id == agent_id).delete()\\n self.session.commit()\\n\\n @enforce_types\\n def delete_source(self, source_id: uuid.UUID):\\n # delete from sources table\\n self.session.query(SourceModel).filter(SourceModel.id == source_id).delete()\\n\\n # delete any mappings\\n self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.source_id == source_id).delete()\\n\\n self.session.commit()\\n\\n @enforce_types\\n def delete_user(self, user_id: uuid.UUID):\\n # delete from users table\\n self.session.query(UserModel).filter(UserModel.id == user_id).delete()\\n\\n # delete associated agents\\n self.session.query(AgentModel).filter(AgentModel.user_id == user_id).delete()\\n\\n # delete associated sources\\n self.session.query(SourceModel).filter(SourceModel.user_id == user_id).delete()\\n\\n # delete associated mappings\\n self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.user_id == user_id).delete()\\n\\n self.session.commit()\\n\\n @enforce_types\\n def list_agents(self, user_id: uuid.UUID) -> List[AgentState]:\\n results = self.session.query(AgentModel).filter(AgentModel.user_id == user_id).all()\\n return [r.to_record() for r in results]\\n\\n @enforce_types\\n def list_sources(self, user_id: uuid.UUID) -> List[Source]:\\n results = self.session.query(SourceModel).filter(SourceModel.user_id == user_id).all()\\n return [r.to_record() for r in results]\\n\\n @enforce_types\\n def get_agent(\\n self, agent_id: Optional[uuid.UUID] = None, agent_name: Optional[str] = None, user_id: Optional[uuid.UUID] = None\\n ) -> Optional[AgentState]:\\n if agent_id:\\n results = self.session.query(AgentModel).filter(AgentModel.id == agent_id).all()\\n else:\\n assert agent_name is not None and user_id is not None, \\\"Must provide either agent_id or agent_name\\\"\\n results = self.session.query(AgentModel).filter(AgentModel.name == agent_name).filter(AgentModel.user_id == user_id).all()\\n\\n if len(results) == 0:\\n return None\\n assert len(results) == 1, f\\\"Expected 1 result, got {len(results)}\\\" # should only be one result\\n return results[0].to_record()\\n\\n @enforce_types\\n def get_user(self, user_id: uuid.UUID) -> Optional[User]:\\n results = self.session.query(UserModel).filter(UserModel.id == user_id).all()\\n if len(results) == 0:\\n return None\\n assert len(results) == 1, f\\\"Expected 1 result, got {len(results)}\\\"\\n return results[0].to_record()\\n\\n @enforce_types\\n def get_source(\\n self, source_id: Optional[uuid.UUID] = None, user_id: Optional[uuid.UUID] = None, source_name: Optional[str] = None\\n ) -> Optional[Source]:\\n if source_id:\\n results = self.session.query(SourceModel).filter(SourceModel.id == source_id).all()\\n else:\\n assert user_id is not None and source_name is not None\\n results = self.session.query(SourceModel).filter(SourceModel.name == source_name).filter(SourceModel.user_id == user_id).all()\\n if len(results) == 0:\\n return None\\n assert len(results) == 1, f\\\"Expected 1 result, got {len(results)}\\\"\\n return results[0].to_record()\\n\\n # agent source metadata\\n @enforce_types\\n def attach_source(self, user_id: uuid.UUID, agent_id: uuid.UUID, source_id: uuid.UUID):\\n self.session.add(AgentSourceMappingModel(user_id=user_id, agent_id=agent_id, source_id=source_id))\\n self.session.commit()\\n\\n @enforce_types\\n def list_attached_sources(self, agent_id: uuid.UUID) -> List[Column]:\\n results = self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.agent_id == agent_id).all()\\n return [r.source_id for r in results]\\n\\n @enforce_types\\n def list_attached_agents(self, source_id: uuid.UUID):\\n results = self.session.query(AgentSourceMappingModel).filter(AgentSourceMappingModel.source_id == source_id).all()\\n return [r.agent_id for r in results]\\n\\n @enforce_types\\n def detach_source(self, agent_id: uuid.UUID, source_id: uuid.UUID):\\n self.session.query(AgentSourceMappingModel).filter(\\n AgentSourceMappingModel.agent_id == agent_id, AgentSourceMappingModel.source_id == source_id\\n ).delete()\\n self.session.commit()\"\n },\n {\n \"identifier\": \"save_agent\",\n \"path\": \"memgpt/metadata.py\",\n \"snippet\": \"def save_agent(agent: Agent, ms: MetadataStore):\\n \\\"\\\"\\\"Save agent to metadata store\\\"\\\"\\\"\\n\\n agent.update_state()\\n agent_state = agent.agent_state\\n\\n if ms.get_agent(agent_id=agent_state.id):\\n ms.update_agent(agent_state)\\n else:\\n ms.create_agent(agent_state)\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import shutil\r\nimport configparser\r\nimport uuid\r\nimport logging\r\nimport glob\r\nimport os\r\nimport sys\r\nimport pickle\r\nimport traceback\r\nimport json\r\nimport questionary\r\nimport typer\r\nimport memgpt.agent as agent\r\nimport memgpt.system as system\r\nimport memgpt.constants as constants\r\nimport memgpt.errors as errors\r\nfrom rich.console import Console\r\nfrom prettytable import PrettyTable\r\nfrom memgpt.log import logger\r\nfrom memgpt.interface import CLIInterface as interface # for printing to terminal\r\nfrom memgpt.config import MemGPTConfig\r\nfrom memgpt.cli.cli import run, attach, version, server, open_folder, quickstart, migrate\r\nfrom memgpt.cli.cli_config import configure, list, add, delete\r\nfrom memgpt.cli.cli_load import app as load_app\r\nfrom memgpt.agent_store.storage import StorageConnector, TableType\r\nfrom memgpt.metadata import MetadataStore, save_agent\r"},"token_num":{"kind":"number","value":17401,"string":"17,401"},"cropped_code":{"kind":"string","value":"\r\n\r\n\r\nconsole = Console()\r\n\r\n\r\napp = typer.Typer(pretty_exceptions_enable=False)\r\napp.command(name=\"run\")(run)\r\napp.command(name=\"version\")(version)\r\napp.command(name=\"attach\")(attach)\r\n"},"all_code":{"kind":"string","value":"\r\n\r\n\r\nconsole = Console()\r\n\r\n\r\napp = typer.Typer(pretty_exceptions_enable=False)\r\napp.command(name=\"run\")(run)\r\napp.command(name=\"version\")(version)\r\napp.command(name=\"attach\")(attach)\r"},"next_line":{"kind":"string","value":"app.command(name=\"configure\")(configure)\r"},"gold_snippet_index":{"kind":"number","value":10,"string":"10"},"created_at":{"kind":"string","value":"2023-10-11 07:38:37+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5698,"cells":{"repo_name":{"kind":"string","value":"PixArt-alpha/PixArt-alpha"},"file_path":{"kind":"string","value":"train_scripts/train_pixart_lcm.py"},"context":{"kind":"list like","value":[{"identifier":"IDDPM","path":"diffusion/iddpm.py","snippet":"def IDDPM(\n timestep_respacing,\n noise_schedule=\"linear\",\n use_kl=False,\n sigma_small=False,\n predict_xstart=False,\n learn_sigma=True,\n pred_sigma=True,\n rescale_learned_sigmas=False,\n diffusion_steps=1000,\n snr=False,\n return_startx=False,\n):\n betas = gd.get_named_beta_schedule(noise_schedule, diffusion_steps)\n if use_kl:\n loss_type = gd.LossType.RESCALED_KL\n elif rescale_learned_sigmas:\n loss_type = gd.LossType.RESCALED_MSE\n else:\n loss_type = gd.LossType.MSE\n if timestep_respacing is None or timestep_respacing == \"\":\n timestep_respacing = [diffusion_steps]\n return SpacedDiffusion(\n use_timesteps=space_timesteps(diffusion_steps, timestep_respacing),\n betas=betas,\n model_mean_type=(\n gd.ModelMeanType.EPSILON if not predict_xstart else gd.ModelMeanType.START_X\n ),\n model_var_type=(\n ((\n gd.ModelVarType.FIXED_LARGE\n if not sigma_small\n else gd.ModelVarType.FIXED_SMALL\n )\n if not learn_sigma\n else gd.ModelVarType.LEARNED_RANGE\n )\n if pred_sigma\n else None\n ),\n loss_type=loss_type,\n snr=snr,\n return_startx=return_startx,\n # rescale_timesteps=rescale_timesteps,\n )"},{"identifier":"save_checkpoint","path":"diffusion/utils/checkpoint.py","snippet":"def save_checkpoint(work_dir,\n epoch,\n model,\n model_ema=None,\n optimizer=None,\n lr_scheduler=None,\n keep_last=False,\n step=None,\n ):\n os.makedirs(work_dir, exist_ok=True)\n state_dict = dict(state_dict=model.state_dict())\n if model_ema is not None:\n state_dict['state_dict_ema'] = model_ema.state_dict()\n if optimizer is not None:\n state_dict['optimizer'] = optimizer.state_dict()\n if lr_scheduler is not None:\n state_dict['scheduler'] = lr_scheduler.state_dict()\n if epoch is not None:\n state_dict['epoch'] = epoch\n file_path = os.path.join(work_dir, f\"epoch_{epoch}.pth\")\n if step is not None:\n file_path = file_path.split('.pth')[0] + f\"_step_{step}.pth\"\n logger = get_root_logger()\n torch.save(state_dict, file_path)\n logger.info(f'Saved checkpoint of epoch {epoch} to {file_path.format(epoch)}.')\n if keep_last:\n for i in range(epoch):\n previous_ckgt = file_path.format(i)\n if os.path.exists(previous_ckgt):\n os.remove(previous_ckgt)"},{"identifier":"load_checkpoint","path":"diffusion/utils/checkpoint.py","snippet":"def load_checkpoint(checkpoint,\n model,\n model_ema=None,\n optimizer=None,\n lr_scheduler=None,\n load_ema=False,\n resume_optimizer=True,\n resume_lr_scheduler=True\n ):\n assert isinstance(checkpoint, str)\n ckpt_file = checkpoint\n checkpoint = torch.load(ckpt_file, map_location=\"cpu\")\n\n state_dict_keys = ['pos_embed', 'base_model.pos_embed', 'model.pos_embed']\n for key in state_dict_keys:\n if key in checkpoint['state_dict']:\n del checkpoint['state_dict'][key]\n if 'state_dict_ema' in checkpoint and key in checkpoint['state_dict_ema']:\n del checkpoint['state_dict_ema'][key]\n break\n\n if load_ema:\n state_dict = checkpoint['state_dict_ema']\n else:\n state_dict = checkpoint.get('state_dict', checkpoint) # to be compatible with the official checkpoint\n # model.load_state_dict(state_dict)\n missing, unexpect = model.load_state_dict(state_dict, strict=False)\n if model_ema is not None:\n model_ema.load_state_dict(checkpoint['state_dict_ema'], strict=False)\n if optimizer is not None and resume_optimizer:\n optimizer.load_state_dict(checkpoint['optimizer'])\n if lr_scheduler is not None and resume_lr_scheduler:\n lr_scheduler.load_state_dict(checkpoint['scheduler'])\n logger = get_root_logger()\n if optimizer is not None:\n epoch = checkpoint.get('epoch', re.match(r'.*epoch_(\\d*).*.pth', ckpt_file).group()[0])\n logger.info(f'Resume checkpoint of epoch {epoch} from {ckpt_file}. Load ema: {load_ema}, '\n f'resume optimizer： {resume_optimizer}, resume lr scheduler: {resume_lr_scheduler}.')\n return epoch, missing, unexpect\n logger.info(f'Load checkpoint from {ckpt_file}. Load ema: {load_ema}.')\n return missing, unexpect"},{"identifier":"synchronize","path":"diffusion/utils/dist_utils.py","snippet":"def synchronize():\n \"\"\"\n Helper function to synchronize (barrier) among all processes when\n using distributed training\n \"\"\"\n if not dist.is_available():\n return\n if not dist.is_initialized():\n return\n world_size = dist.get_world_size()\n if world_size == 1:\n return\n dist.barrier()"},{"identifier":"get_world_size","path":"diffusion/utils/dist_utils.py","snippet":"def get_world_size():\n if not dist.is_available():\n return 1\n if not dist.is_initialized():\n return 1\n return dist.get_world_size()"},{"identifier":"clip_grad_norm_","path":"diffusion/utils/dist_utils.py","snippet":"@torch.no_grad()\ndef clip_grad_norm_(\n self, max_norm: Union[float, int], norm_type: Union[float, int] = 2.0\n) -> None:\n self._lazy_init()\n self._wait_for_previous_optim_step()\n assert self._is_root, \"clip_grad_norm should only be called on the root (parent) instance\"\n self._assert_state(TrainingState_.IDLE)\n\n max_norm = float(max_norm)\n norm_type = float(norm_type)\n # Computes the max norm for this shard's gradients and sync's across workers\n local_norm = _calc_grad_norm(self.params_with_grad, norm_type).cuda() # type: ignore[arg-type]\n if norm_type == math.inf:\n total_norm = local_norm\n dist.all_reduce(total_norm, op=torch.distributed.ReduceOp.MAX, group=self.process_group)\n else:\n total_norm = local_norm ** norm_type\n dist.all_reduce(total_norm, group=self.process_group)\n total_norm = total_norm ** (1.0 / norm_type)\n\n clip_coef = torch.tensor(max_norm, dtype=total_norm.dtype, device=total_norm.device) / (total_norm + 1e-6)\n if clip_coef < 1:\n # multiply by clip_coef, aka, (max_norm/total_norm).\n for p in self.params_with_grad:\n assert p.grad is not None\n p.grad.detach().mul_(clip_coef.to(p.grad.device))\n return total_norm"},{"identifier":"build_dataset","path":"diffusion/data/builder.py","snippet":"def build_dataset(cfg, resolution=224, **kwargs):\n logger = get_root_logger()\n\n dataset_type = cfg.get('type')\n logger.info(f\"Constructing dataset {dataset_type}...\")\n t = time.time()\n transform = cfg.pop('transform', 'default_train')\n transform = get_transform(transform, resolution)\n dataset = build_from_cfg(cfg, DATASETS, default_args=dict(transform=transform, resolution=resolution, **kwargs))\n logger.info(f\"Dataset {dataset_type} constructed. time: {(time.time() - t):.2f} s, length (use/ori): {len(dataset)}/{dataset.ori_imgs_nums}\")\n return dataset"},{"identifier":"build_dataloader","path":"diffusion/data/builder.py","snippet":"def build_dataloader(dataset, batch_size=256, num_workers=4, shuffle=True, **kwargs):\n if 'batch_sampler' in kwargs:\n dataloader = DataLoader(dataset, batch_sampler=kwargs['batch_sampler'], num_workers=num_workers, pin_memory=True)\n else:\n dataloader = DataLoader(dataset,\n batch_size=batch_size,\n shuffle=shuffle,\n num_workers=num_workers,\n pin_memory=True,\n **kwargs)\n return dataloader"},{"identifier":"set_data_root","path":"diffusion/data/builder.py","snippet":"def set_data_root(data_root):\n global DATA_ROOT\n DATA_ROOT = data_root"},{"identifier":"build_model","path":"diffusion/model/builder.py","snippet":"def build_model(cfg, use_grad_checkpoint=False, use_fp32_attention=False, gc_step=1, **kwargs):\n if isinstance(cfg, str):\n cfg = dict(type=cfg)\n model = MODELS.build(cfg, default_args=kwargs)\n if use_grad_checkpoint:\n set_grad_checkpoint(model, use_fp32_attention=use_fp32_attention, gc_step=gc_step)\n return model"},{"identifier":"get_root_logger","path":"diffusion/utils/logger.py","snippet":"def get_root_logger(log_file=None, log_level=logging.INFO, name='PixArt'):\n \"\"\"Get root logger.\n\n Args:\n log_file (str, optional): File path of log. Defaults to None.\n log_level (int, optional): The level of logger.\n Defaults to logging.INFO.\n name (str): logger name\n Returns:\n :obj:`logging.Logger`: The obtained logger\n \"\"\"\n if log_file is None:\n log_file = '/dev/null'\n logger = get_logger(name=name, log_file=log_file, log_level=log_level)\n return logger"},{"identifier":"set_random_seed","path":"diffusion/utils/misc.py","snippet":"def set_random_seed(seed, deterministic=False):\n \"\"\"Set random seed.\n\n Args:\n seed (int): Seed to be used.\n deterministic (bool): Whether to set the deterministic option for\n CUDNN backend, i.e., set `torch.backends.cudnn.deterministic`\n to True and `torch.backends.cudnn.benchmark` to False.\n Default: False.\n \"\"\"\n random.seed(seed)\n np.random.seed(seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed_all(seed)\n if deterministic:\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False"},{"identifier":"read_config","path":"diffusion/utils/misc.py","snippet":"def read_config(file):\n # solve config loading conflict when multi-processes\n import time\n while True:\n config = Config.fromfile(file)\n if len(config) == 0:\n time.sleep(0.1)\n continue\n break\n return config"},{"identifier":"init_random_seed","path":"diffusion/utils/misc.py","snippet":"def init_random_seed(seed=None, device='cuda'):\n \"\"\"Initialize random seed.\n\n If the seed is not set, the seed will be automatically randomized,\n and then broadcast to all processes to prevent some potential bugs.\n\n Args:\n seed (int, Optional): The seed. Default to None.\n device (str): The device where the seed will be put on.\n Default to 'cuda'.\n\n Returns:\n int: Seed to be used.\n \"\"\"\n if seed is not None:\n return seed\n\n # Make sure all ranks share the same random seed to prevent\n # some potential bugs. Please refer to\n # https://github.com/open-mmlab/mmdetection/issues/6339\n rank, world_size = get_dist_info()\n seed = np.random.randint(2 ** 31)\n if world_size == 1:\n return seed\n\n if rank == 0:\n random_num = torch.tensor(seed, dtype=torch.int32, device=device)\n else:\n random_num = torch.tensor(0, dtype=torch.int32, device=device)\n dist.broadcast(random_num, src=0)\n return random_num.item()"},{"identifier":"DebugUnderflowOverflow","path":"diffusion/utils/misc.py","snippet":"class DebugUnderflowOverflow:\n \"\"\"\n This debug class helps detect and understand where the model starts getting very large or very small, and more\n importantly `nan` or `inf` weight and activation elements.\n There are 2 working modes:\n 1. Underflow/overflow detection (default)\n 2. Specific batch absolute min/max tracing without detection\n Mode 1: Underflow/overflow detection\n To activate the underflow/overflow detection, initialize the object with the model :\n ```python\n debug_overflow = DebugUnderflowOverflow(model)\n ```\n then run the training as normal and if `nan` or `inf` gets detected in at least one of the weight, input or\n output elements this module will throw an exception and will print `max_frames_to_save` frames that lead to this\n event, each frame reporting\n 1. the fully qualified module name plus the class name whose `forward` was run\n 2. the absolute min and max value of all elements for each module weights, and the inputs and output\n For example, here is the header and the last few frames in detection report for `google/mt5-small` run in fp16 mixed precision :\n ```\n Detected inf/nan during batch_number=0\n Last 21 forward frames:\n abs min abs max metadata\n [...]\n encoder.block.2.layer.1.DenseReluDense.wi_0 Linear\n 2.17e-07 4.50e+00 weight\n 1.79e-06 4.65e+00 input[0]\n 2.68e-06 3.70e+01 output\n encoder.block.2.layer.1.DenseReluDense.wi_1 Linear\n 8.08e-07 2.66e+01 weight\n 1.79e-06 4.65e+00 input[0]\n 1.27e-04 2.37e+02 output\n encoder.block.2.layer.1.DenseReluDense.wo Linear\n 1.01e-06 6.44e+00 weight\n 0.00e+00 9.74e+03 input[0]\n 3.18e-04 6.27e+04 output\n encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense\n 1.79e-06 4.65e+00 input[0]\n 3.18e-04 6.27e+04 output\n encoder.block.2.layer.1.dropout Dropout\n 3.18e-04 6.27e+04 input[0]\n 0.00e+00 inf output\n ```\n You can see here, that `T5DenseGatedGeluDense.forward` resulted in output activations, whose absolute max value\n was around 62.7K, which is very close to fp16's top limit of 64K. In the next frame we have `Dropout` which\n renormalizes the weights, after it zeroed some of the elements, which pushes the absolute max value to more than\n 64K, and we get an overlow.\n As you can see it's the previous frames that we need to look into when the numbers start going into very large for\n fp16 numbers.\n The tracking is done in a forward hook, which gets invoked immediately after `forward` has completed.\n By default the last 21 frames are printed. You can change the default to adjust for your needs. For example :\n ```python\n debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=100)\n ```\n To validate that you have set up this debugging feature correctly, and you intend to use it in a training that may\n take hours to complete, first run it with normal tracing enabled for one of a few batches as explained in the next\n section.\n Mode 2. Specific batch absolute min/max tracing without detection\n The second work mode is per-batch tracing with the underflow/overflow detection feature turned off.\n Let's say you want to watch the absolute min and max values for all the ingredients of each `forward` call of a\n given batch, and only do that for batches 1 and 3. Then you instantiate this class as :\n ```python\n debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1,3])\n ```\n And now full batches 1 and 3 will be traced using the same format as explained above. Batches are 0-indexed.\n This is helpful if you know that the program starts misbehaving after a certain batch number, so you can\n fast-forward right to that area.\n Early stopping:\n You can also specify the batch number after which to stop the training, with :\n ```python\n debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1,3], abort_after_batch_num=3)\n ```\n This feature is mainly useful in the tracing mode, but you can use it for any mode.\n **Performance**:\n As this module measures absolute `min`/``max` of each weight of the model on every forward it'll slow the\n training down. Therefore remember to turn it off once the debugging needs have been met.\n Args:\n model (`nn.Module`):\n The model to debug.\n max_frames_to_save (`int`, *optional*, defaults to 21):\n How many frames back to record\n trace_batch_nums(`List[int]`, *optional*, defaults to `[]`):\n Which batch numbers to trace (turns detection off)\n abort_after_batch_num (`int``, *optional*):\n Whether to abort after a certain batch number has finished\n \"\"\"\n\n def __init__(self, model, max_frames_to_save=21, trace_batch_nums=[], abort_after_batch_num=None):\n self.model = model\n self.trace_batch_nums = trace_batch_nums\n self.abort_after_batch_num = abort_after_batch_num\n\n # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence\n self.frames = collections.deque([], max_frames_to_save)\n self.frame = []\n self.batch_number = 0\n self.total_calls = 0\n self.detected_overflow = False\n self.prefix = \" \"\n\n self.analyse_model()\n\n self.register_forward_hook()\n\n def save_frame(self, frame=None):\n if frame is not None:\n self.expand_frame(frame)\n self.frames.append(\"\\n\".join(self.frame))\n self.frame = [] # start a new frame\n\n def expand_frame(self, line):\n self.frame.append(line)\n\n def trace_frames(self):\n print(\"\\n\".join(self.frames))\n self.frames = []\n\n def reset_saved_frames(self):\n self.frames = []\n\n def dump_saved_frames(self):\n print(f\"\\nDetected inf/nan during batch_number={self.batch_number} \"\n f\"Last {len(self.frames)} forward frames:\"\n f\"{'abs min':8} {'abs max':8} metadata\"\n f\"'\\n'.join(self.frames)\"\n f\"\\n\\n\")\n self.frames = []\n\n def analyse_model(self):\n # extract the fully qualified module names, to be able to report at run time. e.g.:\n # encoder.block.2.layer.0.SelfAttention.o\n #\n # for shared weights only the first shared module name will be registered\n self.module_names = {m: name for name, m in self.model.named_modules()}\n # self.longest_module_name = max(len(v) for v in self.module_names.values())\n\n def analyse_variable(self, var, ctx):\n if torch.is_tensor(var):\n self.expand_frame(self.get_abs_min_max(var, ctx))\n if self.detect_overflow(var, ctx):\n self.detected_overflow = True\n elif var is None:\n self.expand_frame(f\"{'None':>17} {ctx}\")\n else:\n self.expand_frame(f\"{'not a tensor':>17} {ctx}\")\n\n def batch_start_frame(self):\n self.expand_frame(f\"\\n\\n{self.prefix} *** Starting batch number={self.batch_number} ***\")\n self.expand_frame(f\"{'abs min':8} {'abs max':8} metadata\")\n\n def batch_end_frame(self):\n self.expand_frame(f\"{self.prefix} *** Finished batch number={self.batch_number - 1} ***\\n\\n\")\n\n def create_frame(self, module, input, output):\n self.expand_frame(f\"{self.prefix} {self.module_names[module]} {module.__class__.__name__}\")\n\n # params\n for name, p in module.named_parameters(recurse=False):\n self.analyse_variable(p, name)\n\n # inputs\n if isinstance(input, tuple):\n for i, x in enumerate(input):\n self.analyse_variable(x, f\"input[{i}]\")\n else:\n self.analyse_variable(input, \"input\")\n\n # outputs\n if isinstance(output, tuple):\n for i, x in enumerate(output):\n # possibly a tuple of tuples\n if isinstance(x, tuple):\n for j, y in enumerate(x):\n self.analyse_variable(y, f\"output[{i}][{j}]\")\n else:\n self.analyse_variable(x, f\"output[{i}]\")\n else:\n self.analyse_variable(output, \"output\")\n\n self.save_frame()\n\n def register_forward_hook(self):\n self.model.apply(self._register_forward_hook)\n\n def _register_forward_hook(self, module):\n module.register_forward_hook(self.forward_hook)\n\n def forward_hook(self, module, input, output):\n # - input is a tuple of packed inputs (could be non-Tensors)\n # - output could be a Tensor or a tuple of Tensors and non-Tensors\n\n last_frame_of_batch = False\n\n trace_mode = True if self.batch_number in self.trace_batch_nums else False\n if trace_mode:\n self.reset_saved_frames()\n\n if self.total_calls == 0:\n self.batch_start_frame()\n self.total_calls += 1\n\n # count batch numbers - the very first forward hook of the batch will be called when the\n # batch completes - i.e. it gets called very last - we know this batch has finished\n if module == self.model:\n self.batch_number += 1\n last_frame_of_batch = True\n\n self.create_frame(module, input, output)\n\n # if last_frame_of_batch:\n # self.batch_end_frame()\n\n if trace_mode:\n self.trace_frames()\n\n if last_frame_of_batch:\n self.batch_start_frame()\n\n if self.detected_overflow and not trace_mode:\n self.dump_saved_frames()\n\n # now we can abort, as it's pointless to continue running\n raise ValueError(\n \"DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. \"\n \"Please scroll up above this traceback to see the activation values prior to this event.\"\n )\n\n # abort after certain batch if requested to do so\n if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:\n raise ValueError(\n f\"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to `abort_after_batch_num={self.abort_after_batch_num}` arg\"\n )\n\n @staticmethod\n def get_abs_min_max(var, ctx):\n abs_var = var.abs()\n return f\"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}\"\n\n @staticmethod\n def detect_overflow(var, ctx):\n \"\"\"\n Report whether the tensor contains any `nan` or `inf` entries.\n This is useful for detecting overflows/underflows and best to call right after the function that did some math that\n modified the tensor in question.\n This function contains a few other helper features that you can enable and tweak directly if you want to track\n various other things.\n Args:\n var: the tensor variable to check\n ctx: the message to print as a context\n Return:\n `True` if `inf` or `nan` was detected, `False` otherwise\n \"\"\"\n detected = False\n if torch.isnan(var).any().item():\n detected = True\n print(f\"{ctx} has nans\")\n if torch.isinf(var).any().item():\n detected = True\n print(f\"{ctx} has infs\")\n if var.dtype == torch.float32 and torch.ge(var.abs(), 65535).any().item():\n detected = True\n print(f\"{ctx} has overflow values {var.abs().max().item()}.\")\n # if needed to monitor large elements can enable the following\n if 0: # and detected:\n n100 = var[torch.ge(var.abs(), 100)]\n if n100.numel() > 0:\n print(f\"{ctx}: n100={n100.numel()}\")\n n1000 = var[torch.ge(var.abs(), 1000)]\n if n1000.numel() > 0:\n print(f\"{ctx}: n1000={n1000.numel()}\")\n n10000 = var[torch.ge(var.abs(), 10000)]\n if n10000.numel() > 0:\n print(f\"{ctx}: n10000={n10000.numel()}\")\n\n if 0:\n print(f\"min={var.min():9.2e} max={var.max():9.2e}\")\n\n if 0:\n print(f\"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})\")\n\n return detected"},{"identifier":"build_optimizer","path":"diffusion/utils/optimizer.py","snippet":"def build_optimizer(model, optimizer_cfg):\n # default parameter-wise config\n logger = get_root_logger()\n\n if hasattr(model, 'module'):\n model = model.module\n # set optimizer constructor\n optimizer_cfg.setdefault('constructor', 'MyOptimizerConstructor')\n # parameter-wise setting: cancel weight decay for some specific modules\n custom_keys = dict()\n for name, module in model.named_modules():\n if hasattr(module, 'zero_weight_decay'):\n custom_keys.update({(name, key): dict(decay_mult=0) for key in module.zero_weight_decay})\n\n paramwise_cfg = Config(dict(cfg=dict(custom_keys=custom_keys)))\n given_cfg = optimizer_cfg.get('paramwise_cfg')\n if given_cfg:\n paramwise_cfg.merge_from_dict(dict(cfg=given_cfg))\n optimizer_cfg['paramwise_cfg'] = paramwise_cfg.cfg\n # build optimizer\n optimizer = mm_build_optimizer(model, optimizer_cfg)\n\n weight_decay_groups = dict()\n lr_groups = dict()\n for group in optimizer.param_groups:\n if not group.get('requires_grad', True): continue\n lr_groups.setdefault(group['lr'], []).append(group)\n weight_decay_groups.setdefault(group['weight_decay'], []).append(group)\n\n learnable_count, fix_count = 0, 0\n for p in model.parameters():\n if p.requires_grad:\n learnable_count += 1\n else:\n fix_count += 1\n fix_info = f\"{learnable_count} are learnable, {fix_count} are fix\"\n lr_info = \"Lr group: \" + \", \".join([f'{len(group)} params with lr {lr:.5f}' for lr, group in lr_groups.items()])\n wd_info = \"Weight decay group: \" + \", \".join(\n [f'{len(group)} params with weight decay {wd}' for wd, group in weight_decay_groups.items()])\n opt_info = f\"Optimizer: total {len(optimizer.param_groups)} param groups, {fix_info}. {lr_info}; {wd_info}.\"\n logger.info(opt_info)\n\n return optimizer"},{"identifier":"auto_scale_lr","path":"diffusion/utils/optimizer.py","snippet":"def auto_scale_lr(effective_bs, optimizer_cfg, rule='linear', base_batch_size=256):\n assert rule in ['linear', 'sqrt']\n logger = get_root_logger()\n # scale by world size\n if rule == 'sqrt':\n scale_ratio = math.sqrt(effective_bs / base_batch_size)\n elif rule == 'linear':\n scale_ratio = effective_bs / base_batch_size\n optimizer_cfg['lr'] *= scale_ratio\n logger.info(f'Automatically adapt lr to {optimizer_cfg[\"lr\"]:.7f} (using {rule} scaling rule).')\n return scale_ratio"},{"identifier":"build_lr_scheduler","path":"diffusion/utils/lr_scheduler.py","snippet":"def build_lr_scheduler(config, optimizer, train_dataloader, lr_scale_ratio):\n if not config.get('lr_schedule_args', None):\n config.lr_schedule_args = dict()\n if config.get('lr_warmup_steps', None):\n config['num_warmup_steps'] = config.get('lr_warmup_steps') # for compatibility with old version\n\n logger = get_root_logger()\n logger.info(\n f'Lr schedule: {config.lr_schedule}, ' + \",\".join(\n [f\"{key}:{value}\" for key, value in config.lr_schedule_args.items()]) + '.')\n if config.lr_schedule == 'cosine':\n lr_scheduler = get_cosine_schedule_with_warmup(\n optimizer=optimizer,\n **config.lr_schedule_args,\n num_training_steps=(len(train_dataloader) * config.num_epochs),\n )\n elif config.lr_schedule == 'constant':\n lr_scheduler = get_constant_schedule_with_warmup(\n optimizer=optimizer,\n **config.lr_schedule_args,\n )\n elif config.lr_schedule == 'cosine_decay_to_constant':\n assert lr_scale_ratio >= 1\n lr_scheduler = get_cosine_decay_to_constant_with_warmup(\n optimizer=optimizer,\n **config.lr_schedule_args,\n final_lr=1 / lr_scale_ratio,\n num_training_steps=(len(train_dataloader) * config.num_epochs),\n )\n else:\n raise RuntimeError(f'Unrecognized lr schedule {config.lr_schedule}.')\n return lr_scheduler"},{"identifier":"AspectRatioBatchSampler","path":"diffusion/utils/data_sampler.py","snippet":"class AspectRatioBatchSampler(BatchSampler):\n \"\"\"A sampler wrapper for grouping images with similar aspect ratio into a same batch.\n\n Args:\n sampler (Sampler): Base sampler.\n dataset (Dataset): Dataset providing data information.\n batch_size (int): Size of mini-batch.\n drop_last (bool): If ``True``, the sampler will drop the last batch if\n its size would be less than ``batch_size``.\n aspect_ratios (dict): The predefined aspect ratios.\n \"\"\"\n\n def __init__(self,\n sampler: Sampler,\n dataset: Dataset,\n batch_size: int,\n aspect_ratios: dict,\n drop_last: bool = False,\n config=None,\n valid_num=0, # take as valid aspect-ratio when sample number >= valid_num\n **kwargs) -> None:\n if not isinstance(sampler, Sampler):\n raise TypeError('sampler should be an instance of ``Sampler``, '\n f'but got {sampler}')\n if not isinstance(batch_size, int) or batch_size <= 0:\n raise ValueError('batch_size should be a positive integer value, '\n f'but got batch_size={batch_size}')\n self.sampler = sampler\n self.dataset = dataset\n self.batch_size = batch_size\n self.aspect_ratios = aspect_ratios\n self.drop_last = drop_last\n self.ratio_nums_gt = kwargs.get('ratio_nums', None)\n self.config = config\n assert self.ratio_nums_gt\n # buckets for each aspect ratio\n self._aspect_ratio_buckets = {ratio: [] for ratio in aspect_ratios.keys()}\n self.current_available_bucket_keys = [str(k) for k, v in self.ratio_nums_gt.items() if v >= valid_num]\n logger = get_root_logger() if config is None else get_root_logger(os.path.join(config.work_dir, 'train_log.log'))\n logger.warning(f\"Using valid_num={valid_num} in config file. Available {len(self.current_available_bucket_keys)} aspect_ratios: {self.current_available_bucket_keys}\")\n\n def __iter__(self) -> Sequence[int]:\n for idx in self.sampler:\n data_info = self.dataset.get_data_info(idx)\n height, width = data_info['height'], data_info['width']\n ratio = height / width\n # find the closest aspect ratio\n closest_ratio = min(self.aspect_ratios.keys(), key=lambda r: abs(float(r) - ratio))\n if closest_ratio not in self.current_available_bucket_keys:\n continue\n bucket = self._aspect_ratio_buckets[closest_ratio]\n bucket.append(idx)\n # yield a batch of indices in the same aspect ratio group\n if len(bucket) == self.batch_size:\n yield bucket[:]\n del bucket[:]\n\n # yield the rest data and reset the buckets\n for bucket in self._aspect_ratio_buckets.values():\n while len(bucket) > 0:\n if len(bucket) <= self.batch_size:\n if not self.drop_last:\n yield bucket[:]\n bucket = []\n else:\n yield bucket[:self.batch_size]\n bucket = bucket[self.batch_size:]"},{"identifier":"BalancedAspectRatioBatchSampler","path":"diffusion/utils/data_sampler.py","snippet":"class BalancedAspectRatioBatchSampler(AspectRatioBatchSampler):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n # Assign samples to each bucket\n self.ratio_nums_gt = kwargs.get('ratio_nums', None)\n assert self.ratio_nums_gt\n self._aspect_ratio_buckets = {float(ratio): [] for ratio in self.aspect_ratios.keys()}\n self.original_buckets = {}\n self.current_available_bucket_keys = [k for k, v in self.ratio_nums_gt.items() if v >= 3000]\n self.all_available_keys = deepcopy(self.current_available_bucket_keys)\n self.exhausted_bucket_keys = []\n self.total_batches = len(self.sampler) // self.batch_size\n self._aspect_ratio_count = {}\n for k in self.all_available_keys:\n self._aspect_ratio_count[float(k)] = 0\n self.original_buckets[float(k)] = []\n logger = get_root_logger(os.path.join(self.config.work_dir, 'train_log.log'))\n logger.warning(f\"Available {len(self.current_available_bucket_keys)} aspect_ratios: {self.current_available_bucket_keys}\")\n\n def __iter__(self) -> Sequence[int]:\n i = 0\n for idx in self.sampler:\n data_info = self.dataset.get_data_info(idx)\n height, width = data_info['height'], data_info['width']\n ratio = height / width\n closest_ratio = float(min(self.aspect_ratios.keys(), key=lambda r: abs(float(r) - ratio)))\n if closest_ratio not in self.all_available_keys:\n continue\n if self._aspect_ratio_count[closest_ratio] < self.ratio_nums_gt[closest_ratio]:\n self._aspect_ratio_count[closest_ratio] += 1\n self._aspect_ratio_buckets[closest_ratio].append(idx)\n self.original_buckets[closest_ratio].append(idx) # Save the original samples for each bucket\n if not self.current_available_bucket_keys:\n self.current_available_bucket_keys, self.exhausted_bucket_keys = self.exhausted_bucket_keys, []\n\n if closest_ratio not in self.current_available_bucket_keys:\n continue\n key = closest_ratio\n bucket = self._aspect_ratio_buckets[key]\n if len(bucket) == self.batch_size:\n yield bucket[:self.batch_size]\n del bucket[:self.batch_size]\n i += 1\n self.exhausted_bucket_keys.append(key)\n self.current_available_bucket_keys.remove(key)\n\n for _ in range(self.total_batches - i):\n key = choice(self.all_available_keys)\n bucket = self._aspect_ratio_buckets[key]\n if len(bucket) >= self.batch_size:\n yield bucket[:self.batch_size]\n del bucket[:self.batch_size]\n\n # If a bucket is exhausted\n if not bucket:\n self._aspect_ratio_buckets[key] = deepcopy(self.original_buckets[key][:])\n shuffle(self._aspect_ratio_buckets[key])\n else:\n self._aspect_ratio_buckets[key] = deepcopy(self.original_buckets[key][:])\n shuffle(self._aspect_ratio_buckets[key])"},{"identifier":"LCMScheduler","path":"diffusion/lcm_scheduler.py","snippet":"class LCMScheduler(SchedulerMixin, ConfigMixin):\n \"\"\"\n `LCMScheduler` extends the denoising procedure introduced in denoising diffusion probabilistic models (DDPMs) with\n non-Markovian guidance.\n This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic\n methods the library implements for all schedulers such as loading and saving.\n Args:\n num_train_timesteps (`int`, defaults to 1000):\n The number of diffusion steps to train the model.\n beta_start (`float`, defaults to 0.0001):\n The starting `beta` value of inference.\n beta_end (`float`, defaults to 0.02):\n The final `beta` value.\n beta_schedule (`str`, defaults to `\"linear\"`):\n The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from\n `linear`, `scaled_linear`, or `squaredcos_cap_v2`.\n trained_betas (`np.ndarray`, *optional*):\n Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.\n clip_sample (`bool`, defaults to `True`):\n Clip the predicted sample for numerical stability.\n clip_sample_range (`float`, defaults to 1.0):\n The maximum magnitude for sample clipping. Valid only when `clip_sample=True`.\n set_alpha_to_one (`bool`, defaults to `True`):\n Each diffusion step uses the alphas product value at that step and at the previous one. For the final step\n there is no previous alpha. When this option is `True` the previous alpha product is fixed to `1`,\n otherwise it uses the alpha value at step 0.\n steps_offset (`int`, defaults to 0):\n An offset added to the inference steps. You can use a combination of `offset=1` and\n `set_alpha_to_one=False` to make the last step use step 0 for the previous alpha product like in Stable\n Diffusion.\n prediction_type (`str`, defaults to `epsilon`, *optional*):\n Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process),\n `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen\n Video](https://imagen.research.google/video/paper.pdf) paper).\n thresholding (`bool`, defaults to `False`):\n Whether to use the \"dynamic thresholding\" method. This is unsuitable for latent-space diffusion models such\n as Stable Diffusion.\n dynamic_thresholding_ratio (`float`, defaults to 0.995):\n The ratio for the dynamic thresholding method. Valid only when `thresholding=True`.\n sample_max_value (`float`, defaults to 1.0):\n The threshold value for dynamic thresholding. Valid only when `thresholding=True`.\n timestep_spacing (`str`, defaults to `\"leading\"`):\n The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and\n Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.\n rescale_betas_zero_snr (`bool`, defaults to `False`):\n Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and\n dark samples instead of limiting it to samples with medium brightness. Loosely related to\n [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).\n \"\"\"\n\n # _compatibles = [e.name for e in KarrasDiffusionSchedulers]\n order = 1\n\n @register_to_config\n def __init__(\n self,\n num_train_timesteps: int = 1000,\n beta_start: float = 0.0001,\n beta_end: float = 0.02,\n beta_schedule: str = \"linear\",\n trained_betas: Optional[Union[np.ndarray, List[float]]] = None,\n clip_sample: bool = True,\n set_alpha_to_one: bool = True,\n steps_offset: int = 0,\n prediction_type: str = \"epsilon\",\n thresholding: bool = False,\n dynamic_thresholding_ratio: float = 0.995,\n clip_sample_range: float = 1.0,\n sample_max_value: float = 1.0,\n timestep_spacing: str = \"leading\",\n rescale_betas_zero_snr: bool = False,\n ):\n if trained_betas is not None:\n self.betas = torch.tensor(trained_betas, dtype=torch.float32)\n elif beta_schedule == \"linear\":\n self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)\n elif beta_schedule == \"scaled_linear\":\n # this schedule is very specific to the latent diffusion model.\n self.betas = (\n torch.linspace(beta_start ** 0.5, beta_end ** 0.5, num_train_timesteps, dtype=torch.float32) ** 2\n )\n elif beta_schedule == \"squaredcos_cap_v2\":\n # Glide cosine schedule\n self.betas = betas_for_alpha_bar(num_train_timesteps)\n else:\n raise NotImplementedError(f\"{beta_schedule} does is not implemented for {self.__class__}\")\n\n # Rescale for zero SNR\n if rescale_betas_zero_snr:\n self.betas = rescale_zero_terminal_snr(self.betas)\n\n self.alphas = 1.0 - self.betas\n self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)\n\n # At every step in ddim, we are looking into the previous alphas_cumprod\n # For the final step, there is no previous alphas_cumprod because we are already at 0\n # `set_alpha_to_one` decides whether we set this parameter simply to one or\n # whether we use the final alpha of the \"non-previous\" one.\n self.final_alpha_cumprod = torch.tensor(1.0) if set_alpha_to_one else self.alphas_cumprod[0]\n\n # standard deviation of the initial noise distribution\n self.init_noise_sigma = 1.0\n\n # setable values\n self.num_inference_steps = None\n self.timesteps = torch.from_numpy(np.arange(0, num_train_timesteps)[::-1].copy().astype(np.int64))\n\n def scale_model_input(self, sample: torch.FloatTensor, timestep: Optional[int] = None) -> torch.FloatTensor:\n \"\"\"\n Ensures interchangeability with schedulers that need to scale the denoising model input depending on the\n current timestep.\n Args:\n sample (`torch.FloatTensor`):\n The input sample.\n timestep (`int`, *optional*):\n The current timestep in the diffusion chain.\n Returns:\n `torch.FloatTensor`:\n A scaled input sample.\n \"\"\"\n return sample\n\n def _get_variance(self, timestep, prev_timestep):\n alpha_prod_t = self.alphas_cumprod[timestep]\n alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod\n beta_prod_t = 1 - alpha_prod_t\n beta_prod_t_prev = 1 - alpha_prod_t_prev\n\n variance = (beta_prod_t_prev / beta_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev)\n\n return variance\n\n # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample\n def _threshold_sample(self, sample: torch.FloatTensor) -> torch.FloatTensor:\n \"\"\"\n \"Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the\n prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by\n s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing\n pixels from saturation at each step. We find that dynamic thresholding results in significantly better\n photorealism as well as better image-text alignment, especially when using very large guidance weights.\"\n https://arxiv.org/abs/2205.11487\n \"\"\"\n dtype = sample.dtype\n batch_size, channels, height, width = sample.shape\n\n if dtype not in (torch.float32, torch.float64):\n sample = sample.float() # upcast for quantile calculation, and clamp not implemented for cpu half\n\n # Flatten sample for doing quantile calculation along each image\n sample = sample.reshape(batch_size, channels * height * width)\n\n abs_sample = sample.abs() # \"a certain percentile absolute pixel value\"\n\n s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1)\n s = torch.clamp(\n s, min=1, max=self.config.sample_max_value\n ) # When clamped to min=1, equivalent to standard clipping to [-1, 1]\n\n s = s.unsqueeze(1) # (batch_size, 1) because clamp will broadcast along dim=0\n sample = torch.clamp(sample, -s, s) / s # \"we threshold xt0 to the range [-s, s] and then divide by s\"\n\n sample = sample.reshape(batch_size, channels, height, width)\n sample = sample.to(dtype)\n\n return sample\n\n def set_timesteps(self, num_inference_steps: int, lcm_origin_steps: int, device: Union[str, torch.device] = None):\n \"\"\"\n Sets the discrete timesteps used for the diffusion chain (to be run before inference).\n Args:\n num_inference_steps (`int`):\n The number of diffusion steps used when generating samples with a pre-trained model.\n \"\"\"\n\n if num_inference_steps > self.config.num_train_timesteps:\n raise ValueError(\n f\"`num_inference_steps`: {num_inference_steps} cannot be larger than `self.config.train_timesteps`:\"\n f\" {self.config.num_train_timesteps} as the unet model trained with this scheduler can only handle\"\n f\" maximal {self.config.num_train_timesteps} timesteps.\"\n )\n\n self.num_inference_steps = num_inference_steps\n\n # LCM Timesteps Setting: # Linear Spacing\n c = self.config.num_train_timesteps // lcm_origin_steps\n lcm_origin_timesteps = np.asarray(list(range(1, lcm_origin_steps + 1))) * c - 1 # LCM Training Steps Schedule\n skipping_step = len(lcm_origin_timesteps) // num_inference_steps\n timesteps = lcm_origin_timesteps[::-skipping_step][:num_inference_steps] # LCM Inference Steps Schedule\n\n self.timesteps = torch.from_numpy(timesteps.copy()).to(device)\n\n def get_scalings_for_boundary_condition_discrete(self, t):\n self.sigma_data = 0.5 # Default: 0.5\n\n # By dividing 0.1: This is almost a delta function at t=0.\n c_skip = self.sigma_data ** 2 / ((t / 0.1) ** 2 + self.sigma_data ** 2)\n c_out = ((t / 0.1) / ((t / 0.1) ** 2 + self.sigma_data ** 2) ** 0.5)\n return c_skip, c_out\n\n def step(\n self,\n model_output: torch.FloatTensor,\n timeindex: int,\n timestep: int,\n sample: torch.FloatTensor,\n eta: float = 0.0,\n use_clipped_model_output: bool = False,\n generator=None,\n variance_noise: Optional[torch.FloatTensor] = None,\n return_dict: bool = True,\n ) -> Union[LCMSchedulerOutput, Tuple]:\n \"\"\"\n Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion\n process from the learned model outputs (most often the predicted noise).\n Args:\n model_output (`torch.FloatTensor`):\n The direct output from learned diffusion model.\n timestep (`float`):\n The current discrete timestep in the diffusion chain.\n sample (`torch.FloatTensor`):\n A current instance of a sample created by the diffusion process.\n eta (`float`):\n The weight of noise for added noise in diffusion step.\n use_clipped_model_output (`bool`, defaults to `False`):\n If `True`, computes \"corrected\" `model_output` from the clipped predicted original sample. Necessary\n because predicted original sample is clipped to [-1, 1] when `self.config.clip_sample` is `True`. If no\n clipping has happened, \"corrected\" `model_output` would coincide with the one provided as input and\n `use_clipped_model_output` has no effect.\n generator (`torch.Generator`, *optional*):\n A random number generator.\n variance_noise (`torch.FloatTensor`):\n Alternative to generating noise with `generator` by directly providing the noise for the variance\n itself. Useful for methods such as [`CycleDiffusion`].\n return_dict (`bool`, *optional*, defaults to `True`):\n Whether or not to return a [`~schedulers.scheduling_lcm.LCMSchedulerOutput`] or `tuple`.\n Returns:\n [`~schedulers.scheduling_utils.LCMSchedulerOutput`] or `tuple`:\n If return_dict is `True`, [`~schedulers.scheduling_lcm.LCMSchedulerOutput`] is returned, otherwise a\n tuple is returned where the first element is the sample tensor.\n \"\"\"\n if self.num_inference_steps is None:\n raise ValueError(\n \"Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler\"\n )\n\n # 1. get previous step value\n prev_timeindex = timeindex + 1\n if prev_timeindex < len(self.timesteps):\n prev_timestep = self.timesteps[prev_timeindex]\n else:\n prev_timestep = timestep\n\n # 2. compute alphas, betas\n alpha_prod_t = self.alphas_cumprod[timestep]\n alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod\n\n beta_prod_t = 1 - alpha_prod_t\n beta_prod_t_prev = 1 - alpha_prod_t_prev\n\n # 3. Get scalings for boundary conditions\n c_skip, c_out = self.get_scalings_for_boundary_condition_discrete(timestep)\n\n # 4. Different Parameterization:\n parameterization = self.config.prediction_type\n\n if parameterization == \"epsilon\": # noise-prediction\n pred_x0 = (sample - beta_prod_t.sqrt() * model_output) / alpha_prod_t.sqrt()\n\n elif parameterization == \"sample\": # x-prediction\n pred_x0 = model_output\n\n elif parameterization == \"v_prediction\": # v-prediction\n pred_x0 = alpha_prod_t.sqrt() * sample - beta_prod_t.sqrt() * model_output\n\n # 4. Denoise model output using boundary conditions\n denoised = c_out * pred_x0 + c_skip * sample\n\n # 5. Sample z ~ N(0, I), For MultiStep Inference\n # Noise is not used for one-step sampling.\n if len(self.timesteps) > 1:\n noise = torch.randn(model_output.shape).to(model_output.device)\n prev_sample = alpha_prod_t_prev.sqrt() * denoised + beta_prod_t_prev.sqrt() * noise\n else:\n prev_sample = denoised\n\n if not return_dict:\n return (prev_sample, denoised)\n\n return LCMSchedulerOutput(prev_sample=prev_sample, denoised=denoised)\n\n # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.add_noise\n def add_noise(\n self,\n original_samples: torch.FloatTensor,\n noise: torch.FloatTensor,\n timesteps: torch.IntTensor,\n ) -> torch.FloatTensor:\n # Make sure alphas_cumprod and timestep have same device and dtype as original_samples\n alphas_cumprod = self.alphas_cumprod.to(device=original_samples.device, dtype=original_samples.dtype)\n timesteps = timesteps.to(original_samples.device)\n\n sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5\n sqrt_alpha_prod = sqrt_alpha_prod.flatten()\n while len(sqrt_alpha_prod.shape) < len(original_samples.shape):\n sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)\n\n sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()\n while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape):\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)\n\n noisy_samples = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise\n return noisy_samples\n\n # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.get_velocity\n def get_velocity(\n self, sample: torch.FloatTensor, noise: torch.FloatTensor, timesteps: torch.IntTensor\n ) -> torch.FloatTensor:\n # Make sure alphas_cumprod and timestep have same device and dtype as sample\n alphas_cumprod = self.alphas_cumprod.to(device=sample.device, dtype=sample.dtype)\n timesteps = timesteps.to(sample.device)\n\n sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5\n sqrt_alpha_prod = sqrt_alpha_prod.flatten()\n while len(sqrt_alpha_prod.shape) < len(sample.shape):\n sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)\n\n sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()\n while len(sqrt_one_minus_alpha_prod.shape) < len(sample.shape):\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)\n\n velocity = sqrt_alpha_prod * noise - sqrt_one_minus_alpha_prod * sample\n return velocity\n\n def __len__(self):\n return self.config.num_train_timesteps"}],"string":"[\n {\n \"identifier\": \"IDDPM\",\n \"path\": \"diffusion/iddpm.py\",\n \"snippet\": \"def IDDPM(\\n timestep_respacing,\\n noise_schedule=\\\"linear\\\",\\n use_kl=False,\\n sigma_small=False,\\n predict_xstart=False,\\n learn_sigma=True,\\n pred_sigma=True,\\n rescale_learned_sigmas=False,\\n diffusion_steps=1000,\\n snr=False,\\n return_startx=False,\\n):\\n betas = gd.get_named_beta_schedule(noise_schedule, diffusion_steps)\\n if use_kl:\\n loss_type = gd.LossType.RESCALED_KL\\n elif rescale_learned_sigmas:\\n loss_type = gd.LossType.RESCALED_MSE\\n else:\\n loss_type = gd.LossType.MSE\\n if timestep_respacing is None or timestep_respacing == \\\"\\\":\\n timestep_respacing = [diffusion_steps]\\n return SpacedDiffusion(\\n use_timesteps=space_timesteps(diffusion_steps, timestep_respacing),\\n betas=betas,\\n model_mean_type=(\\n gd.ModelMeanType.EPSILON if not predict_xstart else gd.ModelMeanType.START_X\\n ),\\n model_var_type=(\\n ((\\n gd.ModelVarType.FIXED_LARGE\\n if not sigma_small\\n else gd.ModelVarType.FIXED_SMALL\\n )\\n if not learn_sigma\\n else gd.ModelVarType.LEARNED_RANGE\\n )\\n if pred_sigma\\n else None\\n ),\\n loss_type=loss_type,\\n snr=snr,\\n return_startx=return_startx,\\n # rescale_timesteps=rescale_timesteps,\\n )\"\n },\n {\n \"identifier\": \"save_checkpoint\",\n \"path\": \"diffusion/utils/checkpoint.py\",\n \"snippet\": \"def save_checkpoint(work_dir,\\n epoch,\\n model,\\n model_ema=None,\\n optimizer=None,\\n lr_scheduler=None,\\n keep_last=False,\\n step=None,\\n ):\\n os.makedirs(work_dir, exist_ok=True)\\n state_dict = dict(state_dict=model.state_dict())\\n if model_ema is not None:\\n state_dict['state_dict_ema'] = model_ema.state_dict()\\n if optimizer is not None:\\n state_dict['optimizer'] = optimizer.state_dict()\\n if lr_scheduler is not None:\\n state_dict['scheduler'] = lr_scheduler.state_dict()\\n if epoch is not None:\\n state_dict['epoch'] = epoch\\n file_path = os.path.join(work_dir, f\\\"epoch_{epoch}.pth\\\")\\n if step is not None:\\n file_path = file_path.split('.pth')[0] + f\\\"_step_{step}.pth\\\"\\n logger = get_root_logger()\\n torch.save(state_dict, file_path)\\n logger.info(f'Saved checkpoint of epoch {epoch} to {file_path.format(epoch)}.')\\n if keep_last:\\n for i in range(epoch):\\n previous_ckgt = file_path.format(i)\\n if os.path.exists(previous_ckgt):\\n os.remove(previous_ckgt)\"\n },\n {\n \"identifier\": \"load_checkpoint\",\n \"path\": \"diffusion/utils/checkpoint.py\",\n \"snippet\": \"def load_checkpoint(checkpoint,\\n model,\\n model_ema=None,\\n optimizer=None,\\n lr_scheduler=None,\\n load_ema=False,\\n resume_optimizer=True,\\n resume_lr_scheduler=True\\n ):\\n assert isinstance(checkpoint, str)\\n ckpt_file = checkpoint\\n checkpoint = torch.load(ckpt_file, map_location=\\\"cpu\\\")\\n\\n state_dict_keys = ['pos_embed', 'base_model.pos_embed', 'model.pos_embed']\\n for key in state_dict_keys:\\n if key in checkpoint['state_dict']:\\n del checkpoint['state_dict'][key]\\n if 'state_dict_ema' in checkpoint and key in checkpoint['state_dict_ema']:\\n del checkpoint['state_dict_ema'][key]\\n break\\n\\n if load_ema:\\n state_dict = checkpoint['state_dict_ema']\\n else:\\n state_dict = checkpoint.get('state_dict', checkpoint) # to be compatible with the official checkpoint\\n # model.load_state_dict(state_dict)\\n missing, unexpect = model.load_state_dict(state_dict, strict=False)\\n if model_ema is not None:\\n model_ema.load_state_dict(checkpoint['state_dict_ema'], strict=False)\\n if optimizer is not None and resume_optimizer:\\n optimizer.load_state_dict(checkpoint['optimizer'])\\n if lr_scheduler is not None and resume_lr_scheduler:\\n lr_scheduler.load_state_dict(checkpoint['scheduler'])\\n logger = get_root_logger()\\n if optimizer is not None:\\n epoch = checkpoint.get('epoch', re.match(r'.*epoch_(\\\\d*).*.pth', ckpt_file).group()[0])\\n logger.info(f'Resume checkpoint of epoch {epoch} from {ckpt_file}. Load ema: {load_ema}, '\\n f'resume optimizer： {resume_optimizer}, resume lr scheduler: {resume_lr_scheduler}.')\\n return epoch, missing, unexpect\\n logger.info(f'Load checkpoint from {ckpt_file}. Load ema: {load_ema}.')\\n return missing, unexpect\"\n },\n {\n \"identifier\": \"synchronize\",\n \"path\": \"diffusion/utils/dist_utils.py\",\n \"snippet\": \"def synchronize():\\n \\\"\\\"\\\"\\n Helper function to synchronize (barrier) among all processes when\\n using distributed training\\n \\\"\\\"\\\"\\n if not dist.is_available():\\n return\\n if not dist.is_initialized():\\n return\\n world_size = dist.get_world_size()\\n if world_size == 1:\\n return\\n dist.barrier()\"\n },\n {\n \"identifier\": \"get_world_size\",\n \"path\": \"diffusion/utils/dist_utils.py\",\n \"snippet\": \"def get_world_size():\\n if not dist.is_available():\\n return 1\\n if not dist.is_initialized():\\n return 1\\n return dist.get_world_size()\"\n },\n {\n \"identifier\": \"clip_grad_norm_\",\n \"path\": \"diffusion/utils/dist_utils.py\",\n \"snippet\": \"@torch.no_grad()\\ndef clip_grad_norm_(\\n self, max_norm: Union[float, int], norm_type: Union[float, int] = 2.0\\n) -> None:\\n self._lazy_init()\\n self._wait_for_previous_optim_step()\\n assert self._is_root, \\\"clip_grad_norm should only be called on the root (parent) instance\\\"\\n self._assert_state(TrainingState_.IDLE)\\n\\n max_norm = float(max_norm)\\n norm_type = float(norm_type)\\n # Computes the max norm for this shard's gradients and sync's across workers\\n local_norm = _calc_grad_norm(self.params_with_grad, norm_type).cuda() # type: ignore[arg-type]\\n if norm_type == math.inf:\\n total_norm = local_norm\\n dist.all_reduce(total_norm, op=torch.distributed.ReduceOp.MAX, group=self.process_group)\\n else:\\n total_norm = local_norm ** norm_type\\n dist.all_reduce(total_norm, group=self.process_group)\\n total_norm = total_norm ** (1.0 / norm_type)\\n\\n clip_coef = torch.tensor(max_norm, dtype=total_norm.dtype, device=total_norm.device) / (total_norm + 1e-6)\\n if clip_coef < 1:\\n # multiply by clip_coef, aka, (max_norm/total_norm).\\n for p in self.params_with_grad:\\n assert p.grad is not None\\n p.grad.detach().mul_(clip_coef.to(p.grad.device))\\n return total_norm\"\n },\n {\n \"identifier\": \"build_dataset\",\n \"path\": \"diffusion/data/builder.py\",\n \"snippet\": \"def build_dataset(cfg, resolution=224, **kwargs):\\n logger = get_root_logger()\\n\\n dataset_type = cfg.get('type')\\n logger.info(f\\\"Constructing dataset {dataset_type}...\\\")\\n t = time.time()\\n transform = cfg.pop('transform', 'default_train')\\n transform = get_transform(transform, resolution)\\n dataset = build_from_cfg(cfg, DATASETS, default_args=dict(transform=transform, resolution=resolution, **kwargs))\\n logger.info(f\\\"Dataset {dataset_type} constructed. time: {(time.time() - t):.2f} s, length (use/ori): {len(dataset)}/{dataset.ori_imgs_nums}\\\")\\n return dataset\"\n },\n {\n \"identifier\": \"build_dataloader\",\n \"path\": \"diffusion/data/builder.py\",\n \"snippet\": \"def build_dataloader(dataset, batch_size=256, num_workers=4, shuffle=True, **kwargs):\\n if 'batch_sampler' in kwargs:\\n dataloader = DataLoader(dataset, batch_sampler=kwargs['batch_sampler'], num_workers=num_workers, pin_memory=True)\\n else:\\n dataloader = DataLoader(dataset,\\n batch_size=batch_size,\\n shuffle=shuffle,\\n num_workers=num_workers,\\n pin_memory=True,\\n **kwargs)\\n return dataloader\"\n },\n {\n \"identifier\": \"set_data_root\",\n \"path\": \"diffusion/data/builder.py\",\n \"snippet\": \"def set_data_root(data_root):\\n global DATA_ROOT\\n DATA_ROOT = data_root\"\n },\n {\n \"identifier\": \"build_model\",\n \"path\": \"diffusion/model/builder.py\",\n \"snippet\": \"def build_model(cfg, use_grad_checkpoint=False, use_fp32_attention=False, gc_step=1, **kwargs):\\n if isinstance(cfg, str):\\n cfg = dict(type=cfg)\\n model = MODELS.build(cfg, default_args=kwargs)\\n if use_grad_checkpoint:\\n set_grad_checkpoint(model, use_fp32_attention=use_fp32_attention, gc_step=gc_step)\\n return model\"\n },\n {\n \"identifier\": \"get_root_logger\",\n \"path\": \"diffusion/utils/logger.py\",\n \"snippet\": \"def get_root_logger(log_file=None, log_level=logging.INFO, name='PixArt'):\\n \\\"\\\"\\\"Get root logger.\\n\\n Args:\\n log_file (str, optional): File path of log. Defaults to None.\\n log_level (int, optional): The level of logger.\\n Defaults to logging.INFO.\\n name (str): logger name\\n Returns:\\n :obj:`logging.Logger`: The obtained logger\\n \\\"\\\"\\\"\\n if log_file is None:\\n log_file = '/dev/null'\\n logger = get_logger(name=name, log_file=log_file, log_level=log_level)\\n return logger\"\n },\n {\n \"identifier\": \"set_random_seed\",\n \"path\": \"diffusion/utils/misc.py\",\n \"snippet\": \"def set_random_seed(seed, deterministic=False):\\n \\\"\\\"\\\"Set random seed.\\n\\n Args:\\n seed (int): Seed to be used.\\n deterministic (bool): Whether to set the deterministic option for\\n CUDNN backend, i.e., set `torch.backends.cudnn.deterministic`\\n to True and `torch.backends.cudnn.benchmark` to False.\\n Default: False.\\n \\\"\\\"\\\"\\n random.seed(seed)\\n np.random.seed(seed)\\n torch.manual_seed(seed)\\n torch.cuda.manual_seed_all(seed)\\n if deterministic:\\n torch.backends.cudnn.deterministic = True\\n torch.backends.cudnn.benchmark = False\"\n },\n {\n \"identifier\": \"read_config\",\n \"path\": \"diffusion/utils/misc.py\",\n \"snippet\": \"def read_config(file):\\n # solve config loading conflict when multi-processes\\n import time\\n while True:\\n config = Config.fromfile(file)\\n if len(config) == 0:\\n time.sleep(0.1)\\n continue\\n break\\n return config\"\n },\n {\n \"identifier\": \"init_random_seed\",\n \"path\": \"diffusion/utils/misc.py\",\n \"snippet\": \"def init_random_seed(seed=None, device='cuda'):\\n \\\"\\\"\\\"Initialize random seed.\\n\\n If the seed is not set, the seed will be automatically randomized,\\n and then broadcast to all processes to prevent some potential bugs.\\n\\n Args:\\n seed (int, Optional): The seed. Default to None.\\n device (str): The device where the seed will be put on.\\n Default to 'cuda'.\\n\\n Returns:\\n int: Seed to be used.\\n \\\"\\\"\\\"\\n if seed is not None:\\n return seed\\n\\n # Make sure all ranks share the same random seed to prevent\\n # some potential bugs. Please refer to\\n # https://github.com/open-mmlab/mmdetection/issues/6339\\n rank, world_size = get_dist_info()\\n seed = np.random.randint(2 ** 31)\\n if world_size == 1:\\n return seed\\n\\n if rank == 0:\\n random_num = torch.tensor(seed, dtype=torch.int32, device=device)\\n else:\\n random_num = torch.tensor(0, dtype=torch.int32, device=device)\\n dist.broadcast(random_num, src=0)\\n return random_num.item()\"\n },\n {\n \"identifier\": \"DebugUnderflowOverflow\",\n \"path\": \"diffusion/utils/misc.py\",\n \"snippet\": \"class DebugUnderflowOverflow:\\n \\\"\\\"\\\"\\n This debug class helps detect and understand where the model starts getting very large or very small, and more\\n importantly `nan` or `inf` weight and activation elements.\\n There are 2 working modes:\\n 1. Underflow/overflow detection (default)\\n 2. Specific batch absolute min/max tracing without detection\\n Mode 1: Underflow/overflow detection\\n To activate the underflow/overflow detection, initialize the object with the model :\\n ```python\\n debug_overflow = DebugUnderflowOverflow(model)\\n ```\\n then run the training as normal and if `nan` or `inf` gets detected in at least one of the weight, input or\\n output elements this module will throw an exception and will print `max_frames_to_save` frames that lead to this\\n event, each frame reporting\\n 1. the fully qualified module name plus the class name whose `forward` was run\\n 2. the absolute min and max value of all elements for each module weights, and the inputs and output\\n For example, here is the header and the last few frames in detection report for `google/mt5-small` run in fp16 mixed precision :\\n ```\\n Detected inf/nan during batch_number=0\\n Last 21 forward frames:\\n abs min abs max metadata\\n [...]\\n encoder.block.2.layer.1.DenseReluDense.wi_0 Linear\\n 2.17e-07 4.50e+00 weight\\n 1.79e-06 4.65e+00 input[0]\\n 2.68e-06 3.70e+01 output\\n encoder.block.2.layer.1.DenseReluDense.wi_1 Linear\\n 8.08e-07 2.66e+01 weight\\n 1.79e-06 4.65e+00 input[0]\\n 1.27e-04 2.37e+02 output\\n encoder.block.2.layer.1.DenseReluDense.wo Linear\\n 1.01e-06 6.44e+00 weight\\n 0.00e+00 9.74e+03 input[0]\\n 3.18e-04 6.27e+04 output\\n encoder.block.2.layer.1.DenseReluDense T5DenseGatedGeluDense\\n 1.79e-06 4.65e+00 input[0]\\n 3.18e-04 6.27e+04 output\\n encoder.block.2.layer.1.dropout Dropout\\n 3.18e-04 6.27e+04 input[0]\\n 0.00e+00 inf output\\n ```\\n You can see here, that `T5DenseGatedGeluDense.forward` resulted in output activations, whose absolute max value\\n was around 62.7K, which is very close to fp16's top limit of 64K. In the next frame we have `Dropout` which\\n renormalizes the weights, after it zeroed some of the elements, which pushes the absolute max value to more than\\n 64K, and we get an overlow.\\n As you can see it's the previous frames that we need to look into when the numbers start going into very large for\\n fp16 numbers.\\n The tracking is done in a forward hook, which gets invoked immediately after `forward` has completed.\\n By default the last 21 frames are printed. You can change the default to adjust for your needs. For example :\\n ```python\\n debug_overflow = DebugUnderflowOverflow(model, max_frames_to_save=100)\\n ```\\n To validate that you have set up this debugging feature correctly, and you intend to use it in a training that may\\n take hours to complete, first run it with normal tracing enabled for one of a few batches as explained in the next\\n section.\\n Mode 2. Specific batch absolute min/max tracing without detection\\n The second work mode is per-batch tracing with the underflow/overflow detection feature turned off.\\n Let's say you want to watch the absolute min and max values for all the ingredients of each `forward` call of a\\n given batch, and only do that for batches 1 and 3. Then you instantiate this class as :\\n ```python\\n debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1,3])\\n ```\\n And now full batches 1 and 3 will be traced using the same format as explained above. Batches are 0-indexed.\\n This is helpful if you know that the program starts misbehaving after a certain batch number, so you can\\n fast-forward right to that area.\\n Early stopping:\\n You can also specify the batch number after which to stop the training, with :\\n ```python\\n debug_overflow = DebugUnderflowOverflow(model, trace_batch_nums=[1,3], abort_after_batch_num=3)\\n ```\\n This feature is mainly useful in the tracing mode, but you can use it for any mode.\\n **Performance**:\\n As this module measures absolute `min`/``max` of each weight of the model on every forward it'll slow the\\n training down. Therefore remember to turn it off once the debugging needs have been met.\\n Args:\\n model (`nn.Module`):\\n The model to debug.\\n max_frames_to_save (`int`, *optional*, defaults to 21):\\n How many frames back to record\\n trace_batch_nums(`List[int]`, *optional*, defaults to `[]`):\\n Which batch numbers to trace (turns detection off)\\n abort_after_batch_num (`int``, *optional*):\\n Whether to abort after a certain batch number has finished\\n \\\"\\\"\\\"\\n\\n def __init__(self, model, max_frames_to_save=21, trace_batch_nums=[], abort_after_batch_num=None):\\n self.model = model\\n self.trace_batch_nums = trace_batch_nums\\n self.abort_after_batch_num = abort_after_batch_num\\n\\n # keep a LIFO buffer of frames to dump as soon as inf/nan is encountered to give context to the problem emergence\\n self.frames = collections.deque([], max_frames_to_save)\\n self.frame = []\\n self.batch_number = 0\\n self.total_calls = 0\\n self.detected_overflow = False\\n self.prefix = \\\" \\\"\\n\\n self.analyse_model()\\n\\n self.register_forward_hook()\\n\\n def save_frame(self, frame=None):\\n if frame is not None:\\n self.expand_frame(frame)\\n self.frames.append(\\\"\\\\n\\\".join(self.frame))\\n self.frame = [] # start a new frame\\n\\n def expand_frame(self, line):\\n self.frame.append(line)\\n\\n def trace_frames(self):\\n print(\\\"\\\\n\\\".join(self.frames))\\n self.frames = []\\n\\n def reset_saved_frames(self):\\n self.frames = []\\n\\n def dump_saved_frames(self):\\n print(f\\\"\\\\nDetected inf/nan during batch_number={self.batch_number} \\\"\\n f\\\"Last {len(self.frames)} forward frames:\\\"\\n f\\\"{'abs min':8} {'abs max':8} metadata\\\"\\n f\\\"'\\\\n'.join(self.frames)\\\"\\n f\\\"\\\\n\\\\n\\\")\\n self.frames = []\\n\\n def analyse_model(self):\\n # extract the fully qualified module names, to be able to report at run time. e.g.:\\n # encoder.block.2.layer.0.SelfAttention.o\\n #\\n # for shared weights only the first shared module name will be registered\\n self.module_names = {m: name for name, m in self.model.named_modules()}\\n # self.longest_module_name = max(len(v) for v in self.module_names.values())\\n\\n def analyse_variable(self, var, ctx):\\n if torch.is_tensor(var):\\n self.expand_frame(self.get_abs_min_max(var, ctx))\\n if self.detect_overflow(var, ctx):\\n self.detected_overflow = True\\n elif var is None:\\n self.expand_frame(f\\\"{'None':>17} {ctx}\\\")\\n else:\\n self.expand_frame(f\\\"{'not a tensor':>17} {ctx}\\\")\\n\\n def batch_start_frame(self):\\n self.expand_frame(f\\\"\\\\n\\\\n{self.prefix} *** Starting batch number={self.batch_number} ***\\\")\\n self.expand_frame(f\\\"{'abs min':8} {'abs max':8} metadata\\\")\\n\\n def batch_end_frame(self):\\n self.expand_frame(f\\\"{self.prefix} *** Finished batch number={self.batch_number - 1} ***\\\\n\\\\n\\\")\\n\\n def create_frame(self, module, input, output):\\n self.expand_frame(f\\\"{self.prefix} {self.module_names[module]} {module.__class__.__name__}\\\")\\n\\n # params\\n for name, p in module.named_parameters(recurse=False):\\n self.analyse_variable(p, name)\\n\\n # inputs\\n if isinstance(input, tuple):\\n for i, x in enumerate(input):\\n self.analyse_variable(x, f\\\"input[{i}]\\\")\\n else:\\n self.analyse_variable(input, \\\"input\\\")\\n\\n # outputs\\n if isinstance(output, tuple):\\n for i, x in enumerate(output):\\n # possibly a tuple of tuples\\n if isinstance(x, tuple):\\n for j, y in enumerate(x):\\n self.analyse_variable(y, f\\\"output[{i}][{j}]\\\")\\n else:\\n self.analyse_variable(x, f\\\"output[{i}]\\\")\\n else:\\n self.analyse_variable(output, \\\"output\\\")\\n\\n self.save_frame()\\n\\n def register_forward_hook(self):\\n self.model.apply(self._register_forward_hook)\\n\\n def _register_forward_hook(self, module):\\n module.register_forward_hook(self.forward_hook)\\n\\n def forward_hook(self, module, input, output):\\n # - input is a tuple of packed inputs (could be non-Tensors)\\n # - output could be a Tensor or a tuple of Tensors and non-Tensors\\n\\n last_frame_of_batch = False\\n\\n trace_mode = True if self.batch_number in self.trace_batch_nums else False\\n if trace_mode:\\n self.reset_saved_frames()\\n\\n if self.total_calls == 0:\\n self.batch_start_frame()\\n self.total_calls += 1\\n\\n # count batch numbers - the very first forward hook of the batch will be called when the\\n # batch completes - i.e. it gets called very last - we know this batch has finished\\n if module == self.model:\\n self.batch_number += 1\\n last_frame_of_batch = True\\n\\n self.create_frame(module, input, output)\\n\\n # if last_frame_of_batch:\\n # self.batch_end_frame()\\n\\n if trace_mode:\\n self.trace_frames()\\n\\n if last_frame_of_batch:\\n self.batch_start_frame()\\n\\n if self.detected_overflow and not trace_mode:\\n self.dump_saved_frames()\\n\\n # now we can abort, as it's pointless to continue running\\n raise ValueError(\\n \\\"DebugUnderflowOverflow: inf/nan detected, aborting as there is no point running further. \\\"\\n \\\"Please scroll up above this traceback to see the activation values prior to this event.\\\"\\n )\\n\\n # abort after certain batch if requested to do so\\n if self.abort_after_batch_num is not None and self.batch_number > self.abort_after_batch_num:\\n raise ValueError(\\n f\\\"DebugUnderflowOverflow: aborting after {self.batch_number} batches due to `abort_after_batch_num={self.abort_after_batch_num}` arg\\\"\\n )\\n\\n @staticmethod\\n def get_abs_min_max(var, ctx):\\n abs_var = var.abs()\\n return f\\\"{abs_var.min():8.2e} {abs_var.max():8.2e} {ctx}\\\"\\n\\n @staticmethod\\n def detect_overflow(var, ctx):\\n \\\"\\\"\\\"\\n Report whether the tensor contains any `nan` or `inf` entries.\\n This is useful for detecting overflows/underflows and best to call right after the function that did some math that\\n modified the tensor in question.\\n This function contains a few other helper features that you can enable and tweak directly if you want to track\\n various other things.\\n Args:\\n var: the tensor variable to check\\n ctx: the message to print as a context\\n Return:\\n `True` if `inf` or `nan` was detected, `False` otherwise\\n \\\"\\\"\\\"\\n detected = False\\n if torch.isnan(var).any().item():\\n detected = True\\n print(f\\\"{ctx} has nans\\\")\\n if torch.isinf(var).any().item():\\n detected = True\\n print(f\\\"{ctx} has infs\\\")\\n if var.dtype == torch.float32 and torch.ge(var.abs(), 65535).any().item():\\n detected = True\\n print(f\\\"{ctx} has overflow values {var.abs().max().item()}.\\\")\\n # if needed to monitor large elements can enable the following\\n if 0: # and detected:\\n n100 = var[torch.ge(var.abs(), 100)]\\n if n100.numel() > 0:\\n print(f\\\"{ctx}: n100={n100.numel()}\\\")\\n n1000 = var[torch.ge(var.abs(), 1000)]\\n if n1000.numel() > 0:\\n print(f\\\"{ctx}: n1000={n1000.numel()}\\\")\\n n10000 = var[torch.ge(var.abs(), 10000)]\\n if n10000.numel() > 0:\\n print(f\\\"{ctx}: n10000={n10000.numel()}\\\")\\n\\n if 0:\\n print(f\\\"min={var.min():9.2e} max={var.max():9.2e}\\\")\\n\\n if 0:\\n print(f\\\"min={var.min():9.2e} max={var.max():9.2e} var={var.var():9.2e} mean={var.mean():9.2e} ({ctx})\\\")\\n\\n return detected\"\n },\n {\n \"identifier\": \"build_optimizer\",\n \"path\": \"diffusion/utils/optimizer.py\",\n \"snippet\": \"def build_optimizer(model, optimizer_cfg):\\n # default parameter-wise config\\n logger = get_root_logger()\\n\\n if hasattr(model, 'module'):\\n model = model.module\\n # set optimizer constructor\\n optimizer_cfg.setdefault('constructor', 'MyOptimizerConstructor')\\n # parameter-wise setting: cancel weight decay for some specific modules\\n custom_keys = dict()\\n for name, module in model.named_modules():\\n if hasattr(module, 'zero_weight_decay'):\\n custom_keys.update({(name, key): dict(decay_mult=0) for key in module.zero_weight_decay})\\n\\n paramwise_cfg = Config(dict(cfg=dict(custom_keys=custom_keys)))\\n given_cfg = optimizer_cfg.get('paramwise_cfg')\\n if given_cfg:\\n paramwise_cfg.merge_from_dict(dict(cfg=given_cfg))\\n optimizer_cfg['paramwise_cfg'] = paramwise_cfg.cfg\\n # build optimizer\\n optimizer = mm_build_optimizer(model, optimizer_cfg)\\n\\n weight_decay_groups = dict()\\n lr_groups = dict()\\n for group in optimizer.param_groups:\\n if not group.get('requires_grad', True): continue\\n lr_groups.setdefault(group['lr'], []).append(group)\\n weight_decay_groups.setdefault(group['weight_decay'], []).append(group)\\n\\n learnable_count, fix_count = 0, 0\\n for p in model.parameters():\\n if p.requires_grad:\\n learnable_count += 1\\n else:\\n fix_count += 1\\n fix_info = f\\\"{learnable_count} are learnable, {fix_count} are fix\\\"\\n lr_info = \\\"Lr group: \\\" + \\\", \\\".join([f'{len(group)} params with lr {lr:.5f}' for lr, group in lr_groups.items()])\\n wd_info = \\\"Weight decay group: \\\" + \\\", \\\".join(\\n [f'{len(group)} params with weight decay {wd}' for wd, group in weight_decay_groups.items()])\\n opt_info = f\\\"Optimizer: total {len(optimizer.param_groups)} param groups, {fix_info}. {lr_info}; {wd_info}.\\\"\\n logger.info(opt_info)\\n\\n return optimizer\"\n },\n {\n \"identifier\": \"auto_scale_lr\",\n \"path\": \"diffusion/utils/optimizer.py\",\n \"snippet\": \"def auto_scale_lr(effective_bs, optimizer_cfg, rule='linear', base_batch_size=256):\\n assert rule in ['linear', 'sqrt']\\n logger = get_root_logger()\\n # scale by world size\\n if rule == 'sqrt':\\n scale_ratio = math.sqrt(effective_bs / base_batch_size)\\n elif rule == 'linear':\\n scale_ratio = effective_bs / base_batch_size\\n optimizer_cfg['lr'] *= scale_ratio\\n logger.info(f'Automatically adapt lr to {optimizer_cfg[\\\"lr\\\"]:.7f} (using {rule} scaling rule).')\\n return scale_ratio\"\n },\n {\n \"identifier\": \"build_lr_scheduler\",\n \"path\": \"diffusion/utils/lr_scheduler.py\",\n \"snippet\": \"def build_lr_scheduler(config, optimizer, train_dataloader, lr_scale_ratio):\\n if not config.get('lr_schedule_args', None):\\n config.lr_schedule_args = dict()\\n if config.get('lr_warmup_steps', None):\\n config['num_warmup_steps'] = config.get('lr_warmup_steps') # for compatibility with old version\\n\\n logger = get_root_logger()\\n logger.info(\\n f'Lr schedule: {config.lr_schedule}, ' + \\\",\\\".join(\\n [f\\\"{key}:{value}\\\" for key, value in config.lr_schedule_args.items()]) + '.')\\n if config.lr_schedule == 'cosine':\\n lr_scheduler = get_cosine_schedule_with_warmup(\\n optimizer=optimizer,\\n **config.lr_schedule_args,\\n num_training_steps=(len(train_dataloader) * config.num_epochs),\\n )\\n elif config.lr_schedule == 'constant':\\n lr_scheduler = get_constant_schedule_with_warmup(\\n optimizer=optimizer,\\n **config.lr_schedule_args,\\n )\\n elif config.lr_schedule == 'cosine_decay_to_constant':\\n assert lr_scale_ratio >= 1\\n lr_scheduler = get_cosine_decay_to_constant_with_warmup(\\n optimizer=optimizer,\\n **config.lr_schedule_args,\\n final_lr=1 / lr_scale_ratio,\\n num_training_steps=(len(train_dataloader) * config.num_epochs),\\n )\\n else:\\n raise RuntimeError(f'Unrecognized lr schedule {config.lr_schedule}.')\\n return lr_scheduler\"\n },\n {\n \"identifier\": \"AspectRatioBatchSampler\",\n \"path\": \"diffusion/utils/data_sampler.py\",\n \"snippet\": \"class AspectRatioBatchSampler(BatchSampler):\\n \\\"\\\"\\\"A sampler wrapper for grouping images with similar aspect ratio into a same batch.\\n\\n Args:\\n sampler (Sampler): Base sampler.\\n dataset (Dataset): Dataset providing data information.\\n batch_size (int): Size of mini-batch.\\n drop_last (bool): If ``True``, the sampler will drop the last batch if\\n its size would be less than ``batch_size``.\\n aspect_ratios (dict): The predefined aspect ratios.\\n \\\"\\\"\\\"\\n\\n def __init__(self,\\n sampler: Sampler,\\n dataset: Dataset,\\n batch_size: int,\\n aspect_ratios: dict,\\n drop_last: bool = False,\\n config=None,\\n valid_num=0, # take as valid aspect-ratio when sample number >= valid_num\\n **kwargs) -> None:\\n if not isinstance(sampler, Sampler):\\n raise TypeError('sampler should be an instance of ``Sampler``, '\\n f'but got {sampler}')\\n if not isinstance(batch_size, int) or batch_size <= 0:\\n raise ValueError('batch_size should be a positive integer value, '\\n f'but got batch_size={batch_size}')\\n self.sampler = sampler\\n self.dataset = dataset\\n self.batch_size = batch_size\\n self.aspect_ratios = aspect_ratios\\n self.drop_last = drop_last\\n self.ratio_nums_gt = kwargs.get('ratio_nums', None)\\n self.config = config\\n assert self.ratio_nums_gt\\n # buckets for each aspect ratio\\n self._aspect_ratio_buckets = {ratio: [] for ratio in aspect_ratios.keys()}\\n self.current_available_bucket_keys = [str(k) for k, v in self.ratio_nums_gt.items() if v >= valid_num]\\n logger = get_root_logger() if config is None else get_root_logger(os.path.join(config.work_dir, 'train_log.log'))\\n logger.warning(f\\\"Using valid_num={valid_num} in config file. Available {len(self.current_available_bucket_keys)} aspect_ratios: {self.current_available_bucket_keys}\\\")\\n\\n def __iter__(self) -> Sequence[int]:\\n for idx in self.sampler:\\n data_info = self.dataset.get_data_info(idx)\\n height, width = data_info['height'], data_info['width']\\n ratio = height / width\\n # find the closest aspect ratio\\n closest_ratio = min(self.aspect_ratios.keys(), key=lambda r: abs(float(r) - ratio))\\n if closest_ratio not in self.current_available_bucket_keys:\\n continue\\n bucket = self._aspect_ratio_buckets[closest_ratio]\\n bucket.append(idx)\\n # yield a batch of indices in the same aspect ratio group\\n if len(bucket) == self.batch_size:\\n yield bucket[:]\\n del bucket[:]\\n\\n # yield the rest data and reset the buckets\\n for bucket in self._aspect_ratio_buckets.values():\\n while len(bucket) > 0:\\n if len(bucket) <= self.batch_size:\\n if not self.drop_last:\\n yield bucket[:]\\n bucket = []\\n else:\\n yield bucket[:self.batch_size]\\n bucket = bucket[self.batch_size:]\"\n },\n {\n \"identifier\": \"BalancedAspectRatioBatchSampler\",\n \"path\": \"diffusion/utils/data_sampler.py\",\n \"snippet\": \"class BalancedAspectRatioBatchSampler(AspectRatioBatchSampler):\\n def __init__(self, *args, **kwargs):\\n super().__init__(*args, **kwargs)\\n # Assign samples to each bucket\\n self.ratio_nums_gt = kwargs.get('ratio_nums', None)\\n assert self.ratio_nums_gt\\n self._aspect_ratio_buckets = {float(ratio): [] for ratio in self.aspect_ratios.keys()}\\n self.original_buckets = {}\\n self.current_available_bucket_keys = [k for k, v in self.ratio_nums_gt.items() if v >= 3000]\\n self.all_available_keys = deepcopy(self.current_available_bucket_keys)\\n self.exhausted_bucket_keys = []\\n self.total_batches = len(self.sampler) // self.batch_size\\n self._aspect_ratio_count = {}\\n for k in self.all_available_keys:\\n self._aspect_ratio_count[float(k)] = 0\\n self.original_buckets[float(k)] = []\\n logger = get_root_logger(os.path.join(self.config.work_dir, 'train_log.log'))\\n logger.warning(f\\\"Available {len(self.current_available_bucket_keys)} aspect_ratios: {self.current_available_bucket_keys}\\\")\\n\\n def __iter__(self) -> Sequence[int]:\\n i = 0\\n for idx in self.sampler:\\n data_info = self.dataset.get_data_info(idx)\\n height, width = data_info['height'], data_info['width']\\n ratio = height / width\\n closest_ratio = float(min(self.aspect_ratios.keys(), key=lambda r: abs(float(r) - ratio)))\\n if closest_ratio not in self.all_available_keys:\\n continue\\n if self._aspect_ratio_count[closest_ratio] < self.ratio_nums_gt[closest_ratio]:\\n self._aspect_ratio_count[closest_ratio] += 1\\n self._aspect_ratio_buckets[closest_ratio].append(idx)\\n self.original_buckets[closest_ratio].append(idx) # Save the original samples for each bucket\\n if not self.current_available_bucket_keys:\\n self.current_available_bucket_keys, self.exhausted_bucket_keys = self.exhausted_bucket_keys, []\\n\\n if closest_ratio not in self.current_available_bucket_keys:\\n continue\\n key = closest_ratio\\n bucket = self._aspect_ratio_buckets[key]\\n if len(bucket) == self.batch_size:\\n yield bucket[:self.batch_size]\\n del bucket[:self.batch_size]\\n i += 1\\n self.exhausted_bucket_keys.append(key)\\n self.current_available_bucket_keys.remove(key)\\n\\n for _ in range(self.total_batches - i):\\n key = choice(self.all_available_keys)\\n bucket = self._aspect_ratio_buckets[key]\\n if len(bucket) >= self.batch_size:\\n yield bucket[:self.batch_size]\\n del bucket[:self.batch_size]\\n\\n # If a bucket is exhausted\\n if not bucket:\\n self._aspect_ratio_buckets[key] = deepcopy(self.original_buckets[key][:])\\n shuffle(self._aspect_ratio_buckets[key])\\n else:\\n self._aspect_ratio_buckets[key] = deepcopy(self.original_buckets[key][:])\\n shuffle(self._aspect_ratio_buckets[key])\"\n },\n {\n \"identifier\": \"LCMScheduler\",\n \"path\": \"diffusion/lcm_scheduler.py\",\n \"snippet\": \"class LCMScheduler(SchedulerMixin, ConfigMixin):\\n \\\"\\\"\\\"\\n `LCMScheduler` extends the denoising procedure introduced in denoising diffusion probabilistic models (DDPMs) with\\n non-Markovian guidance.\\n This model inherits from [`SchedulerMixin`] and [`ConfigMixin`]. Check the superclass documentation for the generic\\n methods the library implements for all schedulers such as loading and saving.\\n Args:\\n num_train_timesteps (`int`, defaults to 1000):\\n The number of diffusion steps to train the model.\\n beta_start (`float`, defaults to 0.0001):\\n The starting `beta` value of inference.\\n beta_end (`float`, defaults to 0.02):\\n The final `beta` value.\\n beta_schedule (`str`, defaults to `\\\"linear\\\"`):\\n The beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from\\n `linear`, `scaled_linear`, or `squaredcos_cap_v2`.\\n trained_betas (`np.ndarray`, *optional*):\\n Pass an array of betas directly to the constructor to bypass `beta_start` and `beta_end`.\\n clip_sample (`bool`, defaults to `True`):\\n Clip the predicted sample for numerical stability.\\n clip_sample_range (`float`, defaults to 1.0):\\n The maximum magnitude for sample clipping. Valid only when `clip_sample=True`.\\n set_alpha_to_one (`bool`, defaults to `True`):\\n Each diffusion step uses the alphas product value at that step and at the previous one. For the final step\\n there is no previous alpha. When this option is `True` the previous alpha product is fixed to `1`,\\n otherwise it uses the alpha value at step 0.\\n steps_offset (`int`, defaults to 0):\\n An offset added to the inference steps. You can use a combination of `offset=1` and\\n `set_alpha_to_one=False` to make the last step use step 0 for the previous alpha product like in Stable\\n Diffusion.\\n prediction_type (`str`, defaults to `epsilon`, *optional*):\\n Prediction type of the scheduler function; can be `epsilon` (predicts the noise of the diffusion process),\\n `sample` (directly predicts the noisy sample`) or `v_prediction` (see section 2.4 of [Imagen\\n Video](https://imagen.research.google/video/paper.pdf) paper).\\n thresholding (`bool`, defaults to `False`):\\n Whether to use the \\\"dynamic thresholding\\\" method. This is unsuitable for latent-space diffusion models such\\n as Stable Diffusion.\\n dynamic_thresholding_ratio (`float`, defaults to 0.995):\\n The ratio for the dynamic thresholding method. Valid only when `thresholding=True`.\\n sample_max_value (`float`, defaults to 1.0):\\n The threshold value for dynamic thresholding. Valid only when `thresholding=True`.\\n timestep_spacing (`str`, defaults to `\\\"leading\\\"`):\\n The way the timesteps should be scaled. Refer to Table 2 of the [Common Diffusion Noise Schedules and\\n Sample Steps are Flawed](https://huggingface.co/papers/2305.08891) for more information.\\n rescale_betas_zero_snr (`bool`, defaults to `False`):\\n Whether to rescale the betas to have zero terminal SNR. This enables the model to generate very bright and\\n dark samples instead of limiting it to samples with medium brightness. Loosely related to\\n [`--offset_noise`](https://github.com/huggingface/diffusers/blob/74fd735eb073eb1d774b1ab4154a0876eb82f055/examples/dreambooth/train_dreambooth.py#L506).\\n \\\"\\\"\\\"\\n\\n # _compatibles = [e.name for e in KarrasDiffusionSchedulers]\\n order = 1\\n\\n @register_to_config\\n def __init__(\\n self,\\n num_train_timesteps: int = 1000,\\n beta_start: float = 0.0001,\\n beta_end: float = 0.02,\\n beta_schedule: str = \\\"linear\\\",\\n trained_betas: Optional[Union[np.ndarray, List[float]]] = None,\\n clip_sample: bool = True,\\n set_alpha_to_one: bool = True,\\n steps_offset: int = 0,\\n prediction_type: str = \\\"epsilon\\\",\\n thresholding: bool = False,\\n dynamic_thresholding_ratio: float = 0.995,\\n clip_sample_range: float = 1.0,\\n sample_max_value: float = 1.0,\\n timestep_spacing: str = \\\"leading\\\",\\n rescale_betas_zero_snr: bool = False,\\n ):\\n if trained_betas is not None:\\n self.betas = torch.tensor(trained_betas, dtype=torch.float32)\\n elif beta_schedule == \\\"linear\\\":\\n self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)\\n elif beta_schedule == \\\"scaled_linear\\\":\\n # this schedule is very specific to the latent diffusion model.\\n self.betas = (\\n torch.linspace(beta_start ** 0.5, beta_end ** 0.5, num_train_timesteps, dtype=torch.float32) ** 2\\n )\\n elif beta_schedule == \\\"squaredcos_cap_v2\\\":\\n # Glide cosine schedule\\n self.betas = betas_for_alpha_bar(num_train_timesteps)\\n else:\\n raise NotImplementedError(f\\\"{beta_schedule} does is not implemented for {self.__class__}\\\")\\n\\n # Rescale for zero SNR\\n if rescale_betas_zero_snr:\\n self.betas = rescale_zero_terminal_snr(self.betas)\\n\\n self.alphas = 1.0 - self.betas\\n self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)\\n\\n # At every step in ddim, we are looking into the previous alphas_cumprod\\n # For the final step, there is no previous alphas_cumprod because we are already at 0\\n # `set_alpha_to_one` decides whether we set this parameter simply to one or\\n # whether we use the final alpha of the \\\"non-previous\\\" one.\\n self.final_alpha_cumprod = torch.tensor(1.0) if set_alpha_to_one else self.alphas_cumprod[0]\\n\\n # standard deviation of the initial noise distribution\\n self.init_noise_sigma = 1.0\\n\\n # setable values\\n self.num_inference_steps = None\\n self.timesteps = torch.from_numpy(np.arange(0, num_train_timesteps)[::-1].copy().astype(np.int64))\\n\\n def scale_model_input(self, sample: torch.FloatTensor, timestep: Optional[int] = None) -> torch.FloatTensor:\\n \\\"\\\"\\\"\\n Ensures interchangeability with schedulers that need to scale the denoising model input depending on the\\n current timestep.\\n Args:\\n sample (`torch.FloatTensor`):\\n The input sample.\\n timestep (`int`, *optional*):\\n The current timestep in the diffusion chain.\\n Returns:\\n `torch.FloatTensor`:\\n A scaled input sample.\\n \\\"\\\"\\\"\\n return sample\\n\\n def _get_variance(self, timestep, prev_timestep):\\n alpha_prod_t = self.alphas_cumprod[timestep]\\n alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod\\n beta_prod_t = 1 - alpha_prod_t\\n beta_prod_t_prev = 1 - alpha_prod_t_prev\\n\\n variance = (beta_prod_t_prev / beta_prod_t) * (1 - alpha_prod_t / alpha_prod_t_prev)\\n\\n return variance\\n\\n # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample\\n def _threshold_sample(self, sample: torch.FloatTensor) -> torch.FloatTensor:\\n \\\"\\\"\\\"\\n \\\"Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the\\n prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by\\n s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing\\n pixels from saturation at each step. We find that dynamic thresholding results in significantly better\\n photorealism as well as better image-text alignment, especially when using very large guidance weights.\\\"\\n https://arxiv.org/abs/2205.11487\\n \\\"\\\"\\\"\\n dtype = sample.dtype\\n batch_size, channels, height, width = sample.shape\\n\\n if dtype not in (torch.float32, torch.float64):\\n sample = sample.float() # upcast for quantile calculation, and clamp not implemented for cpu half\\n\\n # Flatten sample for doing quantile calculation along each image\\n sample = sample.reshape(batch_size, channels * height * width)\\n\\n abs_sample = sample.abs() # \\\"a certain percentile absolute pixel value\\\"\\n\\n s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1)\\n s = torch.clamp(\\n s, min=1, max=self.config.sample_max_value\\n ) # When clamped to min=1, equivalent to standard clipping to [-1, 1]\\n\\n s = s.unsqueeze(1) # (batch_size, 1) because clamp will broadcast along dim=0\\n sample = torch.clamp(sample, -s, s) / s # \\\"we threshold xt0 to the range [-s, s] and then divide by s\\\"\\n\\n sample = sample.reshape(batch_size, channels, height, width)\\n sample = sample.to(dtype)\\n\\n return sample\\n\\n def set_timesteps(self, num_inference_steps: int, lcm_origin_steps: int, device: Union[str, torch.device] = None):\\n \\\"\\\"\\\"\\n Sets the discrete timesteps used for the diffusion chain (to be run before inference).\\n Args:\\n num_inference_steps (`int`):\\n The number of diffusion steps used when generating samples with a pre-trained model.\\n \\\"\\\"\\\"\\n\\n if num_inference_steps > self.config.num_train_timesteps:\\n raise ValueError(\\n f\\\"`num_inference_steps`: {num_inference_steps} cannot be larger than `self.config.train_timesteps`:\\\"\\n f\\\" {self.config.num_train_timesteps} as the unet model trained with this scheduler can only handle\\\"\\n f\\\" maximal {self.config.num_train_timesteps} timesteps.\\\"\\n )\\n\\n self.num_inference_steps = num_inference_steps\\n\\n # LCM Timesteps Setting: # Linear Spacing\\n c = self.config.num_train_timesteps // lcm_origin_steps\\n lcm_origin_timesteps = np.asarray(list(range(1, lcm_origin_steps + 1))) * c - 1 # LCM Training Steps Schedule\\n skipping_step = len(lcm_origin_timesteps) // num_inference_steps\\n timesteps = lcm_origin_timesteps[::-skipping_step][:num_inference_steps] # LCM Inference Steps Schedule\\n\\n self.timesteps = torch.from_numpy(timesteps.copy()).to(device)\\n\\n def get_scalings_for_boundary_condition_discrete(self, t):\\n self.sigma_data = 0.5 # Default: 0.5\\n\\n # By dividing 0.1: This is almost a delta function at t=0.\\n c_skip = self.sigma_data ** 2 / ((t / 0.1) ** 2 + self.sigma_data ** 2)\\n c_out = ((t / 0.1) / ((t / 0.1) ** 2 + self.sigma_data ** 2) ** 0.5)\\n return c_skip, c_out\\n\\n def step(\\n self,\\n model_output: torch.FloatTensor,\\n timeindex: int,\\n timestep: int,\\n sample: torch.FloatTensor,\\n eta: float = 0.0,\\n use_clipped_model_output: bool = False,\\n generator=None,\\n variance_noise: Optional[torch.FloatTensor] = None,\\n return_dict: bool = True,\\n ) -> Union[LCMSchedulerOutput, Tuple]:\\n \\\"\\\"\\\"\\n Predict the sample from the previous timestep by reversing the SDE. This function propagates the diffusion\\n process from the learned model outputs (most often the predicted noise).\\n Args:\\n model_output (`torch.FloatTensor`):\\n The direct output from learned diffusion model.\\n timestep (`float`):\\n The current discrete timestep in the diffusion chain.\\n sample (`torch.FloatTensor`):\\n A current instance of a sample created by the diffusion process.\\n eta (`float`):\\n The weight of noise for added noise in diffusion step.\\n use_clipped_model_output (`bool`, defaults to `False`):\\n If `True`, computes \\\"corrected\\\" `model_output` from the clipped predicted original sample. Necessary\\n because predicted original sample is clipped to [-1, 1] when `self.config.clip_sample` is `True`. If no\\n clipping has happened, \\\"corrected\\\" `model_output` would coincide with the one provided as input and\\n `use_clipped_model_output` has no effect.\\n generator (`torch.Generator`, *optional*):\\n A random number generator.\\n variance_noise (`torch.FloatTensor`):\\n Alternative to generating noise with `generator` by directly providing the noise for the variance\\n itself. Useful for methods such as [`CycleDiffusion`].\\n return_dict (`bool`, *optional*, defaults to `True`):\\n Whether or not to return a [`~schedulers.scheduling_lcm.LCMSchedulerOutput`] or `tuple`.\\n Returns:\\n [`~schedulers.scheduling_utils.LCMSchedulerOutput`] or `tuple`:\\n If return_dict is `True`, [`~schedulers.scheduling_lcm.LCMSchedulerOutput`] is returned, otherwise a\\n tuple is returned where the first element is the sample tensor.\\n \\\"\\\"\\\"\\n if self.num_inference_steps is None:\\n raise ValueError(\\n \\\"Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler\\\"\\n )\\n\\n # 1. get previous step value\\n prev_timeindex = timeindex + 1\\n if prev_timeindex < len(self.timesteps):\\n prev_timestep = self.timesteps[prev_timeindex]\\n else:\\n prev_timestep = timestep\\n\\n # 2. compute alphas, betas\\n alpha_prod_t = self.alphas_cumprod[timestep]\\n alpha_prod_t_prev = self.alphas_cumprod[prev_timestep] if prev_timestep >= 0 else self.final_alpha_cumprod\\n\\n beta_prod_t = 1 - alpha_prod_t\\n beta_prod_t_prev = 1 - alpha_prod_t_prev\\n\\n # 3. Get scalings for boundary conditions\\n c_skip, c_out = self.get_scalings_for_boundary_condition_discrete(timestep)\\n\\n # 4. Different Parameterization:\\n parameterization = self.config.prediction_type\\n\\n if parameterization == \\\"epsilon\\\": # noise-prediction\\n pred_x0 = (sample - beta_prod_t.sqrt() * model_output) / alpha_prod_t.sqrt()\\n\\n elif parameterization == \\\"sample\\\": # x-prediction\\n pred_x0 = model_output\\n\\n elif parameterization == \\\"v_prediction\\\": # v-prediction\\n pred_x0 = alpha_prod_t.sqrt() * sample - beta_prod_t.sqrt() * model_output\\n\\n # 4. Denoise model output using boundary conditions\\n denoised = c_out * pred_x0 + c_skip * sample\\n\\n # 5. Sample z ~ N(0, I), For MultiStep Inference\\n # Noise is not used for one-step sampling.\\n if len(self.timesteps) > 1:\\n noise = torch.randn(model_output.shape).to(model_output.device)\\n prev_sample = alpha_prod_t_prev.sqrt() * denoised + beta_prod_t_prev.sqrt() * noise\\n else:\\n prev_sample = denoised\\n\\n if not return_dict:\\n return (prev_sample, denoised)\\n\\n return LCMSchedulerOutput(prev_sample=prev_sample, denoised=denoised)\\n\\n # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.add_noise\\n def add_noise(\\n self,\\n original_samples: torch.FloatTensor,\\n noise: torch.FloatTensor,\\n timesteps: torch.IntTensor,\\n ) -> torch.FloatTensor:\\n # Make sure alphas_cumprod and timestep have same device and dtype as original_samples\\n alphas_cumprod = self.alphas_cumprod.to(device=original_samples.device, dtype=original_samples.dtype)\\n timesteps = timesteps.to(original_samples.device)\\n\\n sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5\\n sqrt_alpha_prod = sqrt_alpha_prod.flatten()\\n while len(sqrt_alpha_prod.shape) < len(original_samples.shape):\\n sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)\\n\\n sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5\\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()\\n while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape):\\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)\\n\\n noisy_samples = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise\\n return noisy_samples\\n\\n # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.get_velocity\\n def get_velocity(\\n self, sample: torch.FloatTensor, noise: torch.FloatTensor, timesteps: torch.IntTensor\\n ) -> torch.FloatTensor:\\n # Make sure alphas_cumprod and timestep have same device and dtype as sample\\n alphas_cumprod = self.alphas_cumprod.to(device=sample.device, dtype=sample.dtype)\\n timesteps = timesteps.to(sample.device)\\n\\n sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5\\n sqrt_alpha_prod = sqrt_alpha_prod.flatten()\\n while len(sqrt_alpha_prod.shape) < len(sample.shape):\\n sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)\\n\\n sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5\\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()\\n while len(sqrt_one_minus_alpha_prod.shape) < len(sample.shape):\\n sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)\\n\\n velocity = sqrt_alpha_prod * noise - sqrt_one_minus_alpha_prod * sample\\n return velocity\\n\\n def __len__(self):\\n return self.config.num_train_timesteps\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import os\nimport sys\nimport types\nimport argparse\nimport datetime\nimport time\nimport warnings\nimport torch\nimport torch.nn as nn\nimport numpy as np\nimport torch.nn.functional as F\nfrom pathlib import Path\nfrom accelerate import Accelerator, InitProcessGroupKwargs\nfrom accelerate.utils import DistributedType\nfrom diffusers.models import AutoencoderKL\nfrom torch.utils.data import RandomSampler\nfrom mmcv.runner import LogBuffer\nfrom copy import deepcopy\nfrom tqdm import tqdm\nfrom diffusion import IDDPM\nfrom diffusion.utils.checkpoint import save_checkpoint, load_checkpoint\nfrom diffusion.utils.dist_utils import synchronize, get_world_size, clip_grad_norm_\nfrom diffusion.data.builder import build_dataset, build_dataloader, set_data_root\nfrom diffusion.model.builder import build_model\nfrom diffusion.utils.logger import get_root_logger\nfrom diffusion.utils.misc import set_random_seed, read_config, init_random_seed, DebugUnderflowOverflow\nfrom diffusion.utils.optimizer import build_optimizer, auto_scale_lr\nfrom diffusion.utils.lr_scheduler import build_lr_scheduler\nfrom diffusion.utils.data_sampler import AspectRatioBatchSampler, BalancedAspectRatioBatchSampler\nfrom diffusion.lcm_scheduler import LCMScheduler\nfrom torchvision.utils import save_image\n from accelerate import FullyShardedDataParallelPlugin\n from torch.distributed.fsdp.fully_sharded_data_parallel import FullStateDictConfig"},"token_num":{"kind":"number","value":16418,"string":"16,418"},"cropped_code":{"kind":"string","value":" )\n synchronize()\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(description=\"Process some integers.\")\n parser.add_argument(\"config\", type=str, help=\"config\")\n parser.add_argument(\"--cloud\", action='store_true', default=False, help=\"cloud or local machine\")\n parser.add_argument('--work-dir', help='the dir to save logs and models')\n parser.add_argument('--resume-from', help='the dir to resume the training')\n parser.add_argument('--load-from', default=None, help='the dir to load a ckpt for training')\n parser.add_argument('--local-rank', type=int, default=-1)\n parser.add_argument('--local_rank', type=int, default=-1)\n parser.add_argument('--debug', action='store_true')\n args = parser.parse_args()\n return args\n\n\nif __name__ == '__main__':\n args = parse_args()\n config = read_config(args.config)\n if args.work_dir is not None:\n # update configs according to CLI args if args.work_dir is not None\n config.work_dir = args.work_dir\n if args.cloud:\n config.data_root = '/data/data'\n if args.resume_from is not None:\n config.load_from = None\n config.resume_from = dict(\n checkpoint=args.resume_from,\n load_ema=False,\n resume_optimizer=True,\n resume_lr_scheduler=True)\n if args.debug:\n config.log_interval = 1\n config.train_batch_size = 11\n config.valid_num = 100\n config.load_from = None\n\n os.umask(0o000)\n os.makedirs(config.work_dir, exist_ok=True)\n\n init_handler = InitProcessGroupKwargs()\n init_handler.timeout = datetime.timedelta(seconds=5400) # change timeout to avoid a strange NCCL bug\n # Initialize accelerator and tensorboard logging\n if config.use_fsdp:\n init_train = 'FSDP'\n set_fsdp_env()\n fsdp_plugin = FullyShardedDataParallelPlugin(state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),)\n else:\n init_train = 'DDP'\n fsdp_plugin = None\n\n even_batches = True\n if config.multi_scale:\n even_batches=False,\n\n accelerator = Accelerator(\n mixed_precision=config.mixed_precision,\n gradient_accumulation_steps=config.gradient_accumulation_steps,\n log_with=\"tensorboard\",\n project_dir=os.path.join(config.work_dir, \"logs\"),\n fsdp_plugin=fsdp_plugin,\n even_batches=even_batches,\n kwargs_handlers=[init_handler]\n )\n\n logger = get_root_logger(os.path.join(config.work_dir, 'train_log.log'))\n\n config.seed = init_random_seed(config.get('seed', None))\n set_random_seed(config.seed)\n\n if accelerator.is_main_process:\n config.dump(os.path.join(config.work_dir, 'config.py'))\n\n logger.info(f\"Config: \\n{config.pretty_text}\")\n logger.info(f\"World_size: {get_world_size()}, seed: {config.seed}\")\n logger.info(f\"Initializing: {init_train} for training\")\n image_size = config.image_size # @param [256, 512]\n latent_size = int(image_size) // 8\n pred_sigma = getattr(config, 'pred_sigma', True)\n learn_sigma = getattr(config, 'learn_sigma', True) and pred_sigma\n model_kwargs={\"window_block_indexes\": config.window_block_indexes, \"window_size\": config.window_size,\n \"use_rel_pos\": config.use_rel_pos, \"lewei_scale\": config.lewei_scale, 'config':config,\n 'model_max_length': config.model_max_length}\n\n # build models\n train_diffusion = IDDPM(str(config.train_sampling_steps), learn_sigma=learn_sigma, pred_sigma=pred_sigma,\n snr=config.snr_loss, return_startx=True)\n model = build_model(config.model,\n config.grad_checkpointing,\n config.get('fp32_attention', False),\n input_size=latent_size,\n learn_sigma=learn_sigma,\n pred_sigma=pred_sigma,\n **model_kwargs).train()\n logger.info(f\"{model.__class__.__name__} Model Parameters: {sum(p.numel() for p in model.parameters()):,}\")\n\n if config.load_from is not None:\n if args.load_from is not None:\n config.load_from = args.load_from\n missing, unexpected = load_checkpoint(config.load_from, model, load_ema=config.get('load_ema', False))\n logger.warning(f'Missing keys: {missing}')\n logger.warning(f'Unexpected keys: {unexpected}')\n\n model_ema = deepcopy(model).eval()\n model_teacher = deepcopy(model).eval()\n\n if not config.data.load_vae_feat:\n vae = AutoencoderKL.from_pretrained(config.vae_pretrained).cuda()\n\n # prepare for FSDP clip grad norm calculation\n if accelerator.distributed_type == DistributedType.FSDP:\n for m in accelerator._models:\n m.clip_grad_norm_ = types.MethodType(clip_grad_norm_, m)\n\n # build dataloader\n set_data_root(config.data_root)\n dataset = build_dataset(config.data, resolution=image_size, aspect_ratio_type=config.aspect_ratio_type)\n if config.multi_scale:\n"},"all_code":{"kind":"string","value":"current_file_path = Path(__file__).resolve()\nsys.path.insert(0, str(current_file_path.parent.parent))\nwarnings.filterwarnings(\"ignore\") # ignore warning\n\n\n\ndef set_fsdp_env():\n os.environ[\"ACCELERATE_USE_FSDP\"] = 'true'\n os.environ[\"FSDP_AUTO_WRAP_POLICY\"] = 'TRANSFORMER_BASED_WRAP'\n os.environ[\"FSDP_BACKWARD_PREFETCH\"] = 'BACKWARD_PRE'\n os.environ[\"FSDP_TRANSFORMER_CLS_TO_WRAP\"] = 'PixArtBlock'\n\n\ndef ema_update(model_dest: nn.Module, model_src: nn.Module, rate):\n param_dict_src = dict(model_src.named_parameters())\n for p_name, p_dest in model_dest.named_parameters():\n p_src = param_dict_src[p_name]\n assert p_src is not p_dest\n p_dest.data.mul_(rate).add_((1 - rate) * p_src.data)\n\n\ndef append_dims(x, target_dims):\n \"\"\"Appends dimensions to the end of a tensor until it has target_dims dimensions.\"\"\"\n dims_to_append = target_dims - x.ndim\n if dims_to_append < 0:\n raise ValueError(f\"input has {x.ndim} dims but target_dims is {target_dims}, which is less\")\n return x[(...,) + (None,) * dims_to_append]\n\n\n# From LCMScheduler.get_scalings_for_boundary_condition_discrete\ndef scalings_for_boundary_conditions(timestep, sigma_data=0.5, timestep_scaling=10.0):\n c_skip = sigma_data**2 / ((timestep / 0.1) ** 2 + sigma_data**2)\n c_out = (timestep / 0.1) / ((timestep / 0.1) ** 2 + sigma_data**2) ** 0.5\n return c_skip, c_out\n\n\ndef extract_into_tensor(a, t, x_shape):\n b, *_ = t.shape\n out = a.gather(-1, t)\n return out.reshape(b, *((1,) * (len(x_shape) - 1)))\n\n\nclass DDIMSolver:\n def __init__(self, alpha_cumprods, timesteps=1000, ddim_timesteps=50):\n # DDIM sampling parameters\n step_ratio = timesteps // ddim_timesteps\n\n self.ddim_timesteps = (np.arange(1, ddim_timesteps + 1) * step_ratio).round().astype(np.int64) - 1\n self.ddim_alpha_cumprods = alpha_cumprods[self.ddim_timesteps]\n self.ddim_alpha_cumprods_prev = np.asarray(\n [alpha_cumprods[0]] + alpha_cumprods[self.ddim_timesteps[:-1]].tolist()\n )\n # convert to torch tensors\n self.ddim_timesteps = torch.from_numpy(self.ddim_timesteps).long()\n self.ddim_alpha_cumprods = torch.from_numpy(self.ddim_alpha_cumprods)\n self.ddim_alpha_cumprods_prev = torch.from_numpy(self.ddim_alpha_cumprods_prev)\n\n def to(self, device):\n self.ddim_timesteps = self.ddim_timesteps.to(device)\n self.ddim_alpha_cumprods = self.ddim_alpha_cumprods.to(device)\n self.ddim_alpha_cumprods_prev = self.ddim_alpha_cumprods_prev.to(device)\n return self\n\n def ddim_step(self, pred_x0, pred_noise, timestep_index):\n alpha_cumprod_prev = extract_into_tensor(self.ddim_alpha_cumprods_prev, timestep_index, pred_x0.shape)\n dir_xt = (1.0 - alpha_cumprod_prev).sqrt() * pred_noise\n x_prev = alpha_cumprod_prev.sqrt() * pred_x0 + dir_xt\n return x_prev\n\n\n@torch.no_grad()\ndef log_validation(model, step, device):\n if hasattr(model, 'module'):\n model = model.module\n scheduler = LCMScheduler(beta_start=0.0001, beta_end=0.02, beta_schedule=\"linear\", prediction_type=\"epsilon\")\n scheduler.set_timesteps(4, 50)\n infer_timesteps = scheduler.timesteps\n\n dog_embed = torch.load('data/tmp/dog.pth', map_location='cpu')\n caption_embs, emb_masks = dog_embed['dog_text'].to(device), dog_embed['dog_mask'].to(device)\n hw = torch.tensor([[1024, 1024]], dtype=torch.float, device=device).repeat(1, 1)\n ar = torch.tensor([[1.]], device=device).repeat(1, 1)\n # Create sampling noise:\n infer_latents = torch.randn(1, 4, 1024, 1024, device=device)\n model_kwargs = dict(data_info={'img_hw': hw, 'aspect_ratio': ar}, mask=emb_masks)\n logger.info(\"Running validation... \")\n\n # 7. LCM MultiStep Sampling Loop:\n for i, t in tqdm(list(enumerate(infer_timesteps))):\n ts = torch.full((1,), t, device=device, dtype=torch.long)\n\n # model prediction (v-prediction, eps, x)\n model_pred = model(infer_latents, ts, caption_embs, **model_kwargs)[:, :4]\n\n # compute the previous noisy sample x_t -> x_t-1\n infer_latents, denoised = scheduler.step(model_pred, i, t, infer_latents, return_dict=False)\n samples = vae.decode(denoised / 0.18215).sample\n torch.cuda.empty_cache()\n save_image(samples[0], f'output_cv/vis/{step}.jpg', nrow=1, normalize=True, value_range=(-1, 1))\n\n\ndef train():\n if config.get('debug_nan', False):\n DebugUnderflowOverflow(model)\n logger.info('NaN debugger registered. Start to detect overflow during training.')\n time_start, last_tic = time.time(), time.time()\n log_buffer = LogBuffer()\n\n start_step = start_epoch * len(train_dataloader)\n global_step = 0\n total_steps = len(train_dataloader) * config.num_epochs\n\n load_vae_feat = getattr(train_dataloader.dataset, 'load_vae_feat', False)\n\n # Create uncond embeds for classifier free guidance\n uncond_prompt_embeds = model.module.y_embedder.y_embedding.repeat(config.train_batch_size, 1, 1, 1)\n\n # Now you train the model\n for epoch in range(start_epoch + 1, config.num_epochs + 1):\n data_time_start= time.time()\n data_time_all = 0\n for step, batch in enumerate(train_dataloader):\n data_time_all += time.time() - data_time_start\n if load_vae_feat:\n z = batch[0]\n else:\n with torch.no_grad():\n with torch.cuda.amp.autocast(enabled=config.mixed_precision == 'fp16'):\n posterior = vae.encode(batch[0]).latent_dist\n if config.sample_posterior:\n z = posterior.sample()\n else:\n z = posterior.mode()\n latents = z * config.scale_factor\n y = batch[1]\n y_mask = batch[2]\n data_info = batch[3]\n\n # Sample a random timestep for each image\n grad_norm = None\n with accelerator.accumulate(model):\n # Predict the noise residual\n optimizer.zero_grad()\n # Sample noise that we'll add to the latents\n noise = torch.randn_like(latents)\n bsz = latents.shape[0]\n\n # Sample a random timestep for each image t_n ~ U[0, N - k - 1] without bias.\n topk = config.train_sampling_steps // config.num_ddim_timesteps\n index = torch.randint(0, config.num_ddim_timesteps, (bsz,), device=latents.device).long()\n start_timesteps = solver.ddim_timesteps[index]\n timesteps = start_timesteps - topk\n timesteps = torch.where(timesteps < 0, torch.zeros_like(timesteps), timesteps)\n\n # Get boundary scalings for start_timesteps and (end) timesteps.\n c_skip_start, c_out_start = scalings_for_boundary_conditions(start_timesteps)\n c_skip_start, c_out_start = [append_dims(x, latents.ndim) for x in [c_skip_start, c_out_start]]\n c_skip, c_out = scalings_for_boundary_conditions(timesteps)\n c_skip, c_out = [append_dims(x, latents.ndim) for x in [c_skip, c_out]]\n\n # Sample a random guidance scale w from U[w_min, w_max] and embed it\n # w = (config.w_max - config.w_min) * torch.rand((bsz,)) + config.w_min\n w = config.cfg_scale * torch.ones((bsz,))\n w = w.reshape(bsz, 1, 1, 1)\n w = w.to(device=latents.device, dtype=latents.dtype)\n\n # Get online LCM prediction on z_{t_{n + k}}, w, c, t_{n + k}\n _, pred_x_0, noisy_model_input = train_diffusion.training_losses(model, latents, start_timesteps, model_kwargs=dict(y=y, mask=y_mask, data_info=data_info), noise=noise)\n\n model_pred = c_skip_start * noisy_model_input + c_out_start * pred_x_0\n\n # Use the ODE solver to predict the kth step in the augmented PF-ODE trajectory after\n # noisy_latents with both the conditioning embedding c and unconditional embedding 0\n # Get teacher model prediction on noisy_latents and conditional embedding\n with torch.no_grad():\n with torch.autocast(\"cuda\"):\n cond_teacher_output, cond_pred_x0, _ = train_diffusion.training_losses(model_teacher, latents, start_timesteps, model_kwargs=dict(y=y, mask=y_mask, data_info=data_info), noise=noise)\n\n # Get teacher model prediction on noisy_latents and unconditional embedding\n uncond_teacher_output, uncond_pred_x0, _ = train_diffusion.training_losses(model_teacher, latents, start_timesteps, model_kwargs=dict(y=uncond_prompt_embeds, mask=y_mask, data_info=data_info), noise=noise)\n\n # Perform \"CFG\" to get x_prev estimate (using the LCM paper's CFG formulation)\n pred_x0 = cond_pred_x0 + w * (cond_pred_x0 - uncond_pred_x0)\n pred_noise = cond_teacher_output + w * (cond_teacher_output - uncond_teacher_output)\n x_prev = solver.ddim_step(pred_x0, pred_noise, index)\n\n # Get target LCM prediction on x_prev, w, c, t_n\n with torch.no_grad():\n with torch.autocast(\"cuda\", enabled=True):\n _, pred_x_0, _ = train_diffusion.training_losses(model_ema, x_prev.float(), timesteps, model_kwargs=dict(y=y, mask=y_mask, data_info=data_info), skip_noise=True)\n\n target = c_skip * x_prev + c_out * pred_x_0\n\n # Calculate loss\n if config.loss_type == \"l2\":\n loss = F.mse_loss(model_pred.float(), target.float(), reduction=\"mean\")\n elif config.loss_type == \"huber\":\n loss = torch.mean(torch.sqrt((model_pred.float() - target.float()) ** 2 + config.huber_c**2) - config.huber_c)\n\n # Backpropagation on the online student model (`model`)\n accelerator.backward(loss)\n if accelerator.sync_gradients:\n grad_norm = accelerator.clip_grad_norm_(model.parameters(), config.gradient_clip)\n optimizer.step()\n lr_scheduler.step()\n optimizer.zero_grad(set_to_none=True)\n\n if accelerator.sync_gradients:\n ema_update(model_ema, model, config.ema_decay)\n\n lr = lr_scheduler.get_last_lr()[0]\n logs = {\"loss\": accelerator.gather(loss).mean().item()}\n if grad_norm is not None:\n logs.update(grad_norm=accelerator.gather(grad_norm).mean().item())\n log_buffer.update(logs)\n if (step + 1) % config.log_interval == 0 or (step + 1) == 1:\n t = (time.time() - last_tic) / config.log_interval\n t_d = data_time_all / config.log_interval\n avg_time = (time.time() - time_start) / (global_step + 1)\n eta = str(datetime.timedelta(seconds=int(avg_time * (total_steps - start_step - global_step - 1))))\n eta_epoch = str(datetime.timedelta(seconds=int(avg_time * (len(train_dataloader) - step - 1))))\n # avg_loss = sum(loss_buffer) / len(loss_buffer)\n log_buffer.average()\n info = f\"Step/Epoch [{(epoch-1)*len(train_dataloader)+step+1}/{epoch}][{step + 1}/{len(train_dataloader)}]:total_eta: {eta}, \" \\\n f\"epoch_eta:{eta_epoch}, time_all:{t:.3f}, time_data:{t_d:.3f}, lr:{lr:.3e}, s:({data_info['resolution'][0][0].item()}, {data_info['resolution'][0][1].item()}), \"\n info += ', '.join([f\"{k}:{v:.4f}\" for k, v in log_buffer.output.items()])\n logger.info(info)\n last_tic = time.time()\n log_buffer.clear()\n data_time_all = 0\n logs.update(lr=lr)\n accelerator.log(logs, step=global_step + start_step)\n\n global_step += 1\n data_time_start= time.time()\n\n synchronize()\n torch.cuda.empty_cache()\n if accelerator.is_main_process:\n # log_validation(model_ema, step, model.device)\n if ((epoch - 1) * len(train_dataloader) + step + 1) % config.save_model_steps == 0:\n os.umask(0o000)\n save_checkpoint(os.path.join(config.work_dir, 'checkpoints'),\n epoch=epoch,\n step=(epoch - 1) * len(train_dataloader) + step + 1,\n model=accelerator.unwrap_model(model),\n model_ema=accelerator.unwrap_model(model_ema),\n optimizer=optimizer,\n lr_scheduler=lr_scheduler\n )\n synchronize()\n\n synchronize()\n if accelerator.is_main_process:\n if epoch % config.save_model_epochs == 0 or epoch == config.num_epochs:\n os.umask(0o000)\n save_checkpoint(os.path.join(config.work_dir, 'checkpoints'),\n epoch=epoch,\n step=(epoch - 1) * len(train_dataloader) + step + 1,\n model=accelerator.unwrap_model(model),\n model_ema=accelerator.unwrap_model(model_ema),\n optimizer=optimizer,\n lr_scheduler=lr_scheduler\n )\n synchronize()\n\n\ndef parse_args():\n parser = argparse.ArgumentParser(description=\"Process some integers.\")\n parser.add_argument(\"config\", type=str, help=\"config\")\n parser.add_argument(\"--cloud\", action='store_true', default=False, help=\"cloud or local machine\")\n parser.add_argument('--work-dir', help='the dir to save logs and models')\n parser.add_argument('--resume-from', help='the dir to resume the training')\n parser.add_argument('--load-from', default=None, help='the dir to load a ckpt for training')\n parser.add_argument('--local-rank', type=int, default=-1)\n parser.add_argument('--local_rank', type=int, default=-1)\n parser.add_argument('--debug', action='store_true')\n args = parser.parse_args()\n return args\n\n\nif __name__ == '__main__':\n args = parse_args()\n config = read_config(args.config)\n if args.work_dir is not None:\n # update configs according to CLI args if args.work_dir is not None\n config.work_dir = args.work_dir\n if args.cloud:\n config.data_root = '/data/data'\n if args.resume_from is not None:\n config.load_from = None\n config.resume_from = dict(\n checkpoint=args.resume_from,\n load_ema=False,\n resume_optimizer=True,\n resume_lr_scheduler=True)\n if args.debug:\n config.log_interval = 1\n config.train_batch_size = 11\n config.valid_num = 100\n config.load_from = None\n\n os.umask(0o000)\n os.makedirs(config.work_dir, exist_ok=True)\n\n init_handler = InitProcessGroupKwargs()\n init_handler.timeout = datetime.timedelta(seconds=5400) # change timeout to avoid a strange NCCL bug\n # Initialize accelerator and tensorboard logging\n if config.use_fsdp:\n init_train = 'FSDP'\n set_fsdp_env()\n fsdp_plugin = FullyShardedDataParallelPlugin(state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),)\n else:\n init_train = 'DDP'\n fsdp_plugin = None\n\n even_batches = True\n if config.multi_scale:\n even_batches=False,\n\n accelerator = Accelerator(\n mixed_precision=config.mixed_precision,\n gradient_accumulation_steps=config.gradient_accumulation_steps,\n log_with=\"tensorboard\",\n project_dir=os.path.join(config.work_dir, \"logs\"),\n fsdp_plugin=fsdp_plugin,\n even_batches=even_batches,\n kwargs_handlers=[init_handler]\n )\n\n logger = get_root_logger(os.path.join(config.work_dir, 'train_log.log'))\n\n config.seed = init_random_seed(config.get('seed', None))\n set_random_seed(config.seed)\n\n if accelerator.is_main_process:\n config.dump(os.path.join(config.work_dir, 'config.py'))\n\n logger.info(f\"Config: \\n{config.pretty_text}\")\n logger.info(f\"World_size: {get_world_size()}, seed: {config.seed}\")\n logger.info(f\"Initializing: {init_train} for training\")\n image_size = config.image_size # @param [256, 512]\n latent_size = int(image_size) // 8\n pred_sigma = getattr(config, 'pred_sigma', True)\n learn_sigma = getattr(config, 'learn_sigma', True) and pred_sigma\n model_kwargs={\"window_block_indexes\": config.window_block_indexes, \"window_size\": config.window_size,\n \"use_rel_pos\": config.use_rel_pos, \"lewei_scale\": config.lewei_scale, 'config':config,\n 'model_max_length': config.model_max_length}\n\n # build models\n train_diffusion = IDDPM(str(config.train_sampling_steps), learn_sigma=learn_sigma, pred_sigma=pred_sigma,\n snr=config.snr_loss, return_startx=True)\n model = build_model(config.model,\n config.grad_checkpointing,\n config.get('fp32_attention', False),\n input_size=latent_size,\n learn_sigma=learn_sigma,\n pred_sigma=pred_sigma,\n **model_kwargs).train()\n logger.info(f\"{model.__class__.__name__} Model Parameters: {sum(p.numel() for p in model.parameters()):,}\")\n\n if config.load_from is not None:\n if args.load_from is not None:\n config.load_from = args.load_from\n missing, unexpected = load_checkpoint(config.load_from, model, load_ema=config.get('load_ema', False))\n logger.warning(f'Missing keys: {missing}')\n logger.warning(f'Unexpected keys: {unexpected}')\n\n model_ema = deepcopy(model).eval()\n model_teacher = deepcopy(model).eval()\n\n if not config.data.load_vae_feat:\n vae = AutoencoderKL.from_pretrained(config.vae_pretrained).cuda()\n\n # prepare for FSDP clip grad norm calculation\n if accelerator.distributed_type == DistributedType.FSDP:\n for m in accelerator._models:\n m.clip_grad_norm_ = types.MethodType(clip_grad_norm_, m)\n\n # build dataloader\n set_data_root(config.data_root)\n dataset = build_dataset(config.data, resolution=image_size, aspect_ratio_type=config.aspect_ratio_type)\n if config.multi_scale:"},"next_line":{"kind":"string","value":" batch_sampler = AspectRatioBatchSampler(sampler=RandomSampler(dataset), dataset=dataset,"},"gold_snippet_index":{"kind":"number","value":18,"string":"18"},"created_at":{"kind":"string","value":"2023-10-12 14:16:33+00:00"},"level":{"kind":"string","value":"24k"}}},{"rowIdx":5699,"cells":{"repo_name":{"kind":"string","value":"NVlabs/EmerNeRF"},"file_path":{"kind":"string","value":"train_emernerf.py"},"context":{"kind":"list like","value":[{"identifier":"metrics","path":"datasets/metrics.py","snippet":"def compute_valid_depth_rmse(prediction: Tensor, target: Tensor) -> float:\ndef compute_psnr(prediction: Tensor, target: Tensor) -> float:\ndef compute_ssim(\n prediction: Union[Tensor, np.ndarray], target: Union[Tensor, np.ndarray]\n) -> float:\ndef compute_scene_flow_metrics(pred: Tensor, labels: Tensor):\ndef knn_predict(\n queries: Tensor,\n memory_bank: Tensor,\n memory_labels: Tensor,\n n_classes: int,\n knn_k: int = 1,\n knn_t: float = 0.1,\n) -> Tensor:\ndef knn_predict(\n queries: Tensor,\n memory_bank: Tensor,\n memory_labels: Tensor,\n n_classes: int,\n knn_k: int = 1,\n knn_t: float = 0.1,\n similarity: str = \"cosine\",\n) -> Tensor:\ndef collect_centroids(\n train_indices: List[int],\n dataset, # a WaymoDataset object\n model: RadianceField,\n device: torch.device,\n):\ndef eval_few_shot_occ(\n test_indices: List[int],\n dataset, # a WaymoDataset object\n model: RadianceField,\n device: torch.device,\n centroids_bank: Tensor,\n label_bank: Tensor,\n):\n EPE3D = torch.mean(l2_norm).item() # Mean absolute distance error"},{"identifier":"SceneDataset","path":"datasets/base/scene_dataset.py","snippet":"class SceneDataset(abc.ABC):\n \"\"\"\n Base class for scene dataset.\n \"\"\"\n\n data_cfg: OmegaConf = None\n pixel_source: ScenePixelSource = None\n lidar_source: SceneLidarSource = None\n # training and testing indices are indices into the full dataset\n # train_indices are img indices, so the length is num_cams * num_timesteps\n train_indices: List[int] = None\n test_indices: List[int] = None\n # train_timesteps are timesteps, so the length is num_timesteps (len(unique_timesteps))\n train_timesteps: Tensor = None\n test_timesteps: Tensor = None\n\n # dataset wrappers\n # full: includes all data\n full_pixel_set: SplitWrapper = None\n full_lidar_set: SplitWrapper = None\n # train: includes only training data\n train_pixel_set: SplitWrapper = None\n train_lidar_set: SplitWrapper = None\n # test: includes only testing data\n test_pixel_set: SplitWrapper = None\n test_lidar_set: SplitWrapper = None\n\n def __init__(\n self,\n data_config: OmegaConf,\n ):\n super().__init__()\n self.data_cfg = data_config\n\n @abc.abstractmethod\n def build_data_source(self):\n \"\"\"\n Create the data source for the dataset.\n \"\"\"\n raise NotImplementedError\n\n @abc.abstractmethod\n def build_split_wrapper(self):\n \"\"\"\n Makes each data source as a Pytorch Dataset.\n \"\"\"\n raise NotImplementedError\n\n @abc.abstractmethod\n def split_train_test(self):\n raise NotImplementedError\n\n def get_aabb(self) -> Tensor:\n if self.lidar_source is not None:\n aabb = self.lidar_source.get_aabb()\n else:\n aabb = self.pixel_source.get_aabb()\n return aabb\n\n @property\n def num_cams(self) -> int:\n return self.pixel_source.num_cams\n\n @property\n def scene_idx(self) -> int:\n return self.data_cfg.scene_idx\n\n @property\n def num_img_timesteps(self) -> int:\n return self.pixel_source.num_timesteps\n\n @property\n def num_lidar_timesteps(self) -> int:\n if self.lidar_source is None:\n logger.warning(\"No lidar source, returning num_img_timesteps\")\n return self.num_img_timesteps\n return self.lidar_source.num_timesteps\n\n @property\n def num_train_timesteps(self) -> int:\n return len(self.train_timesteps)\n\n @property\n def num_test_timesteps(self) -> int:\n return len(self.test_timesteps)\n\n @property\n def unique_normalized_training_timestamps(self) -> Tensor:\n return self.pixel_source.unique_normalized_timestamps[self.train_timesteps]\n\n @property\n def device(self):\n return self.data_cfg.preload_device"},{"identifier":"DensityField","path":"radiance_fields/radiance_field.py","snippet":"class DensityField(nn.Module):\n def __init__(\n self,\n xyz_encoder: HashEncoder,\n aabb: Union[Tensor, List[float]] = [[-1.0, -1.0, -1.0, 1.0, 1.0, 1.0]],\n num_dims: int = 3,\n density_activation: Callable = lambda x: trunc_exp(x - 1),\n unbounded: bool = False,\n base_mlp_layer_width: int = 64,\n ) -> None:\n super().__init__()\n if not isinstance(aabb, Tensor):\n aabb = torch.tensor(aabb, dtype=torch.float32)\n self.register_buffer(\"aabb\", aabb)\n self.num_dims = num_dims\n self.density_activation = density_activation\n self.unbounded = unbounded\n self.xyz_encoder = xyz_encoder\n\n # density head\n self.base_mlp = nn.Sequential(\n nn.Linear(self.xyz_encoder.n_output_dims, base_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(base_mlp_layer_width, 1),\n )\n\n @property\n def device(self) -> torch.device:\n return self.aabb.device\n\n def set_aabb(self, aabb: Union[Tensor, List[float]]) -> None:\n if not isinstance(aabb, Tensor):\n aabb = torch.tensor(aabb, dtype=torch.float32)\n logger.info(f\"Set propnet aabb from {self.aabb} to {aabb}\")\n self.aabb.copy_(aabb)\n self.aabb = self.aabb.to(self.device)\n\n def forward(\n self, positions: Tensor, data_dict: Dict[str, Tensor] = None\n ) -> Dict[str, Tensor]:\n if self.unbounded:\n # use infinte norm to contract the positions for cuboid aabb\n positions = contract(positions, self.aabb, ord=float(\"inf\"))\n else:\n aabb_min, aabb_max = torch.split(self.aabb, 3, dim=-1)\n positions = (positions - aabb_min) / (aabb_max - aabb_min)\n selector = ((positions > 0.0) & (positions < 1.0)).all(dim=-1).to(positions)\n positions = positions * selector.unsqueeze(-1)\n xyz_encoding = self.xyz_encoder(positions.view(-1, self.num_dims))\n density_before_activation = self.base_mlp(xyz_encoding).view(\n list(positions.shape[:-1]) + [-1]\n )\n density = self.density_activation(density_before_activation)\n return {\"density\": density}"},{"identifier":"RadianceField","path":"radiance_fields/radiance_field.py","snippet":"class RadianceField(nn.Module):\n def __init__(\n self,\n xyz_encoder: HashEncoder,\n dynamic_xyz_encoder: Optional[HashEncoder] = None,\n flow_xyz_encoder: Optional[HashEncoder] = None,\n aabb: Union[Tensor, List[float]] = [-1, -1, -1, 1, 1, 1],\n num_dims: int = 3,\n density_activation: Callable = lambda x: trunc_exp(x - 1),\n unbounded: bool = True,\n geometry_feature_dim: int = 15,\n base_mlp_layer_width: int = 64,\n head_mlp_layer_width: int = 64,\n enable_cam_embedding: bool = False,\n enable_img_embedding: bool = False,\n num_cams: int = 3,\n appearance_embedding_dim: int = 16,\n semantic_feature_dim: int = 64,\n feature_mlp_layer_width: int = 256,\n feature_embedding_dim: int = 768,\n enable_sky_head: bool = False,\n enable_shadow_head: bool = False,\n enable_feature_head: bool = False,\n num_train_timesteps: int = 0,\n interpolate_xyz_encoding: bool = False,\n enable_learnable_pe: bool = True,\n enable_temporal_interpolation: bool = False,\n ) -> None:\n super().__init__()\n # scene properties\n if not isinstance(aabb, Tensor):\n aabb = torch.tensor(aabb, dtype=torch.float32)\n self.register_buffer(\"aabb\", aabb)\n self.unbounded = unbounded\n self.num_cams = num_cams\n self.num_dims = num_dims\n self.density_activation = density_activation\n\n # appearance embedding\n self.enable_cam_embedding = enable_cam_embedding\n self.enable_img_embedding = enable_img_embedding\n self.appearance_embedding_dim = appearance_embedding_dim\n\n self.geometry_feature_dim = geometry_feature_dim\n # add semantic feature dim if feature head is enabled\n if not enable_feature_head:\n semantic_feature_dim = 0\n self.semantic_feature_dim = semantic_feature_dim\n\n # note: we use very conservative default values for mlps\n # usually you want to use larger ones\n\n # ======== Static Field ======== #\n self.xyz_encoder = xyz_encoder\n self.base_mlp = nn.Sequential(\n nn.Linear(self.xyz_encoder.n_output_dims, base_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(\n base_mlp_layer_width, geometry_feature_dim + semantic_feature_dim\n ),\n )\n\n # ======== Dynamic Field ======== #\n self.interpolate_xyz_encoding = interpolate_xyz_encoding\n self.dynamic_xyz_encoder = dynamic_xyz_encoder\n self.enable_temporal_interpolation = enable_temporal_interpolation\n if self.dynamic_xyz_encoder is not None:\n # for temporal interpolation\n self.register_buffer(\"training_timesteps\", torch.zeros(num_train_timesteps))\n self.dynamic_base_mlp = nn.Sequential(\n nn.Linear(self.dynamic_xyz_encoder.n_output_dims, base_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(\n base_mlp_layer_width,\n geometry_feature_dim + semantic_feature_dim,\n ),\n )\n\n # ======== Flow Field ======== #\n self.flow_xyz_encoder = flow_xyz_encoder\n if self.flow_xyz_encoder is not None:\n self.flow_mlp = nn.Sequential(\n nn.Linear(\n self.flow_xyz_encoder.n_output_dims,\n base_mlp_layer_width,\n ),\n nn.ReLU(),\n nn.Linear(base_mlp_layer_width, base_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(base_mlp_layer_width, 6), # 3 for forward, 3 for backward\n # no activation function for flow\n )\n\n # appearance embedding\n if self.enable_cam_embedding:\n # per-camera embedding\n self.appearance_embedding = nn.Embedding(num_cams, appearance_embedding_dim)\n elif self.enable_img_embedding:\n # per-image embedding\n self.appearance_embedding = nn.Embedding(\n num_train_timesteps * num_cams, appearance_embedding_dim\n )\n else:\n self.appearance_embedding = None\n\n # direction encoding\n self.direction_encoding = SinusoidalEncoder(\n n_input_dims=3, min_deg=0, max_deg=4\n )\n\n # ======== Color Head ======== #\n self.rgb_head = MLP(\n in_dims=geometry_feature_dim\n + self.direction_encoding.n_output_dims\n + (\n appearance_embedding_dim\n if self.enable_cam_embedding or self.enable_img_embedding\n else 0 # 2 or 0?\n ),\n out_dims=3,\n num_layers=3,\n hidden_dims=head_mlp_layer_width,\n skip_connections=[1],\n )\n\n # ======== Shadow Head ======== #\n self.enable_shadow_head = enable_shadow_head\n if self.enable_shadow_head:\n self.shadow_head = nn.Sequential(\n nn.Linear(geometry_feature_dim, base_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(base_mlp_layer_width, 1),\n nn.Sigmoid(),\n )\n\n # ======== Sky Head ======== #\n self.enable_sky_head = enable_sky_head\n if self.enable_sky_head:\n self.sky_head = MLP(\n in_dims=self.direction_encoding.n_output_dims\n + (\n appearance_embedding_dim\n if self.enable_cam_embedding or self.enable_img_embedding\n else 0\n ),\n out_dims=3,\n num_layers=3,\n hidden_dims=head_mlp_layer_width,\n skip_connections=[1],\n )\n if enable_feature_head:\n # feature sky head\n self.dino_sky_head = nn.Sequential(\n # TODO: remove appearance embedding from dino sky head\n nn.Linear(\n self.direction_encoding.n_output_dims\n + (\n appearance_embedding_dim\n if self.enable_cam_embedding or self.enable_img_embedding\n else 0\n ),\n feature_mlp_layer_width,\n ),\n nn.ReLU(),\n nn.Linear(feature_mlp_layer_width, feature_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(feature_mlp_layer_width, feature_embedding_dim),\n )\n\n # ======== Feature Head ======== #\n self.enable_feature_head = enable_feature_head\n if self.enable_feature_head:\n self.dino_head = nn.Sequential(\n nn.Linear(semantic_feature_dim, feature_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(feature_mlp_layer_width, feature_mlp_layer_width),\n nn.ReLU(),\n nn.Linear(feature_mlp_layer_width, feature_embedding_dim),\n )\n # placeholders for visualization, will be registered when available\n self.register_buffer(\n \"feats_reduction_mat\", torch.zeros(feature_embedding_dim, 3)\n )\n self.register_buffer(\"feat_color_min\", torch.zeros(3, dtype=torch.float32))\n self.register_buffer(\"feat_color_max\", torch.ones(3, dtype=torch.float32))\n\n # positional embedding (PE) decomposition\n self.enable_learnable_pe = enable_learnable_pe\n if self.enable_learnable_pe:\n # globally-shared low-resolution learnable PE map\n self.learnable_pe_map = nn.Parameter(\n 0.05 * torch.randn(1, feature_embedding_dim // 2, 80, 120),\n requires_grad=True,\n )\n # a PE head to decode PE features\n self.pe_head = nn.Sequential(\n nn.Linear(feature_embedding_dim // 2, feature_embedding_dim),\n )\n\n def register_normalized_training_timesteps(\n self, normalized_timesteps: Tensor, time_diff: float = None\n ) -> None:\n \"\"\"\n register normalized timesteps for temporal interpolation\n\n Args:\n normalized_timesteps (Tensor): normalized timesteps in [0, 1]\n time_diff (float, optional): time difference between two consecutive timesteps. Defaults to None.\n \"\"\"\n if self.dynamic_xyz_encoder is not None:\n # register timesteps for temporal interpolation\n self.training_timesteps.copy_(normalized_timesteps)\n self.training_timesteps = self.training_timesteps.to(self.device)\n if time_diff is not None:\n # use the provided time difference if available\n self.time_diff = time_diff\n else:\n if len(self.training_timesteps) > 1:\n # otherwise, compute the time difference from the provided timesteps\n # it's important to make sure the provided timesteps are consecutive\n self.time_diff = (\n self.training_timesteps[1] - self.training_timesteps[0]\n )\n else:\n self.time_diff = 0\n\n def set_aabb(self, aabb: Union[Tensor, List[float]]) -> None:\n \"\"\"\n register aabb for scene space\n \"\"\"\n if not isinstance(aabb, Tensor):\n aabb = torch.tensor(aabb, dtype=torch.float32)\n logger.info(f\"Set aabb from {self.aabb} to {aabb}\")\n self.aabb.copy_(aabb)\n self.aabb = self.aabb.to(self.device)\n\n def register_feats_reduction_mat(\n self,\n feats_reduction_mat: Tensor,\n feat_color_min: Tensor,\n feat_color_max: Tensor,\n ) -> None:\n \"\"\"\n A placeholder for registering the PCA reduction matrix and min/max values for visualization.\n You may not want to compute PCA reduction matrix every time from the dataset.\n \"\"\"\n # for visualization\n self.feats_reduction_mat.copy_(feats_reduction_mat)\n self.feat_color_min.copy_(feat_color_min)\n self.feat_color_max.copy_(feat_color_max)\n self.feats_reduction_mat = self.feats_reduction_mat.to(self.device)\n self.feat_color_min = self.feat_color_min.to(self.device)\n self.feat_color_max = self.feat_color_max.to(self.device)\n\n @property\n def device(self) -> torch.device:\n return self.aabb.device\n\n def contract_points(\n self,\n positions: Tensor,\n ) -> Tensor:\n \"\"\"\n contract [-inf, inf] points to the range [0, 1] for hash encoding\n\n Returns:\n normed_positions: [..., 3] in [0, 1]\n \"\"\"\n if self.unbounded:\n # use infinte norm to contract the positions for cuboid aabb\n normed_positions = contract(positions, self.aabb, ord=float(\"inf\"))\n else:\n aabb_min, aabb_max = torch.split(self.aabb, 3, dim=-1)\n normed_positions = (positions - aabb_min) / (aabb_max - aabb_min)\n selector = (\n ((normed_positions > 0.0) & (normed_positions < 1.0))\n .all(dim=-1)\n .to(positions)\n )\n normed_positions = normed_positions * selector.unsqueeze(-1)\n return normed_positions\n\n def forward_static_hash(\n self,\n positions: Tensor,\n ) -> Tensor:\n \"\"\"\n forward pass for static hash encoding\n\n Returns:\n encoded_features: [..., geometry_feature_dim + (semantic_feature_dim)]\n normed_positions: [..., 3] in [0, 1]\n \"\"\"\n normed_positions = self.contract_points(positions)\n xyz_encoding = self.xyz_encoder(normed_positions.view(-1, self.num_dims))\n encoded_features = self.base_mlp(xyz_encoding).view(\n list(normed_positions.shape[:-1]) + [-1]\n )\n return encoded_features, normed_positions\n\n def forward_dynamic_hash(\n self,\n normed_positions: Tensor,\n normed_timestamps: Tensor,\n return_hash_encodings: bool = False,\n ) -> Union[Tuple[Tensor, Tensor], Tensor]:\n \"\"\"\n forward pass for dynamic hash encoding\n\n Returns:\n encoded_dynamic_feats: [..., geometry_feature_dim + (semantic_feature_dim)]\n dynamic_xyz_encoding: [..., n_output_dims] (optional)\n \"\"\"\n if normed_timestamps.shape[-1] != 1:\n normed_timestamps = normed_timestamps.unsqueeze(-1)\n # To be fixed.\n # if self.training or not self.enable_temporal_interpolation:\n if True:\n temporal_positions = torch.cat(\n [normed_positions, normed_timestamps], dim=-1\n )\n dynamic_xyz_encoding = self.dynamic_xyz_encoder(\n temporal_positions.view(-1, self.num_dims + 1)\n ).view(list(temporal_positions.shape[:-1]) + [-1])\n encoded_dynamic_feats = self.dynamic_base_mlp(dynamic_xyz_encoding)\n else:\n encoded_dynamic_feats = temporal_interpolation(\n normed_timestamps,\n self.training_timesteps,\n normed_positions,\n self.dynamic_xyz_encoder,\n self.dynamic_base_mlp,\n interpolate_xyz_encoding=self.interpolate_xyz_encoding,\n )\n if return_hash_encodings:\n return encoded_dynamic_feats, dynamic_xyz_encoding\n else:\n return encoded_dynamic_feats\n\n def forward_flow_hash(\n self,\n normed_positions: Tensor,\n normed_timestamps: Tensor,\n ) -> Tuple[Tensor, Tensor]:\n \"\"\"\n forward pass for flow hash encoding\n\n Returns:\n flow: [..., 6] (forward_flow, backward_flow)\n \"\"\"\n if normed_timestamps.shape[-1] != 1:\n normed_timestamps = normed_timestamps.unsqueeze(-1)\n if self.training or not self.enable_temporal_interpolation:\n temporal_positions = torch.cat(\n [normed_positions, normed_timestamps], dim=-1\n )\n flow_xyz_encoding = self.flow_xyz_encoder(\n temporal_positions.view(-1, self.num_dims + 1)\n ).view(list(temporal_positions.shape[:-1]) + [-1])\n flow = self.flow_mlp(flow_xyz_encoding)\n else:\n flow = temporal_interpolation(\n normed_timestamps,\n self.training_timesteps,\n normed_positions,\n self.flow_xyz_encoder,\n self.flow_mlp,\n interpolate_xyz_encoding=True,\n )\n return flow\n\n def forward(\n self,\n positions: Tensor,\n directions: Tensor = None,\n data_dict: Dict[str, Tensor] = {},\n return_density_only: bool = False,\n combine_static_dynamic: bool = False,\n query_feature_head: bool = True,\n query_pe_head: bool = True,\n ) -> Dict[str, Tensor]:\n \"\"\"\n Args:\n positions: [..., 3]\n directions: [..., 3]\n data_dict: a dictionary containing additional data\n return_density_only: if True, only return density without querying other heads\n combine_static_dynamic: if True, combine static and dynamic predictions based on static and dynamic density\n in addition to returning separate results for static and dynamic fields\n query_feature_head: if True, query feature head\n query_pe_head: if True, query PE head. Disable this if we want to directly query 3D features.\n Returns:\n results_dict: a dictionary containing everything\n \"\"\"\n results_dict = {}\n # forward static branch\n encoded_features, normed_positions = self.forward_static_hash(positions)\n geo_feats, semantic_feats = torch.split(\n encoded_features,\n [self.geometry_feature_dim, self.semantic_feature_dim],\n dim=-1,\n )\n static_density = self.density_activation(geo_feats[..., 0])\n\n has_timestamps = (\n \"normed_timestamps\" in data_dict or \"lidar_normed_timestamps\" in data_dict\n )\n if self.dynamic_xyz_encoder is not None and has_timestamps:\n # forward dynamic branch\n if \"normed_timestamps\" in data_dict:\n normed_timestamps = data_dict[\"normed_timestamps\"]\n elif \"lidar_normed_timestamps\" in data_dict:\n # we use `lidar_` prefix as an identifier to skip querying other heads\n normed_timestamps = data_dict[\"lidar_normed_timestamps\"]\n dynamic_feats, dynamic_hash_encodings = self.forward_dynamic_hash(\n normed_positions, normed_timestamps, return_hash_encodings=True\n )\n if self.flow_xyz_encoder is not None:\n flow = self.forward_flow_hash(normed_positions, normed_timestamps)\n forward_flow, backward_flow = flow[..., :3], flow[..., 3:]\n results_dict[\"forward_flow\"] = forward_flow\n results_dict[\"backward_flow\"] = backward_flow\n temporal_aggregation_results = self.temporal_aggregation(\n positions,\n normed_timestamps,\n forward_flow,\n backward_flow,\n dynamic_feats,\n )\n # overwrite dynamic feats using temporal aggregation results\n dynamic_feats = temporal_aggregation_results[\"dynamic_feats\"]\n # to be studied\n temporal_aggregation_results[\n \"current_dynamic_hash_encodings\"\n ] = dynamic_hash_encodings\n results_dict.update(temporal_aggregation_results)\n (dynamic_geo_feats, dynamic_semantic_feats,) = torch.split(\n dynamic_feats,\n [self.geometry_feature_dim, self.semantic_feature_dim],\n dim=-1,\n )\n dynamic_density = self.density_activation(dynamic_geo_feats[..., 0])\n # blend static and dynamic density to get the final density\n density = static_density + dynamic_density\n results_dict.update(\n {\n \"density\": density,\n \"static_density\": static_density,\n \"dynamic_density\": dynamic_density,\n }\n )\n if return_density_only:\n # skip querying other heads\n return results_dict\n\n if directions is not None:\n rgb_results = self.query_rgb(\n directions, geo_feats, dynamic_geo_feats, data_dict=data_dict\n )\n results_dict[\"dynamic_rgb\"] = rgb_results[\"dynamic_rgb\"]\n results_dict[\"static_rgb\"] = rgb_results[\"rgb\"]\n if combine_static_dynamic:\n static_ratio = static_density / (density + 1e-6)\n dynamic_ratio = dynamic_density / (density + 1e-6)\n results_dict[\"rgb\"] = (\n static_ratio[..., None] * results_dict[\"static_rgb\"]\n + dynamic_ratio[..., None] * results_dict[\"dynamic_rgb\"]\n )\n if self.enable_shadow_head:\n shadow_ratio = self.shadow_head(dynamic_geo_feats)\n results_dict[\"shadow_ratio\"] = shadow_ratio\n if combine_static_dynamic and \"rgb\" in results_dict:\n results_dict[\"rgb\"] = (\n static_ratio[..., None]\n * results_dict[\"rgb\"]\n * (1 - shadow_ratio)\n + dynamic_ratio[..., None] * results_dict[\"dynamic_rgb\"]\n )\n else:\n # if no dynamic branch, use static density\n results_dict[\"density\"] = static_density\n if return_density_only:\n # skip querying other heads\n return results_dict\n if directions is not None:\n rgb_results = self.query_rgb(directions, geo_feats, data_dict=data_dict)\n results_dict[\"rgb\"] = rgb_results[\"rgb\"]\n\n if self.enable_feature_head and query_feature_head:\n if self.enable_learnable_pe and query_pe_head:\n learnable_pe_map = (\n F.grid_sample(\n self.learnable_pe_map,\n # assume pixel coords have been normalize to [-1, 1]\n data_dict[\"pixel_coords\"].reshape(1, 1, -1, 2) * 2 - 1,\n align_corners=False, # didn't test with True\n mode=\"bilinear\", # didn't test with other modes\n )\n .squeeze(2)\n .squeeze(0)\n .permute(1, 0)\n )\n dino_pe = self.pe_head(learnable_pe_map)\n results_dict[\"dino_pe\"] = dino_pe\n dino_feats = self.dino_head(semantic_feats)\n\n if self.dynamic_xyz_encoder is not None and has_timestamps:\n dynamic_dino_feats = self.dino_head(dynamic_semantic_feats)\n results_dict[\"static_dino_feat\"] = dino_feats\n results_dict[\"dynamic_dino_feat\"] = dynamic_dino_feats\n if combine_static_dynamic:\n static_ratio = static_density / (density + 1e-6)\n dynamic_ratio = dynamic_density / (density + 1e-6)\n results_dict[\"dino_feat\"] = (\n static_ratio[..., None] * dino_feats\n + dynamic_ratio[..., None] * dynamic_dino_feats\n )\n else:\n results_dict[\"dino_feat\"] = dino_feats\n\n # query sky if not in lidar mode\n if (\n self.enable_sky_head\n and \"lidar_origin\" not in data_dict\n and directions is not None\n ):\n directions = directions[:, 0]\n reduced_data_dict = {k: v[:, 0] for k, v in data_dict.items()}\n sky_results = self.query_sky(directions, data_dict=reduced_data_dict)\n results_dict.update(sky_results)\n\n return results_dict\n\n def temporal_aggregation(\n self,\n positions: Tensor, # current world coordinates\n normed_timestamps: Tensor, # current normalized timestamps\n forward_flow: Tensor,\n backward_flow: Tensor,\n dynamic_feats: Tensor,\n ) -> Tensor:\n \"\"\"\n temporal aggregation for dynamic features\n Eq. (8) in the emernerf paper\n \"\"\"\n if normed_timestamps.shape[-1] != 1:\n normed_timestamps = normed_timestamps.unsqueeze(-1)\n if self.training:\n noise = torch.rand_like(forward_flow)[..., 0:1]\n else:\n noise = torch.ones_like(forward_flow)[..., 0:1]\n # forward and backward warped positions\n forward_warped_positions = self.contract_points(\n positions + forward_flow * noise\n )\n backward_warped_positions = self.contract_points(\n positions + backward_flow * noise\n )\n # forward and backward warped timestamps\n forward_warped_time = torch.clamp(\n normed_timestamps + self.time_diff * noise, 0, 1.0\n )\n backward_warped_time = torch.clamp(\n normed_timestamps - self.time_diff * noise, 0, 1.0\n )\n (\n forward_dynamic_feats,\n forward_dynamic_hash_encodings,\n ) = self.forward_dynamic_hash(\n forward_warped_positions,\n forward_warped_time,\n return_hash_encodings=True,\n )\n (\n backward_dynamic_feats,\n backward_dynamic_hash_encodings,\n ) = self.forward_dynamic_hash(\n backward_warped_positions,\n backward_warped_time,\n return_hash_encodings=True,\n )\n forward_pred_flow = self.forward_flow_hash(\n forward_warped_positions,\n forward_warped_time,\n )\n backward_pred_flow = self.forward_flow_hash(\n backward_warped_positions,\n backward_warped_time,\n )\n # simple weighted sum\n aggregated_dynamic_feats = (\n dynamic_feats + 0.5 * forward_dynamic_feats + 0.5 * backward_dynamic_feats\n ) / 2.0\n return {\n \"dynamic_feats\": aggregated_dynamic_feats,\n \"forward_pred_backward_flow\": forward_pred_flow[..., 3:],\n \"backward_pred_forward_flow\": backward_pred_flow[..., :3],\n # to be studied\n \"forward_dynamic_hash_encodings\": forward_dynamic_hash_encodings,\n \"backward_dynamic_hash_encodings\": backward_dynamic_hash_encodings,\n }\n\n def query_rgb(\n self,\n directions: Tensor,\n geo_feats: Tensor,\n dynamic_geo_feats: Tensor = None,\n data_dict: Dict[str, Tensor] = None,\n ) -> Tensor:\n directions = (directions + 1.0) / 2.0 # do we need this?\n h = self.direction_encoding(directions.reshape(-1, directions.shape[-1])).view(\n *directions.shape[:-1], -1\n )\n if self.enable_cam_embedding or self.enable_img_embedding:\n if \"cam_idx\" in data_dict and self.enable_cam_embedding:\n appearance_embedding = self.appearance_embedding(data_dict[\"cam_idx\"])\n elif \"img_idx\" in data_dict and self.enable_img_embedding:\n appearance_embedding = self.appearance_embedding(data_dict[\"img_idx\"])\n else:\n # use mean appearance embedding\n # print(\"using mean appearance embedding\")\n appearance_embedding = torch.ones(\n (*directions.shape[:-1], self.appearance_embedding_dim),\n device=directions.device,\n ) * self.appearance_embedding.weight.mean(dim=0)\n h = torch.cat([h, appearance_embedding], dim=-1)\n\n rgb = self.rgb_head(torch.cat([h, geo_feats], dim=-1))\n rgb = F.sigmoid(rgb)\n results = {\"rgb\": rgb}\n\n if self.dynamic_xyz_encoder is not None:\n assert (\n dynamic_geo_feats is not None\n ), \"Dynamic geometry features are not provided.\"\n dynamic_rgb = self.rgb_head(torch.cat([h, dynamic_geo_feats], dim=-1))\n dynamic_rgb = F.sigmoid(dynamic_rgb)\n results[\"dynamic_rgb\"] = dynamic_rgb\n return results\n\n def query_sky(\n self, directions: Tensor, data_dict: Dict[str, Tensor] = None\n ) -> Dict[str, Tensor]:\n if len(directions.shape) == 2:\n dd = self.direction_encoding(directions).to(directions)\n else:\n dd = self.direction_encoding(directions[:, 0]).to(directions)\n if self.enable_cam_embedding or self.enable_img_embedding:\n # optionally add appearance embedding\n if \"cam_idx\" in data_dict and self.enable_cam_embedding:\n appearance_embedding = self.appearance_embedding(data_dict[\"cam_idx\"])\n elif \"img_idx\" in data_dict and self.enable_img_embedding:\n appearance_embedding = self.appearance_embedding(data_dict[\"img_idx\"])\n else:\n # use mean appearance embedding\n appearance_embedding = torch.ones(\n (*directions.shape[:-1], self.appearance_embedding_dim),\n device=directions.device,\n ) * self.appearance_embedding.weight.mean(dim=0)\n dd = torch.cat([dd, appearance_embedding], dim=-1)\n rgb_sky = self.sky_head(dd).to(directions)\n rgb_sky = F.sigmoid(rgb_sky)\n results = {\"rgb_sky\": rgb_sky}\n if self.enable_feature_head:\n self.dino_sky_head(dd).to(directions)\n results[\"dino_sky_feat\"] = self.dino_sky_head(dd).to(directions)\n return results\n\n def query_flow(\n self, positions: Tensor, normed_timestamps: Tensor, query_density: bool = True\n ) -> Dict[str, Tensor]:\n \"\"\"\n query flow field\n \"\"\"\n normed_positions = self.contract_points(positions)\n flow = self.forward_flow_hash(normed_positions, normed_timestamps)\n results = {\n \"forward_flow\": flow[..., :3],\n \"backward_flow\": flow[..., 3:],\n }\n if query_density:\n # it's important to filter valid flows based on a dynamic density threshold.\n # flows are valid only if they are on dynamic points.\n dynamic_feats = self.forward_dynamic_hash(\n normed_positions, normed_timestamps\n )\n (dynamic_geo_feats, _,) = torch.split(\n dynamic_feats,\n [self.geometry_feature_dim, self.semantic_feature_dim],\n dim=-1,\n )\n dynamic_density = self.density_activation(dynamic_geo_feats[..., 0])\n results[\"dynamic_density\"] = dynamic_density\n return results\n\n def query_attributes(\n self,\n positions: Tensor,\n normed_timestamps: Tensor = None,\n query_feature_head: bool = True,\n ):\n \"\"\"\n query attributes (density, dino features, etc.)\n \"\"\"\n results_dict = {}\n encoded_features, normed_positions = self.forward_static_hash(positions)\n geo_feats, semantic_feats = torch.split(\n encoded_features,\n [self.geometry_feature_dim, self.semantic_feature_dim],\n dim=-1,\n )\n static_density = self.density_activation(geo_feats[..., 0])\n if self.dynamic_xyz_encoder is not None and normed_timestamps is not None:\n dynamic_feats, dynamic_hash_encodings = self.forward_dynamic_hash(\n normed_positions, normed_timestamps, return_hash_encodings=True\n )\n if self.flow_xyz_encoder is not None:\n flow = self.forward_flow_hash(normed_positions, normed_timestamps)\n forward_flow = flow[..., :3]\n backward_flow = flow[..., 3:]\n results_dict[\"forward_flow\"] = forward_flow\n results_dict[\"backward_flow\"] = backward_flow\n temporal_aggregation_results = self.temporal_aggregation(\n positions,\n normed_timestamps,\n forward_flow,\n backward_flow,\n dynamic_feats,\n )\n dynamic_feats = temporal_aggregation_results[\"dynamic_feats\"]\n temporal_aggregation_results[\n \"current_dynamic_hash_encodings\"\n ] = dynamic_hash_encodings\n results_dict.update(temporal_aggregation_results)\n\n (dynamic_geo_feats, dynamic_semantic_feats,) = torch.split(\n dynamic_feats,\n [self.geometry_feature_dim, self.semantic_feature_dim],\n dim=-1,\n )\n dynamic_density = self.density_activation(dynamic_geo_feats[..., 0])\n density = static_density + dynamic_density\n results_dict.update(\n {\n \"density\": density,\n \"static_density\": static_density,\n \"dynamic_density\": dynamic_density,\n # \"occupancy\": occupancy,\n }\n )\n else:\n results_dict[\"density\"] = static_density\n if self.enable_feature_head and query_feature_head:\n # query on demand\n dino_feats = self.dino_head(semantic_feats)\n if self.dynamic_xyz_encoder is not None and normed_timestamps is not None:\n dynamic_dino_feats = self.dino_head(dynamic_semantic_feats)\n results_dict[\"static_dino_feat\"] = dino_feats\n results_dict[\"dynamic_dino_feat\"] = dynamic_dino_feats\n results_dict[\"dino_feat\"] = (\n static_density.unsqueeze(-1) * dino_feats\n + dynamic_density.unsqueeze(-1) * dynamic_dino_feats\n ) / (density.unsqueeze(-1) + 1e-6)\n else:\n results_dict[\"dino_feat\"] = dino_feats\n return results_dict"},{"identifier":"render_rays","path":"radiance_fields/render_utils.py","snippet":"def render_rays(\n # scene\n radiance_field: RadianceField = None,\n proposal_estimator: PropNetEstimator = None,\n proposal_networks: Optional[List[DensityField]] = None,\n data_dict: Dict[str, Tensor] = None,\n cfg: OmegaConf = None,\n proposal_requires_grad: bool = False,\n return_decomposition: bool = False,\n prefix=\"\",\n) -> Dict[str, Tensor]:\n \"\"\"Render some attributes of the scene along the rays.\"\"\"\n # reshape data_dict to be (num_rays, ...)\n rays_shape = data_dict[prefix + \"origins\"].shape\n if len(rays_shape) == 3:\n height, width, _ = rays_shape\n num_rays = height * width\n reshaped_data_dict = {}\n for k, v in data_dict.items():\n reshaped_data_dict[k] = v.reshape(num_rays, -1).squeeze()\n else:\n num_rays, _ = rays_shape\n reshaped_data_dict = data_dict.copy()\n\n def prop_sigma_fn(t_starts, t_ends, proposal_network):\n # query propsal networks for density\n t_origins = chunk_data_dict[prefix + \"origins\"][..., None, :]\n t_dirs = chunk_data_dict[prefix + \"viewdirs\"][..., None, :]\n positions = t_origins + t_dirs * (t_starts + t_ends)[..., None] / 2.0\n sub_dict = {\n k: v[..., None].repeat_interleave(t_starts.shape[-1], dim=-1)\n for k, v in chunk_data_dict.items()\n if \"time\" in k\n }\n return proposal_network(positions, sub_dict)\n\n def query_fn(t_starts, t_ends):\n # query the final nerf model for density and other information along the rays\n t_origins = chunk_data_dict[prefix + \"origins\"][..., None, :]\n t_dirs = chunk_data_dict[prefix + \"viewdirs\"][..., None, :].repeat_interleave(\n t_starts.shape[-1], dim=-2\n )\n sub_dict = {\n k: v[..., None].repeat_interleave(t_starts.shape[-1], dim=-1)\n for k, v in chunk_data_dict.items()\n if k not in [prefix + \"viewdirs\", prefix + \"origins\", \"pixel_coords\"]\n }\n sub_dict[\"t_starts\"], sub_dict[\"t_ends\"] = t_starts, t_ends\n if \"pixel_coords\" in chunk_data_dict:\n # use this for positional embedding decomposition\n sub_dict[\"pixel_coords\"] = chunk_data_dict[\"pixel_coords\"]\n positions = t_origins + t_dirs * (t_starts + t_ends)[..., None] / 2.0\n # return density only when rendering lidar, i.e., no rgb or sky or features are rendered\n results_dict: Dict[str, Tensor] = radiance_field(\n positions, t_dirs, sub_dict, return_density_only=(prefix == \"lidar_\")\n )\n results_dict[\"density\"] = results_dict[\"density\"].squeeze(-1)\n return results_dict\n\n results = []\n chunk = 2**24 if radiance_field.training else cfg.render.render_chunk_size\n for i in range(0, num_rays, chunk):\n chunk_data_dict = {k: v[i : i + chunk] for k, v in reshaped_data_dict.items()}\n assert proposal_networks is not None, \"proposal_networks is required.\"\n # obtain proposed intervals\n t_starts, t_ends = proposal_estimator.sampling(\n prop_sigma_fns=[\n lambda *args: prop_sigma_fn(*args, p) for p in proposal_networks\n ],\n num_samples=cfg.nerf.sampling.num_samples,\n prop_samples=cfg.nerf.propnet.num_samples_per_prop,\n n_rays=chunk_data_dict[prefix + \"origins\"].shape[0],\n near_plane=cfg.nerf.propnet.near_plane,\n far_plane=cfg.nerf.propnet.far_plane,\n sampling_type=cfg.nerf.propnet.sampling_type,\n stratified=radiance_field.training,\n requires_grad=proposal_requires_grad,\n )\n # render the scene\n chunk_results_dict = rendering(\n t_starts,\n t_ends,\n query_fn=query_fn,\n return_decomposition=return_decomposition,\n )\n extras = chunk_results_dict.pop(\"extras\")\n results.append(chunk_results_dict)\n render_results = collate(\n results,\n collate_fn_map={\n **default_collate_fn_map,\n Tensor: lambda x, **_: torch.cat(x, 0),\n },\n )\n extras[\"density\"] = render_results.pop(\"density\")\n for k, v in render_results.items():\n # recover the original shape\n render_results[k] = v.reshape(list(rays_shape[:-1]) + list(v.shape[1:]))\n render_results[\"extras\"] = extras\n return render_results"},{"identifier":"render_pixels","path":"radiance_fields/video_utils.py","snippet":"def render_pixels(\n cfg: OmegaConf,\n model: RadianceField,\n proposal_estimator: PropNetEstimator,\n dataset: SplitWrapper,\n proposal_networks: Optional[List[DensityField]] = None,\n compute_metrics: bool = False,\n vis_indices: Optional[List[int]] = None,\n return_decomposition: bool = True,\n):\n \"\"\"\n Render pixel-related outputs from a model.\n\n Args:\n ....skip obvious args\n compute_metrics (bool, optional): Whether to compute metrics. Defaults to False.\n vis_indices (Optional[List[int]], optional): Indices to visualize. Defaults to None.\n return_decomposition (bool, optional): Whether to visualize the static-dynamic decomposition. Defaults to True.\n \"\"\"\n model.eval()\n if proposal_networks is not None:\n for p in proposal_networks:\n p.eval()\n if proposal_estimator is not None:\n proposal_estimator.eval()\n # set up render function\n render_func = lambda data_dict: render_rays(\n radiance_field=model,\n proposal_estimator=proposal_estimator,\n proposal_networks=proposal_networks,\n data_dict=data_dict,\n cfg=cfg,\n return_decomposition=return_decomposition, # return static-dynamic decomposition\n )\n render_results = render(\n dataset,\n render_func,\n model=model,\n compute_metrics=compute_metrics,\n vis_indices=vis_indices,\n )\n if compute_metrics:\n num_samples = len(dataset) if vis_indices is None else len(vis_indices)\n logger.info(f\"Eval over {num_samples} images:\")\n logger.info(f\"\\tPSNR: {render_results['psnr']:.4f}\")\n logger.info(f\"\\tSSIM: {render_results['ssim']:.4f}\")\n logger.info(f\"\\tFeature PSNR: {render_results['feat_psnr']:.4f}\")\n logger.info(f\"\\tMasked PSNR: {render_results['masked_psnr']:.4f}\")\n logger.info(f\"\\tMasked SSIM: {render_results['masked_ssim']:.4f}\")\n logger.info(f\"\\tMasked Feature PSNR: {render_results['masked_feat_psnr']:.4f}\")\n\n return render_results"},{"identifier":"save_videos","path":"radiance_fields/video_utils.py","snippet":"def save_videos(\n render_results: Dict[str, List[Tensor]],\n save_pth: str,\n num_timestamps: int,\n keys: List[str] = [\"gt_rgbs\", \"rgbs\", \"depths\"],\n num_cams: int = 3,\n save_seperate_video: bool = False,\n save_images: bool = False,\n fps: int = 10,\n verbose: bool = True,\n):\n if save_seperate_video:\n return_frame = save_seperate_videos(\n render_results,\n save_pth,\n num_timestamps=num_timestamps,\n keys=keys,\n num_cams=num_cams,\n save_images=save_images,\n fps=fps,\n verbose=verbose,\n )\n else:\n return_frame = save_concatenated_videos(\n render_results,\n save_pth,\n num_timestamps=num_timestamps,\n keys=keys,\n num_cams=num_cams,\n save_images=save_images,\n fps=fps,\n verbose=verbose,\n )\n return return_frame"},{"identifier":"PropNetEstimator","path":"third_party/nerfacc_prop_net.py","snippet":"class PropNetEstimator(AbstractEstimator):\n \"\"\"Proposal network transmittance estimator.\n\n References: \"Mip-NeRF 360: Unbounded Anti-Aliased Neural Radiance Fields.\"\n\n Args:\n optimizer: The optimizer to use for the proposal networks.\n scheduler: The learning rate scheduler to use for the proposal networks.\n \"\"\"\n\n def __init__(\n self,\n optimizer: Optional[torch.optim.Optimizer] = None,\n scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,\n enable_anti_aliasing_loss: Optional[bool] = True,\n anti_aliasing_pulse_width: Optional[List[float]] = [0.03, 0.003],\n ) -> None:\n super().__init__()\n self.optimizer = optimizer\n self.scheduler = scheduler\n self.prop_cache: List = []\n self.enable_anti_aliasing_loss = enable_anti_aliasing_loss\n self.pulse_width = anti_aliasing_pulse_width\n if self.enable_anti_aliasing_loss:\n logger.info(\"Enable anti-aliasing loss, pulse width: %s\", self.pulse_width)\n\n @torch.no_grad()\n def sampling(\n self,\n prop_sigma_fns: List[Callable],\n prop_samples: List[int],\n num_samples: int,\n # rendering options\n n_rays: int,\n near_plane: float,\n far_plane: float,\n sampling_type: Literal[\n \"uniform\", \"lindisp\", \"sqrt\", \"log\", \"uniform_lindisp\"\n ] = \"uniform_lindisp\",\n # training options\n stratified: bool = False,\n requires_grad: bool = False,\n ) -> Tuple[Tensor, Tensor]:\n \"\"\"Sampling with CDFs from proposal networks.\n\n Note:\n When `requires_grad` is `True`, the gradients are allowed to flow\n through the proposal networks, and the outputs of the proposal\n networks are cached to update them later when calling `update_every_n_steps()`\n\n Args:\n prop_sigma_fns: Proposal network evaluate functions. It should be a list\n of functions that take in samples {t_starts (n_rays, n_samples),\n t_ends (n_rays, n_samples)} and returns the post-activation densities\n (n_rays, n_samples).\n prop_samples: Number of samples to draw from each proposal network. Should\n be the same length as `prop_sigma_fns`.\n num_samples: Number of samples to draw in the end.\n n_rays: Number of rays.\n near_plane: Near plane.\n far_plane: Far plane.\n sampling_type: Sampling type. Either \"uniform\" or \"lindisp\". Default to\n \"lindisp\".\n stratified: Whether to use stratified sampling. Default to `False`.\n requires_grad: Whether to allow gradients to flow through the proposal\n networks. Default to `False`.\n\n Returns:\n A tuple of {Tensor, Tensor}:\n\n - **t_starts**: The starts of the samples. Shape (n_rays, num_samples).\n - **t_ends**: The ends of the samples. Shape (n_rays, num_samples).\n\n \"\"\"\n assert len(prop_sigma_fns) == len(prop_samples), (\n \"The number of proposal networks and the number of samples \"\n \"should be the same.\"\n )\n cdfs = torch.cat(\n [\n torch.zeros((n_rays, 1), device=self.device),\n torch.ones((n_rays, 1), device=self.device),\n ],\n dim=-1,\n )\n intervals = RayIntervals(vals=cdfs)\n\n for i, (level_fn, level_samples) in enumerate(\n zip(prop_sigma_fns, prop_samples)\n ):\n intervals, _ = importance_sampling(\n intervals, cdfs, level_samples, stratified\n )\n t_vals = _transform_stot(\n sampling_type, intervals.vals, near_plane, far_plane\n )\n t_starts = t_vals[..., :-1]\n t_ends = t_vals[..., 1:]\n\n with torch.set_grad_enabled(requires_grad):\n sigmas = level_fn(t_starts, t_ends)[\"density\"].squeeze(-1)\n assert sigmas.shape == t_starts.shape\n trans, _ = render_transmittance_from_density(t_starts, t_ends, sigmas)\n cdfs = 1.0 - torch.cat(\n [trans, torch.zeros_like(trans[..., :1])], dim=-1\n )\n if requires_grad:\n self.prop_cache.append((intervals, cdfs, i))\n\n intervals, _ = importance_sampling(intervals, cdfs, num_samples, stratified)\n t_vals = _transform_stot(sampling_type, intervals.vals, near_plane, far_plane)\n t_starts = t_vals[..., :-1]\n t_ends = t_vals[..., 1:]\n if requires_grad:\n self.prop_cache.append((intervals, None, None))\n\n return t_starts, t_ends\n\n @torch.enable_grad()\n def compute_loss(self, trans: Tensor, loss_scaler: float = 1.0) -> Tensor:\n \"\"\"Compute the loss for the proposal networks.\n\n Args:\n trans: The transmittance of all samples. Shape (n_rays, num_samples).\n loss_scaler: The loss scaler. Default to 1.0.\n\n Returns:\n The loss for the proposal networks.\n \"\"\"\n if len(self.prop_cache) == 0:\n return torch.zeros((), device=self.device)\n\n intervals, _, _ = self.prop_cache.pop()\n # get cdfs at all edges of intervals\n cdfs = 1.0 - torch.cat([trans, torch.zeros_like(trans[..., :1])], dim=-1)\n cdfs = cdfs.detach()\n loss = 0.0\n\n if self.enable_anti_aliasing_loss:\n w_normalize = (cdfs[..., 1:] - cdfs[..., :-1]) / (\n intervals.vals[..., 1:] - intervals.vals[..., :-1]\n )\n c1, w1 = blur_stepfun(intervals.vals, w_normalize, self.pulse_width[0])\n c2, w2 = blur_stepfun(intervals.vals, w_normalize, self.pulse_width[1])\n area1 = 0.5 * (w1[..., 1:] + w1[..., :-1]) * (c1[..., 1:] - c1[..., :-1])\n area2 = 0.5 * (w2[..., 1:] + w2[..., :-1]) * (c2[..., 1:] - c2[..., :-1])\n cdfs1 = torch.cat(\n [\n torch.zeros_like(area1[..., :1]),\n torch.cumsum(area1, dim=-1),\n ],\n dim=-1,\n )\n cdfs2 = torch.cat(\n [\n torch.zeros_like(area2[..., :1]),\n torch.cumsum(area2, dim=-1),\n ],\n dim=-1,\n )\n cs = [c1, c2]\n ws = [w1, w2]\n _cdfs = [cdfs1, cdfs2]\n while self.prop_cache:\n prop_intervals, prop_cdfs, prop_id = self.prop_cache.pop()\n wp = prop_cdfs[..., 1:] - prop_cdfs[..., :-1]\n cdf_interp = sorted_interp_quad(\n prop_intervals.vals, cs[prop_id], ws[prop_id], _cdfs[prop_id]\n )\n w_s = torch.diff(cdf_interp, dim=-1)\n loss += ((w_s - wp).clamp_min(0) ** 2 / (wp + 1e-5)).mean()\n else:\n while self.prop_cache:\n prop_intervals, prop_cdfs, _ = self.prop_cache.pop()\n loss += _pdf_loss(intervals, cdfs, prop_intervals, prop_cdfs).mean()\n return loss * loss_scaler\n\n @torch.enable_grad()\n def update_every_n_steps(\n self,\n trans: Tensor,\n requires_grad: bool = False,\n loss_scaler: float = 1.0,\n ) -> float:\n \"\"\"Update the estimator every n steps during training.\n\n Args:\n trans: The transmittance of all samples. Shape (n_rays, num_samples).\n requires_grad: Whether to allow gradients to flow through the proposal\n networks. Default to `False`.\n loss_scaler: The loss scaler to use. Default to 1.0.\n\n Returns:\n The loss of the proposal networks for logging (a float scalar).\n \"\"\"\n if requires_grad:\n return self._update(trans=trans, loss_scaler=loss_scaler)\n else:\n if self.scheduler is not None:\n self.scheduler.step()\n return 0.0\n\n @torch.enable_grad()\n def _update(self, trans: Tensor, loss_scaler: float = 1.0) -> float:\n assert len(self.prop_cache) > 0\n assert self.optimizer is not None, \"No optimizer is provided.\"\n\n loss = self.compute_loss(trans, loss_scaler)\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n if self.scheduler is not None:\n self.scheduler.step()\n return loss.item()"},{"identifier":"get_proposal_requires_grad_fn","path":"third_party/nerfacc_prop_net.py","snippet":"def get_proposal_requires_grad_fn(\n target: float = 5.0, num_steps: int = 1000\n) -> Callable:\n schedule = lambda s: min(s / num_steps, 1.0) * target\n\n steps_since_last_grad = 0\n\n def proposal_requires_grad_fn(step: int) -> bool:\n nonlocal steps_since_last_grad\n target_steps_since_last_grad = schedule(step)\n requires_grad = steps_since_last_grad > target_steps_since_last_grad\n if requires_grad:\n steps_since_last_grad = 0\n steps_since_last_grad += 1\n return requires_grad\n\n return proposal_requires_grad_fn"},{"identifier":"MetricLogger","path":"utils/logging.py","snippet":"class MetricLogger(object):\n def __init__(self, delimiter=\"\\t\", output_file=None):\n self.meters = defaultdict(SmoothedValue)\n self.delimiter = delimiter\n self.output_file = output_file\n\n def update(self, **kwargs):\n for k, v in kwargs.items():\n if isinstance(v, torch.Tensor):\n v = v.item()\n assert isinstance(v, (float, int))\n self.meters[k].update(v)\n\n def __getattr__(self, attr):\n if attr in self.meters:\n return self.meters[attr]\n if attr in self.__dict__:\n return self.__dict__[attr]\n raise AttributeError(\n f\"'{type(self).__name__}' object has no attribute '{attr}'\"\n )\n\n def __str__(self):\n loss_str = []\n for name, meter in self.meters.items():\n loss_str.append(f\"{name}: {str(meter)}\")\n return self.delimiter.join(loss_str)\n\n def synchronize_between_processes(self):\n for meter in self.meters.values():\n meter.synchronize_between_processes()\n\n def add_meter(self, name, meter):\n self.meters[name] = meter\n\n def dump_in_output_file(self, iteration, iter_time, data_time):\n if self.output_file is None:\n return\n dict_to_dump = dict(\n iteration=iteration,\n iter_time=iter_time,\n data_time=data_time,\n )\n dict_to_dump.update({k: v.median for k, v in self.meters.items()})\n with open(self.output_file, \"a\") as f:\n f.write(json.dumps(dict_to_dump) + \"\\n\")\n pass\n\n def log_every(\n self, iterable, print_freq, header=None, n_iterations=None, start_iteration=0\n ):\n i = start_iteration\n if not header:\n header = \"\"\n start_time = time.time()\n end = time.time()\n iter_time = SmoothedValue(fmt=\"{avg:.6f}\")\n data_time = SmoothedValue(fmt=\"{avg:.6f}\")\n\n if n_iterations is None:\n n_iterations = len(iterable)\n\n space_fmt = \":\" + str(len(str(n_iterations))) + \"d\"\n\n log_list = [\n header,\n \"[{0\" + space_fmt + \"}/{1}]\",\n \"eta: {eta}\",\n \"elapsed: {elapsed_time_str}\",\n \"{meters}\",\n \"time: {time}\",\n \"data: {data}\",\n ]\n if torch.cuda.is_available():\n log_list += [\"max mem: {memory:.0f}\"]\n\n log_msg = self.delimiter.join(log_list)\n MB = 1024.0 * 1024.0\n for obj in iterable:\n data_time.update(time.time() - end)\n yield obj\n iter_time.update(time.time() - end)\n if i % print_freq == 0 or i == n_iterations - 1:\n self.dump_in_output_file(\n iteration=i, iter_time=iter_time.avg, data_time=data_time.avg\n )\n eta_seconds = iter_time.global_avg * (n_iterations - i)\n eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))\n elapsed_time = time.time() - start_time\n elapsed_time_str = str(datetime.timedelta(seconds=int(elapsed_time)))\n\n if torch.cuda.is_available():\n logger.info(\n log_msg.format(\n i,\n n_iterations,\n eta=eta_string,\n elapsed_time_str=elapsed_time_str,\n meters=str(self),\n time=str(iter_time),\n data=str(data_time),\n memory=torch.cuda.max_memory_allocated() / MB,\n )\n )\n else:\n logger.info(\n log_msg.format(\n i,\n n_iterations,\n eta=eta_string,\n meters=str(self),\n time=str(iter_time),\n data=str(data_time),\n )\n )\n i += 1\n end = time.time()\n if i >= n_iterations:\n break\n total_time = time.time() - start_time\n total_time_str = str(datetime.timedelta(seconds=int(total_time)))\n logger.info(\n f\"{header} Total time: {total_time_str} ({total_time / n_iterations:.6f} s / it)\"\n )"},{"identifier":"setup_logging","path":"utils/logging.py","snippet":"def setup_logging(\n output: Optional[str] = None,\n *,\n name: Optional[str] = None,\n level: int = logging.DEBUG,\n capture_warnings: bool = True,\n time_string: Optional[str] = None,\n) -> None:\n \"\"\"\n Setup logging.\n\n Args:\n output: A file name or a directory to save log files. If None, log\n files will not be saved. If output ends with \".txt\" or \".log\", it\n is assumed to be a file name.\n Otherwise, logs will be saved to `output/log.txt`.\n name: The name of the logger to configure, by default the root logger.\n level: The logging level to use.\n capture_warnings: Whether warnings should be captured as logs.\n \"\"\"\n logging.captureWarnings(capture_warnings)\n _configure_logger(name, level=level, output=output, time_string=time_string)"},{"identifier":"visualize_voxels","path":"utils/visualization_tools.py","snippet":"def visualize_voxels(\n cfg: OmegaConf,\n model: RadianceField,\n proposal_estimator: PropNetEstimator = None,\n proposal_networks: DensityField = None,\n dataset: SceneDataset = None,\n device: str = \"cuda\",\n save_html: bool = True,\n is_dynamic: bool = False,\n):\n model.eval()\n for p in proposal_networks:\n p.eval()\n if proposal_estimator is not None:\n proposal_estimator.eval()\n if proposal_networks is not None:\n for p in proposal_networks:\n p.eval()\n\n vis_voxel_aabb = torch.tensor(model.aabb, device=device)\n # slightly expand the aabb to make sure all points are covered\n vis_voxel_aabb[1:3] -= 1\n vis_voxel_aabb[3:] += 1\n aabb_min, aabb_max = torch.split(vis_voxel_aabb, 3, dim=-1)\n aabb_length = aabb_max - aabb_min\n\n # compute the voxel resolution for visualization\n static_voxel_resolution = torch.ceil(\n (aabb_max - aabb_min) / cfg.render.vis_voxel_size\n ).long()\n empty_static_voxels = torch.zeros(*static_voxel_resolution, device=device)\n if is_dynamic:\n # use a slightly smaller voxel size for dynamic voxels\n dynamic_voxel_resolution = torch.ceil(\n (aabb_max - aabb_min) / cfg.render.vis_voxel_size * 0.8\n ).long()\n all_occupied_dynamic_points = []\n empty_dynamic_voxels = torch.zeros(*dynamic_voxel_resolution, device=device)\n\n # collect some patches for PCA\n to_compute_pca_patches = []\n\n pbar = tqdm(\n dataset.full_pixel_set,\n desc=\"querying depth\",\n dynamic_ncols=True,\n total=len(dataset.full_pixel_set),\n )\n for i, data_dict in enumerate(pbar):\n data_dict = dataset.full_pixel_set[i]\n for k, v in data_dict.items():\n data_dict[k] = v.to(device)\n if i < dataset.num_cams:\n # collect all patches from the first timestep\n with torch.no_grad():\n render_results = render_rays(\n radiance_field=model,\n proposal_estimator=proposal_estimator,\n proposal_networks=proposal_networks,\n data_dict=data_dict,\n cfg=cfg,\n proposal_requires_grad=False,\n )\n if \"dino_pe_free\" in render_results:\n dino_feats = render_results[\"dino_pe_free\"]\n else:\n dino_feats = render_results[\"dino_feat\"]\n dino_feats = dino_feats.reshape(-1, dino_feats.shape[-1])\n to_compute_pca_patches.append(dino_feats)\n # query the depth. we force a lidar mode here so that the renderer will skip\n # querying other features such as colors, features, etc.\n data_dict[\"lidar_origins\"] = data_dict[\"origins\"].to(device)\n data_dict[\"lidar_viewdirs\"] = data_dict[\"viewdirs\"].to(device)\n data_dict[\"lidar_normed_timestamps\"] = data_dict[\"normed_timestamps\"].to(device)\n with torch.no_grad():\n render_results = render_rays(\n radiance_field=model,\n proposal_estimator=proposal_estimator,\n proposal_networks=proposal_networks,\n data_dict=data_dict,\n cfg=cfg,\n proposal_requires_grad=False,\n prefix=\"lidar_\", # force lidar mode\n return_decomposition=True,\n )\n # ==== get the static voxels ======\n if is_dynamic:\n static_depth = render_results[\"static_depth\"]\n else:\n static_depth = render_results[\"depth\"]\n world_coords = (\n data_dict[\"lidar_origins\"] + data_dict[\"lidar_viewdirs\"] * static_depth\n )\n world_coords = world_coords[static_depth.squeeze() < 80]\n voxel_coords = world_coords_to_voxel_coords(\n world_coords, aabb_min, aabb_max, static_voxel_resolution\n )\n voxel_coords = voxel_coords.long()\n selector = (\n (voxel_coords[..., 0] >= 0)\n & (voxel_coords[..., 0] < static_voxel_resolution[0])\n & (voxel_coords[..., 1] >= 0)\n & (voxel_coords[..., 1] < static_voxel_resolution[1])\n & (voxel_coords[..., 2] >= 0)\n & (voxel_coords[..., 2] < static_voxel_resolution[2])\n )\n # split the voxel_coords into separate dimensions\n voxel_coords_x = voxel_coords[..., 0][selector]\n voxel_coords_y = voxel_coords[..., 1][selector]\n voxel_coords_z = voxel_coords[..., 2][selector]\n # index into empty_voxels using the separated coordinates\n empty_static_voxels[voxel_coords_x, voxel_coords_y, voxel_coords_z] = 1\n\n # ==== get the dynamic voxels ======\n if is_dynamic:\n dynamic_depth = render_results[\"dynamic_depth\"]\n world_coords = (\n data_dict[\"lidar_origins\"] + data_dict[\"lidar_viewdirs\"] * dynamic_depth\n )\n voxel_coords = world_coords_to_voxel_coords(\n world_coords, aabb_min, aabb_max, dynamic_voxel_resolution\n )\n voxel_coords = voxel_coords.long()\n selector = (\n (voxel_coords[..., 0] >= 0)\n & (voxel_coords[..., 0] < dynamic_voxel_resolution[0])\n & (voxel_coords[..., 1] >= 0)\n & (voxel_coords[..., 1] < dynamic_voxel_resolution[1])\n & (voxel_coords[..., 2] >= 0)\n & (voxel_coords[..., 2] < dynamic_voxel_resolution[2])\n )\n # split the voxel_coords into separate dimensions\n voxel_coords_x = voxel_coords[..., 0][selector]\n voxel_coords_y = voxel_coords[..., 1][selector]\n voxel_coords_z = voxel_coords[..., 2][selector]\n # index into empty_voxels using the separated coordinates\n empty_dynamic_voxels[voxel_coords_x, voxel_coords_y, voxel_coords_z] = 1\n if i % dataset.num_cams == 0 and i > 0:\n all_occupied_dynamic_points.append(\n voxel_coords_to_world_coords(\n aabb_min,\n aabb_max,\n dynamic_voxel_resolution,\n torch.nonzero(empty_dynamic_voxels),\n )\n )\n empty_dynamic_voxels = torch.zeros(\n *dynamic_voxel_resolution, device=device\n )\n # compute the pca reduction\n dummy_pca_reduction, color_min, color_max = get_robust_pca(\n torch.cat(to_compute_pca_patches, dim=0).to(device), m=2.5\n )\n # now let's query the features\n all_occupied_static_points = voxel_coords_to_world_coords(\n aabb_min, aabb_max, static_voxel_resolution, torch.nonzero(empty_static_voxels)\n )\n chunk = 2**18\n pca_colors = []\n occupied_points = []\n pbar = tqdm(\n range(0, all_occupied_static_points.shape[0], chunk),\n desc=\"querying static features\",\n dynamic_ncols=True,\n )\n for i in pbar:\n occupied_points_chunk = all_occupied_static_points[i : i + chunk]\n density_list = []\n # we need to accumulate the density from all proposal networks as well\n # to ensure reliable density estimation\n for p in proposal_networks:\n density_list.append(p(occupied_points_chunk)[\"density\"].squeeze(-1))\n with torch.no_grad():\n results = model.forward(\n occupied_points_chunk,\n query_feature_head=False,\n )\n density_list.append(results[\"density\"])\n density = torch.stack(density_list, dim=0)\n density = torch.mean(density, dim=0)\n # use a preset threshold to determine whether a voxel is occupied\n selector = density > 0.5\n occupied_points_chunk = occupied_points_chunk[selector]\n if len(occupied_points_chunk) == 0:\n # skip if no occupied points in this chunk\n continue\n with torch.no_grad():\n feats = model.forward(\n occupied_points_chunk,\n query_feature_head=True,\n query_pe_head=False,\n )[\"dino_feat\"]\n colors = feats @ dummy_pca_reduction\n del feats\n colors = (colors - color_min) / (color_max - color_min)\n pca_colors.append(torch.clamp(colors, 0, 1))\n occupied_points.append(occupied_points_chunk)\n\n pca_colors = torch.cat(pca_colors, dim=0)\n occupied_points = torch.cat(occupied_points, dim=0)\n if is_dynamic:\n dynamic_pca_colors = []\n dynamic_occupied_points = []\n unq_timestamps = dataset.pixel_source.unique_normalized_timestamps.to(device)\n # query every 10 frames\n pbar = tqdm(\n range(0, len(all_occupied_dynamic_points), 10),\n desc=\"querying dynamic fields\",\n dynamic_ncols=True,\n )\n for i in pbar:\n occupied_points_chunk = all_occupied_dynamic_points[i]\n normed_timestamps = unq_timestamps[i].repeat(\n occupied_points_chunk.shape[0], 1\n )\n with torch.no_grad():\n results = model.forward(\n occupied_points_chunk,\n data_dict={\"normed_timestamps\": normed_timestamps},\n query_feature_head=False,\n )\n selector = results[\"dynamic_density\"].squeeze() > 0.1\n occupied_points_chunk = occupied_points_chunk[selector]\n if len(occupied_points_chunk) == 0:\n continue\n # query some features\n normed_timestamps = unq_timestamps[i].repeat(\n occupied_points_chunk.shape[0], 1\n )\n with torch.no_grad():\n feats = model.forward(\n occupied_points_chunk,\n data_dict={\"normed_timestamps\": normed_timestamps},\n query_feature_head=True,\n query_pe_head=False,\n )[\"dynamic_dino_feat\"]\n colors = feats @ dummy_pca_reduction\n del feats\n colors = (colors - color_min) / (color_max - color_min)\n dynamic_pca_colors.append(torch.clamp(colors, 0, 1))\n dynamic_occupied_points.append(occupied_points_chunk)\n dynamic_coords = [x.cpu().numpy() for x in dynamic_occupied_points]\n dynamic_colors = [x.cpu().numpy() for x in dynamic_pca_colors]\n else:\n dynamic_coords = None\n dynamic_colors = None\n\n figure = vis_occ_plotly(\n vis_aabb=vis_voxel_aabb.cpu().numpy().tolist(),\n coords=occupied_points.cpu().numpy(),\n colors=pca_colors.cpu().numpy(),\n dynamic_coords=dynamic_coords,\n dynamic_colors=dynamic_colors,\n x_ratio=1,\n y_ratio=(aabb_length[1] / aabb_length[0]).item(),\n z_ratio=(aabb_length[2] / aabb_length[0]).item(),\n size=3,\n black_bg=True,\n title=f\"Lifted {cfg.data.pixel_source.feature_model_type} Features, PE_removed: {cfg.nerf.model.head.enable_learnable_pe}\",\n )\n # for plotly\n data = figure.to_dict()[\"data\"]\n layout = figure.to_dict()[\"layout\"]\n output_path = os.path.join(cfg.log_dir, f\"feature_field.json\")\n with open(output_path, \"w\") as f:\n json.dump({\"data\": data, \"layout\": layout}, f, cls=NumpyEncoder)\n logger.info(f\"Saved to {output_path}\")\n output_path = os.path.join(cfg.log_dir, f\"feature_field.html\")\n if save_html:\n figure.write_html(output_path)\n logger.info(f\"Query result saved to {output_path}\")"},{"identifier":"visualize_scene_flow","path":"utils/visualization_tools.py","snippet":"def visualize_scene_flow(\n cfg: OmegaConf,\n model: RadianceField,\n dataset: SceneDataset = None,\n device: str = \"cuda\",\n save_html: bool = True,\n):\n pbar = tqdm(\n range(0, len(dataset.full_lidar_set) - 1, 10),\n desc=\"querying flow\",\n dynamic_ncols=True,\n )\n predicted_flow_colors, gt_flow_colors = [], []\n dynamic_coords = []\n for i in pbar:\n data_dict = dataset.full_lidar_set[i].copy()\n lidar_flow_class = data_dict[\"lidar_flow_class\"]\n for k, v in data_dict.items():\n # remove invalid flow (the information is from GT)\n data_dict[k] = v[lidar_flow_class != -1]\n\n if data_dict[k].shape[0] == 0:\n logger.info(f\"no valid points, skipping...\")\n continue\n # filter out ground points\n # for k, v in data_dict.items():\n # data_dict[k] = v[~data_dict[\"lidar_ground\"]]\n valid_lidar_mask = dataset.get_valid_lidar_mask(i, data_dict)\n for k, v in data_dict.items():\n data_dict[k] = v[valid_lidar_mask]\n lidar_points = (\n data_dict[\"lidar_origins\"]\n + data_dict[\"lidar_ranges\"] * data_dict[\"lidar_viewdirs\"]\n )\n normalized_timestamps = data_dict[\"lidar_normed_timestamps\"]\n with torch.no_grad():\n pred_results = model.query_flow(\n positions=lidar_points,\n normed_timestamps=normalized_timestamps,\n )\n pred_flow = pred_results[\"forward_flow\"]\n # flow is only valid when the point is not static\n pred_flow[pred_results[\"dynamic_density\"] < 0.2] *= 0\n\n predicted_flow_colors.append(\n scene_flow_to_rgb(pred_flow, flow_max_radius=2.0, background=\"bright\")\n .cpu()\n .numpy()\n )\n gt_flow_colors.append(\n scene_flow_to_rgb(\n data_dict[\"lidar_flow\"], flow_max_radius=2.0, background=\"bright\"\n )\n .cpu()\n .numpy()\n )\n dynamic_coords.append(lidar_points.cpu().numpy())\n\n vis_voxel_aabb = torch.tensor(model.aabb, device=device)\n # slightly expand the aabb to make sure all points are covered\n vis_voxel_aabb[1:3] -= 1\n vis_voxel_aabb[3:] += 1\n aabb_min, aabb_max = torch.split(vis_voxel_aabb, 3, dim=-1)\n aabb_length = aabb_max - aabb_min\n pred_figure = vis_occ_plotly(\n vis_aabb=vis_voxel_aabb.cpu().numpy().tolist(),\n dynamic_coords=dynamic_coords,\n dynamic_colors=predicted_flow_colors,\n x_ratio=1,\n y_ratio=(aabb_length[1] / aabb_length[0]).item(),\n z_ratio=(aabb_length[2] / aabb_length[0]).item(),\n size=2,\n black_bg=True,\n title=f\"Predicted Flow\",\n )\n gt_figure = vis_occ_plotly(\n vis_aabb=vis_voxel_aabb.cpu().numpy().tolist(),\n dynamic_coords=dynamic_coords,\n dynamic_colors=gt_flow_colors,\n x_ratio=1,\n y_ratio=(aabb_length[1] / aabb_length[0]).item(),\n z_ratio=(aabb_length[2] / aabb_length[0]).item(),\n size=2,\n black_bg=True,\n title=f\"GT Flow\",\n )\n if save_html:\n output_path = os.path.join(cfg.log_dir, f\"predicted_flow.html\")\n pred_figure.write_html(output_path)\n logger.info(f\"Predicted flow result saved to {output_path}\")\n output_path = os.path.join(cfg.log_dir, f\"gt_flow.html\")\n gt_figure.write_html(output_path)\n logger.info(f\"GT flow saved to {output_path}\")"}],"string":"[\n {\n \"identifier\": \"metrics\",\n \"path\": \"datasets/metrics.py\",\n \"snippet\": \"def compute_valid_depth_rmse(prediction: Tensor, target: Tensor) -> float:\\ndef compute_psnr(prediction: Tensor, target: Tensor) -> float:\\ndef compute_ssim(\\n prediction: Union[Tensor, np.ndarray], target: Union[Tensor, np.ndarray]\\n) -> float:\\ndef compute_scene_flow_metrics(pred: Tensor, labels: Tensor):\\ndef knn_predict(\\n queries: Tensor,\\n memory_bank: Tensor,\\n memory_labels: Tensor,\\n n_classes: int,\\n knn_k: int = 1,\\n knn_t: float = 0.1,\\n) -> Tensor:\\ndef knn_predict(\\n queries: Tensor,\\n memory_bank: Tensor,\\n memory_labels: Tensor,\\n n_classes: int,\\n knn_k: int = 1,\\n knn_t: float = 0.1,\\n similarity: str = \\\"cosine\\\",\\n) -> Tensor:\\ndef collect_centroids(\\n train_indices: List[int],\\n dataset, # a WaymoDataset object\\n model: RadianceField,\\n device: torch.device,\\n):\\ndef eval_few_shot_occ(\\n test_indices: List[int],\\n dataset, # a WaymoDataset object\\n model: RadianceField,\\n device: torch.device,\\n centroids_bank: Tensor,\\n label_bank: Tensor,\\n):\\n EPE3D = torch.mean(l2_norm).item() # Mean absolute distance error\"\n },\n {\n \"identifier\": \"SceneDataset\",\n \"path\": \"datasets/base/scene_dataset.py\",\n \"snippet\": \"class SceneDataset(abc.ABC):\\n \\\"\\\"\\\"\\n Base class for scene dataset.\\n \\\"\\\"\\\"\\n\\n data_cfg: OmegaConf = None\\n pixel_source: ScenePixelSource = None\\n lidar_source: SceneLidarSource = None\\n # training and testing indices are indices into the full dataset\\n # train_indices are img indices, so the length is num_cams * num_timesteps\\n train_indices: List[int] = None\\n test_indices: List[int] = None\\n # train_timesteps are timesteps, so the length is num_timesteps (len(unique_timesteps))\\n train_timesteps: Tensor = None\\n test_timesteps: Tensor = None\\n\\n # dataset wrappers\\n # full: includes all data\\n full_pixel_set: SplitWrapper = None\\n full_lidar_set: SplitWrapper = None\\n # train: includes only training data\\n train_pixel_set: SplitWrapper = None\\n train_lidar_set: SplitWrapper = None\\n # test: includes only testing data\\n test_pixel_set: SplitWrapper = None\\n test_lidar_set: SplitWrapper = None\\n\\n def __init__(\\n self,\\n data_config: OmegaConf,\\n ):\\n super().__init__()\\n self.data_cfg = data_config\\n\\n @abc.abstractmethod\\n def build_data_source(self):\\n \\\"\\\"\\\"\\n Create the data source for the dataset.\\n \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @abc.abstractmethod\\n def build_split_wrapper(self):\\n \\\"\\\"\\\"\\n Makes each data source as a Pytorch Dataset.\\n \\\"\\\"\\\"\\n raise NotImplementedError\\n\\n @abc.abstractmethod\\n def split_train_test(self):\\n raise NotImplementedError\\n\\n def get_aabb(self) -> Tensor:\\n if self.lidar_source is not None:\\n aabb = self.lidar_source.get_aabb()\\n else:\\n aabb = self.pixel_source.get_aabb()\\n return aabb\\n\\n @property\\n def num_cams(self) -> int:\\n return self.pixel_source.num_cams\\n\\n @property\\n def scene_idx(self) -> int:\\n return self.data_cfg.scene_idx\\n\\n @property\\n def num_img_timesteps(self) -> int:\\n return self.pixel_source.num_timesteps\\n\\n @property\\n def num_lidar_timesteps(self) -> int:\\n if self.lidar_source is None:\\n logger.warning(\\\"No lidar source, returning num_img_timesteps\\\")\\n return self.num_img_timesteps\\n return self.lidar_source.num_timesteps\\n\\n @property\\n def num_train_timesteps(self) -> int:\\n return len(self.train_timesteps)\\n\\n @property\\n def num_test_timesteps(self) -> int:\\n return len(self.test_timesteps)\\n\\n @property\\n def unique_normalized_training_timestamps(self) -> Tensor:\\n return self.pixel_source.unique_normalized_timestamps[self.train_timesteps]\\n\\n @property\\n def device(self):\\n return self.data_cfg.preload_device\"\n },\n {\n \"identifier\": \"DensityField\",\n \"path\": \"radiance_fields/radiance_field.py\",\n \"snippet\": \"class DensityField(nn.Module):\\n def __init__(\\n self,\\n xyz_encoder: HashEncoder,\\n aabb: Union[Tensor, List[float]] = [[-1.0, -1.0, -1.0, 1.0, 1.0, 1.0]],\\n num_dims: int = 3,\\n density_activation: Callable = lambda x: trunc_exp(x - 1),\\n unbounded: bool = False,\\n base_mlp_layer_width: int = 64,\\n ) -> None:\\n super().__init__()\\n if not isinstance(aabb, Tensor):\\n aabb = torch.tensor(aabb, dtype=torch.float32)\\n self.register_buffer(\\\"aabb\\\", aabb)\\n self.num_dims = num_dims\\n self.density_activation = density_activation\\n self.unbounded = unbounded\\n self.xyz_encoder = xyz_encoder\\n\\n # density head\\n self.base_mlp = nn.Sequential(\\n nn.Linear(self.xyz_encoder.n_output_dims, base_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(base_mlp_layer_width, 1),\\n )\\n\\n @property\\n def device(self) -> torch.device:\\n return self.aabb.device\\n\\n def set_aabb(self, aabb: Union[Tensor, List[float]]) -> None:\\n if not isinstance(aabb, Tensor):\\n aabb = torch.tensor(aabb, dtype=torch.float32)\\n logger.info(f\\\"Set propnet aabb from {self.aabb} to {aabb}\\\")\\n self.aabb.copy_(aabb)\\n self.aabb = self.aabb.to(self.device)\\n\\n def forward(\\n self, positions: Tensor, data_dict: Dict[str, Tensor] = None\\n ) -> Dict[str, Tensor]:\\n if self.unbounded:\\n # use infinte norm to contract the positions for cuboid aabb\\n positions = contract(positions, self.aabb, ord=float(\\\"inf\\\"))\\n else:\\n aabb_min, aabb_max = torch.split(self.aabb, 3, dim=-1)\\n positions = (positions - aabb_min) / (aabb_max - aabb_min)\\n selector = ((positions > 0.0) & (positions < 1.0)).all(dim=-1).to(positions)\\n positions = positions * selector.unsqueeze(-1)\\n xyz_encoding = self.xyz_encoder(positions.view(-1, self.num_dims))\\n density_before_activation = self.base_mlp(xyz_encoding).view(\\n list(positions.shape[:-1]) + [-1]\\n )\\n density = self.density_activation(density_before_activation)\\n return {\\\"density\\\": density}\"\n },\n {\n \"identifier\": \"RadianceField\",\n \"path\": \"radiance_fields/radiance_field.py\",\n \"snippet\": \"class RadianceField(nn.Module):\\n def __init__(\\n self,\\n xyz_encoder: HashEncoder,\\n dynamic_xyz_encoder: Optional[HashEncoder] = None,\\n flow_xyz_encoder: Optional[HashEncoder] = None,\\n aabb: Union[Tensor, List[float]] = [-1, -1, -1, 1, 1, 1],\\n num_dims: int = 3,\\n density_activation: Callable = lambda x: trunc_exp(x - 1),\\n unbounded: bool = True,\\n geometry_feature_dim: int = 15,\\n base_mlp_layer_width: int = 64,\\n head_mlp_layer_width: int = 64,\\n enable_cam_embedding: bool = False,\\n enable_img_embedding: bool = False,\\n num_cams: int = 3,\\n appearance_embedding_dim: int = 16,\\n semantic_feature_dim: int = 64,\\n feature_mlp_layer_width: int = 256,\\n feature_embedding_dim: int = 768,\\n enable_sky_head: bool = False,\\n enable_shadow_head: bool = False,\\n enable_feature_head: bool = False,\\n num_train_timesteps: int = 0,\\n interpolate_xyz_encoding: bool = False,\\n enable_learnable_pe: bool = True,\\n enable_temporal_interpolation: bool = False,\\n ) -> None:\\n super().__init__()\\n # scene properties\\n if not isinstance(aabb, Tensor):\\n aabb = torch.tensor(aabb, dtype=torch.float32)\\n self.register_buffer(\\\"aabb\\\", aabb)\\n self.unbounded = unbounded\\n self.num_cams = num_cams\\n self.num_dims = num_dims\\n self.density_activation = density_activation\\n\\n # appearance embedding\\n self.enable_cam_embedding = enable_cam_embedding\\n self.enable_img_embedding = enable_img_embedding\\n self.appearance_embedding_dim = appearance_embedding_dim\\n\\n self.geometry_feature_dim = geometry_feature_dim\\n # add semantic feature dim if feature head is enabled\\n if not enable_feature_head:\\n semantic_feature_dim = 0\\n self.semantic_feature_dim = semantic_feature_dim\\n\\n # note: we use very conservative default values for mlps\\n # usually you want to use larger ones\\n\\n # ======== Static Field ======== #\\n self.xyz_encoder = xyz_encoder\\n self.base_mlp = nn.Sequential(\\n nn.Linear(self.xyz_encoder.n_output_dims, base_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(\\n base_mlp_layer_width, geometry_feature_dim + semantic_feature_dim\\n ),\\n )\\n\\n # ======== Dynamic Field ======== #\\n self.interpolate_xyz_encoding = interpolate_xyz_encoding\\n self.dynamic_xyz_encoder = dynamic_xyz_encoder\\n self.enable_temporal_interpolation = enable_temporal_interpolation\\n if self.dynamic_xyz_encoder is not None:\\n # for temporal interpolation\\n self.register_buffer(\\\"training_timesteps\\\", torch.zeros(num_train_timesteps))\\n self.dynamic_base_mlp = nn.Sequential(\\n nn.Linear(self.dynamic_xyz_encoder.n_output_dims, base_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(\\n base_mlp_layer_width,\\n geometry_feature_dim + semantic_feature_dim,\\n ),\\n )\\n\\n # ======== Flow Field ======== #\\n self.flow_xyz_encoder = flow_xyz_encoder\\n if self.flow_xyz_encoder is not None:\\n self.flow_mlp = nn.Sequential(\\n nn.Linear(\\n self.flow_xyz_encoder.n_output_dims,\\n base_mlp_layer_width,\\n ),\\n nn.ReLU(),\\n nn.Linear(base_mlp_layer_width, base_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(base_mlp_layer_width, 6), # 3 for forward, 3 for backward\\n # no activation function for flow\\n )\\n\\n # appearance embedding\\n if self.enable_cam_embedding:\\n # per-camera embedding\\n self.appearance_embedding = nn.Embedding(num_cams, appearance_embedding_dim)\\n elif self.enable_img_embedding:\\n # per-image embedding\\n self.appearance_embedding = nn.Embedding(\\n num_train_timesteps * num_cams, appearance_embedding_dim\\n )\\n else:\\n self.appearance_embedding = None\\n\\n # direction encoding\\n self.direction_encoding = SinusoidalEncoder(\\n n_input_dims=3, min_deg=0, max_deg=4\\n )\\n\\n # ======== Color Head ======== #\\n self.rgb_head = MLP(\\n in_dims=geometry_feature_dim\\n + self.direction_encoding.n_output_dims\\n + (\\n appearance_embedding_dim\\n if self.enable_cam_embedding or self.enable_img_embedding\\n else 0 # 2 or 0?\\n ),\\n out_dims=3,\\n num_layers=3,\\n hidden_dims=head_mlp_layer_width,\\n skip_connections=[1],\\n )\\n\\n # ======== Shadow Head ======== #\\n self.enable_shadow_head = enable_shadow_head\\n if self.enable_shadow_head:\\n self.shadow_head = nn.Sequential(\\n nn.Linear(geometry_feature_dim, base_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(base_mlp_layer_width, 1),\\n nn.Sigmoid(),\\n )\\n\\n # ======== Sky Head ======== #\\n self.enable_sky_head = enable_sky_head\\n if self.enable_sky_head:\\n self.sky_head = MLP(\\n in_dims=self.direction_encoding.n_output_dims\\n + (\\n appearance_embedding_dim\\n if self.enable_cam_embedding or self.enable_img_embedding\\n else 0\\n ),\\n out_dims=3,\\n num_layers=3,\\n hidden_dims=head_mlp_layer_width,\\n skip_connections=[1],\\n )\\n if enable_feature_head:\\n # feature sky head\\n self.dino_sky_head = nn.Sequential(\\n # TODO: remove appearance embedding from dino sky head\\n nn.Linear(\\n self.direction_encoding.n_output_dims\\n + (\\n appearance_embedding_dim\\n if self.enable_cam_embedding or self.enable_img_embedding\\n else 0\\n ),\\n feature_mlp_layer_width,\\n ),\\n nn.ReLU(),\\n nn.Linear(feature_mlp_layer_width, feature_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(feature_mlp_layer_width, feature_embedding_dim),\\n )\\n\\n # ======== Feature Head ======== #\\n self.enable_feature_head = enable_feature_head\\n if self.enable_feature_head:\\n self.dino_head = nn.Sequential(\\n nn.Linear(semantic_feature_dim, feature_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(feature_mlp_layer_width, feature_mlp_layer_width),\\n nn.ReLU(),\\n nn.Linear(feature_mlp_layer_width, feature_embedding_dim),\\n )\\n # placeholders for visualization, will be registered when available\\n self.register_buffer(\\n \\\"feats_reduction_mat\\\", torch.zeros(feature_embedding_dim, 3)\\n )\\n self.register_buffer(\\\"feat_color_min\\\", torch.zeros(3, dtype=torch.float32))\\n self.register_buffer(\\\"feat_color_max\\\", torch.ones(3, dtype=torch.float32))\\n\\n # positional embedding (PE) decomposition\\n self.enable_learnable_pe = enable_learnable_pe\\n if self.enable_learnable_pe:\\n # globally-shared low-resolution learnable PE map\\n self.learnable_pe_map = nn.Parameter(\\n 0.05 * torch.randn(1, feature_embedding_dim // 2, 80, 120),\\n requires_grad=True,\\n )\\n # a PE head to decode PE features\\n self.pe_head = nn.Sequential(\\n nn.Linear(feature_embedding_dim // 2, feature_embedding_dim),\\n )\\n\\n def register_normalized_training_timesteps(\\n self, normalized_timesteps: Tensor, time_diff: float = None\\n ) -> None:\\n \\\"\\\"\\\"\\n register normalized timesteps for temporal interpolation\\n\\n Args:\\n normalized_timesteps (Tensor): normalized timesteps in [0, 1]\\n time_diff (float, optional): time difference between two consecutive timesteps. Defaults to None.\\n \\\"\\\"\\\"\\n if self.dynamic_xyz_encoder is not None:\\n # register timesteps for temporal interpolation\\n self.training_timesteps.copy_(normalized_timesteps)\\n self.training_timesteps = self.training_timesteps.to(self.device)\\n if time_diff is not None:\\n # use the provided time difference if available\\n self.time_diff = time_diff\\n else:\\n if len(self.training_timesteps) > 1:\\n # otherwise, compute the time difference from the provided timesteps\\n # it's important to make sure the provided timesteps are consecutive\\n self.time_diff = (\\n self.training_timesteps[1] - self.training_timesteps[0]\\n )\\n else:\\n self.time_diff = 0\\n\\n def set_aabb(self, aabb: Union[Tensor, List[float]]) -> None:\\n \\\"\\\"\\\"\\n register aabb for scene space\\n \\\"\\\"\\\"\\n if not isinstance(aabb, Tensor):\\n aabb = torch.tensor(aabb, dtype=torch.float32)\\n logger.info(f\\\"Set aabb from {self.aabb} to {aabb}\\\")\\n self.aabb.copy_(aabb)\\n self.aabb = self.aabb.to(self.device)\\n\\n def register_feats_reduction_mat(\\n self,\\n feats_reduction_mat: Tensor,\\n feat_color_min: Tensor,\\n feat_color_max: Tensor,\\n ) -> None:\\n \\\"\\\"\\\"\\n A placeholder for registering the PCA reduction matrix and min/max values for visualization.\\n You may not want to compute PCA reduction matrix every time from the dataset.\\n \\\"\\\"\\\"\\n # for visualization\\n self.feats_reduction_mat.copy_(feats_reduction_mat)\\n self.feat_color_min.copy_(feat_color_min)\\n self.feat_color_max.copy_(feat_color_max)\\n self.feats_reduction_mat = self.feats_reduction_mat.to(self.device)\\n self.feat_color_min = self.feat_color_min.to(self.device)\\n self.feat_color_max = self.feat_color_max.to(self.device)\\n\\n @property\\n def device(self) -> torch.device:\\n return self.aabb.device\\n\\n def contract_points(\\n self,\\n positions: Tensor,\\n ) -> Tensor:\\n \\\"\\\"\\\"\\n contract [-inf, inf] points to the range [0, 1] for hash encoding\\n\\n Returns:\\n normed_positions: [..., 3] in [0, 1]\\n \\\"\\\"\\\"\\n if self.unbounded:\\n # use infinte norm to contract the positions for cuboid aabb\\n normed_positions = contract(positions, self.aabb, ord=float(\\\"inf\\\"))\\n else:\\n aabb_min, aabb_max = torch.split(self.aabb, 3, dim=-1)\\n normed_positions = (positions - aabb_min) / (aabb_max - aabb_min)\\n selector = (\\n ((normed_positions > 0.0) & (normed_positions < 1.0))\\n .all(dim=-1)\\n .to(positions)\\n )\\n normed_positions = normed_positions * selector.unsqueeze(-1)\\n return normed_positions\\n\\n def forward_static_hash(\\n self,\\n positions: Tensor,\\n ) -> Tensor:\\n \\\"\\\"\\\"\\n forward pass for static hash encoding\\n\\n Returns:\\n encoded_features: [..., geometry_feature_dim + (semantic_feature_dim)]\\n normed_positions: [..., 3] in [0, 1]\\n \\\"\\\"\\\"\\n normed_positions = self.contract_points(positions)\\n xyz_encoding = self.xyz_encoder(normed_positions.view(-1, self.num_dims))\\n encoded_features = self.base_mlp(xyz_encoding).view(\\n list(normed_positions.shape[:-1]) + [-1]\\n )\\n return encoded_features, normed_positions\\n\\n def forward_dynamic_hash(\\n self,\\n normed_positions: Tensor,\\n normed_timestamps: Tensor,\\n return_hash_encodings: bool = False,\\n ) -> Union[Tuple[Tensor, Tensor], Tensor]:\\n \\\"\\\"\\\"\\n forward pass for dynamic hash encoding\\n\\n Returns:\\n encoded_dynamic_feats: [..., geometry_feature_dim + (semantic_feature_dim)]\\n dynamic_xyz_encoding: [..., n_output_dims] (optional)\\n \\\"\\\"\\\"\\n if normed_timestamps.shape[-1] != 1:\\n normed_timestamps = normed_timestamps.unsqueeze(-1)\\n # To be fixed.\\n # if self.training or not self.enable_temporal_interpolation:\\n if True:\\n temporal_positions = torch.cat(\\n [normed_positions, normed_timestamps], dim=-1\\n )\\n dynamic_xyz_encoding = self.dynamic_xyz_encoder(\\n temporal_positions.view(-1, self.num_dims + 1)\\n ).view(list(temporal_positions.shape[:-1]) + [-1])\\n encoded_dynamic_feats = self.dynamic_base_mlp(dynamic_xyz_encoding)\\n else:\\n encoded_dynamic_feats = temporal_interpolation(\\n normed_timestamps,\\n self.training_timesteps,\\n normed_positions,\\n self.dynamic_xyz_encoder,\\n self.dynamic_base_mlp,\\n interpolate_xyz_encoding=self.interpolate_xyz_encoding,\\n )\\n if return_hash_encodings:\\n return encoded_dynamic_feats, dynamic_xyz_encoding\\n else:\\n return encoded_dynamic_feats\\n\\n def forward_flow_hash(\\n self,\\n normed_positions: Tensor,\\n normed_timestamps: Tensor,\\n ) -> Tuple[Tensor, Tensor]:\\n \\\"\\\"\\\"\\n forward pass for flow hash encoding\\n\\n Returns:\\n flow: [..., 6] (forward_flow, backward_flow)\\n \\\"\\\"\\\"\\n if normed_timestamps.shape[-1] != 1:\\n normed_timestamps = normed_timestamps.unsqueeze(-1)\\n if self.training or not self.enable_temporal_interpolation:\\n temporal_positions = torch.cat(\\n [normed_positions, normed_timestamps], dim=-1\\n )\\n flow_xyz_encoding = self.flow_xyz_encoder(\\n temporal_positions.view(-1, self.num_dims + 1)\\n ).view(list(temporal_positions.shape[:-1]) + [-1])\\n flow = self.flow_mlp(flow_xyz_encoding)\\n else:\\n flow = temporal_interpolation(\\n normed_timestamps,\\n self.training_timesteps,\\n normed_positions,\\n self.flow_xyz_encoder,\\n self.flow_mlp,\\n interpolate_xyz_encoding=True,\\n )\\n return flow\\n\\n def forward(\\n self,\\n positions: Tensor,\\n directions: Tensor = None,\\n data_dict: Dict[str, Tensor] = {},\\n return_density_only: bool = False,\\n combine_static_dynamic: bool = False,\\n query_feature_head: bool = True,\\n query_pe_head: bool = True,\\n ) -> Dict[str, Tensor]:\\n \\\"\\\"\\\"\\n Args:\\n positions: [..., 3]\\n directions: [..., 3]\\n data_dict: a dictionary containing additional data\\n return_density_only: if True, only return density without querying other heads\\n combine_static_dynamic: if True, combine static and dynamic predictions based on static and dynamic density\\n in addition to returning separate results for static and dynamic fields\\n query_feature_head: if True, query feature head\\n query_pe_head: if True, query PE head. Disable this if we want to directly query 3D features.\\n Returns:\\n results_dict: a dictionary containing everything\\n \\\"\\\"\\\"\\n results_dict = {}\\n # forward static branch\\n encoded_features, normed_positions = self.forward_static_hash(positions)\\n geo_feats, semantic_feats = torch.split(\\n encoded_features,\\n [self.geometry_feature_dim, self.semantic_feature_dim],\\n dim=-1,\\n )\\n static_density = self.density_activation(geo_feats[..., 0])\\n\\n has_timestamps = (\\n \\\"normed_timestamps\\\" in data_dict or \\\"lidar_normed_timestamps\\\" in data_dict\\n )\\n if self.dynamic_xyz_encoder is not None and has_timestamps:\\n # forward dynamic branch\\n if \\\"normed_timestamps\\\" in data_dict:\\n normed_timestamps = data_dict[\\\"normed_timestamps\\\"]\\n elif \\\"lidar_normed_timestamps\\\" in data_dict:\\n # we use `lidar_` prefix as an identifier to skip querying other heads\\n normed_timestamps = data_dict[\\\"lidar_normed_timestamps\\\"]\\n dynamic_feats, dynamic_hash_encodings = self.forward_dynamic_hash(\\n normed_positions, normed_timestamps, return_hash_encodings=True\\n )\\n if self.flow_xyz_encoder is not None:\\n flow = self.forward_flow_hash(normed_positions, normed_timestamps)\\n forward_flow, backward_flow = flow[..., :3], flow[..., 3:]\\n results_dict[\\\"forward_flow\\\"] = forward_flow\\n results_dict[\\\"backward_flow\\\"] = backward_flow\\n temporal_aggregation_results = self.temporal_aggregation(\\n positions,\\n normed_timestamps,\\n forward_flow,\\n backward_flow,\\n dynamic_feats,\\n )\\n # overwrite dynamic feats using temporal aggregation results\\n dynamic_feats = temporal_aggregation_results[\\\"dynamic_feats\\\"]\\n # to be studied\\n temporal_aggregation_results[\\n \\\"current_dynamic_hash_encodings\\\"\\n ] = dynamic_hash_encodings\\n results_dict.update(temporal_aggregation_results)\\n (dynamic_geo_feats, dynamic_semantic_feats,) = torch.split(\\n dynamic_feats,\\n [self.geometry_feature_dim, self.semantic_feature_dim],\\n dim=-1,\\n )\\n dynamic_density = self.density_activation(dynamic_geo_feats[..., 0])\\n # blend static and dynamic density to get the final density\\n density = static_density + dynamic_density\\n results_dict.update(\\n {\\n \\\"density\\\": density,\\n \\\"static_density\\\": static_density,\\n \\\"dynamic_density\\\": dynamic_density,\\n }\\n )\\n if return_density_only:\\n # skip querying other heads\\n return results_dict\\n\\n if directions is not None:\\n rgb_results = self.query_rgb(\\n directions, geo_feats, dynamic_geo_feats, data_dict=data_dict\\n )\\n results_dict[\\\"dynamic_rgb\\\"] = rgb_results[\\\"dynamic_rgb\\\"]\\n results_dict[\\\"static_rgb\\\"] = rgb_results[\\\"rgb\\\"]\\n if combine_static_dynamic:\\n static_ratio = static_density / (density + 1e-6)\\n dynamic_ratio = dynamic_density / (density + 1e-6)\\n results_dict[\\\"rgb\\\"] = (\\n static_ratio[..., None] * results_dict[\\\"static_rgb\\\"]\\n + dynamic_ratio[..., None] * results_dict[\\\"dynamic_rgb\\\"]\\n )\\n if self.enable_shadow_head:\\n shadow_ratio = self.shadow_head(dynamic_geo_feats)\\n results_dict[\\\"shadow_ratio\\\"] = shadow_ratio\\n if combine_static_dynamic and \\\"rgb\\\" in results_dict:\\n results_dict[\\\"rgb\\\"] = (\\n static_ratio[..., None]\\n * results_dict[\\\"rgb\\\"]\\n * (1 - shadow_ratio)\\n + dynamic_ratio[..., None] * results_dict[\\\"dynamic_rgb\\\"]\\n )\\n else:\\n # if no dynamic branch, use static density\\n results_dict[\\\"density\\\"] = static_density\\n if return_density_only:\\n # skip querying other heads\\n return results_dict\\n if directions is not None:\\n rgb_results = self.query_rgb(directions, geo_feats, data_dict=data_dict)\\n results_dict[\\\"rgb\\\"] = rgb_results[\\\"rgb\\\"]\\n\\n if self.enable_feature_head and query_feature_head:\\n if self.enable_learnable_pe and query_pe_head:\\n learnable_pe_map = (\\n F.grid_sample(\\n self.learnable_pe_map,\\n # assume pixel coords have been normalize to [-1, 1]\\n data_dict[\\\"pixel_coords\\\"].reshape(1, 1, -1, 2) * 2 - 1,\\n align_corners=False, # didn't test with True\\n mode=\\\"bilinear\\\", # didn't test with other modes\\n )\\n .squeeze(2)\\n .squeeze(0)\\n .permute(1, 0)\\n )\\n dino_pe = self.pe_head(learnable_pe_map)\\n results_dict[\\\"dino_pe\\\"] = dino_pe\\n dino_feats = self.dino_head(semantic_feats)\\n\\n if self.dynamic_xyz_encoder is not None and has_timestamps:\\n dynamic_dino_feats = self.dino_head(dynamic_semantic_feats)\\n results_dict[\\\"static_dino_feat\\\"] = dino_feats\\n results_dict[\\\"dynamic_dino_feat\\\"] = dynamic_dino_feats\\n if combine_static_dynamic:\\n static_ratio = static_density / (density + 1e-6)\\n dynamic_ratio = dynamic_density / (density + 1e-6)\\n results_dict[\\\"dino_feat\\\"] = (\\n static_ratio[..., None] * dino_feats\\n + dynamic_ratio[..., None] * dynamic_dino_feats\\n )\\n else:\\n results_dict[\\\"dino_feat\\\"] = dino_feats\\n\\n # query sky if not in lidar mode\\n if (\\n self.enable_sky_head\\n and \\\"lidar_origin\\\" not in data_dict\\n and directions is not None\\n ):\\n directions = directions[:, 0]\\n reduced_data_dict = {k: v[:, 0] for k, v in data_dict.items()}\\n sky_results = self.query_sky(directions, data_dict=reduced_data_dict)\\n results_dict.update(sky_results)\\n\\n return results_dict\\n\\n def temporal_aggregation(\\n self,\\n positions: Tensor, # current world coordinates\\n normed_timestamps: Tensor, # current normalized timestamps\\n forward_flow: Tensor,\\n backward_flow: Tensor,\\n dynamic_feats: Tensor,\\n ) -> Tensor:\\n \\\"\\\"\\\"\\n temporal aggregation for dynamic features\\n Eq. (8) in the emernerf paper\\n \\\"\\\"\\\"\\n if normed_timestamps.shape[-1] != 1:\\n normed_timestamps = normed_timestamps.unsqueeze(-1)\\n if self.training:\\n noise = torch.rand_like(forward_flow)[..., 0:1]\\n else:\\n noise = torch.ones_like(forward_flow)[..., 0:1]\\n # forward and backward warped positions\\n forward_warped_positions = self.contract_points(\\n positions + forward_flow * noise\\n )\\n backward_warped_positions = self.contract_points(\\n positions + backward_flow * noise\\n )\\n # forward and backward warped timestamps\\n forward_warped_time = torch.clamp(\\n normed_timestamps + self.time_diff * noise, 0, 1.0\\n )\\n backward_warped_time = torch.clamp(\\n normed_timestamps - self.time_diff * noise, 0, 1.0\\n )\\n (\\n forward_dynamic_feats,\\n forward_dynamic_hash_encodings,\\n ) = self.forward_dynamic_hash(\\n forward_warped_positions,\\n forward_warped_time,\\n return_hash_encodings=True,\\n )\\n (\\n backward_dynamic_feats,\\n backward_dynamic_hash_encodings,\\n ) = self.forward_dynamic_hash(\\n backward_warped_positions,\\n backward_warped_time,\\n return_hash_encodings=True,\\n )\\n forward_pred_flow = self.forward_flow_hash(\\n forward_warped_positions,\\n forward_warped_time,\\n )\\n backward_pred_flow = self.forward_flow_hash(\\n backward_warped_positions,\\n backward_warped_time,\\n )\\n # simple weighted sum\\n aggregated_dynamic_feats = (\\n dynamic_feats + 0.5 * forward_dynamic_feats + 0.5 * backward_dynamic_feats\\n ) / 2.0\\n return {\\n \\\"dynamic_feats\\\": aggregated_dynamic_feats,\\n \\\"forward_pred_backward_flow\\\": forward_pred_flow[..., 3:],\\n \\\"backward_pred_forward_flow\\\": backward_pred_flow[..., :3],\\n # to be studied\\n \\\"forward_dynamic_hash_encodings\\\": forward_dynamic_hash_encodings,\\n \\\"backward_dynamic_hash_encodings\\\": backward_dynamic_hash_encodings,\\n }\\n\\n def query_rgb(\\n self,\\n directions: Tensor,\\n geo_feats: Tensor,\\n dynamic_geo_feats: Tensor = None,\\n data_dict: Dict[str, Tensor] = None,\\n ) -> Tensor:\\n directions = (directions + 1.0) / 2.0 # do we need this?\\n h = self.direction_encoding(directions.reshape(-1, directions.shape[-1])).view(\\n *directions.shape[:-1], -1\\n )\\n if self.enable_cam_embedding or self.enable_img_embedding:\\n if \\\"cam_idx\\\" in data_dict and self.enable_cam_embedding:\\n appearance_embedding = self.appearance_embedding(data_dict[\\\"cam_idx\\\"])\\n elif \\\"img_idx\\\" in data_dict and self.enable_img_embedding:\\n appearance_embedding = self.appearance_embedding(data_dict[\\\"img_idx\\\"])\\n else:\\n # use mean appearance embedding\\n # print(\\\"using mean appearance embedding\\\")\\n appearance_embedding = torch.ones(\\n (*directions.shape[:-1], self.appearance_embedding_dim),\\n device=directions.device,\\n ) * self.appearance_embedding.weight.mean(dim=0)\\n h = torch.cat([h, appearance_embedding], dim=-1)\\n\\n rgb = self.rgb_head(torch.cat([h, geo_feats], dim=-1))\\n rgb = F.sigmoid(rgb)\\n results = {\\\"rgb\\\": rgb}\\n\\n if self.dynamic_xyz_encoder is not None:\\n assert (\\n dynamic_geo_feats is not None\\n ), \\\"Dynamic geometry features are not provided.\\\"\\n dynamic_rgb = self.rgb_head(torch.cat([h, dynamic_geo_feats], dim=-1))\\n dynamic_rgb = F.sigmoid(dynamic_rgb)\\n results[\\\"dynamic_rgb\\\"] = dynamic_rgb\\n return results\\n\\n def query_sky(\\n self, directions: Tensor, data_dict: Dict[str, Tensor] = None\\n ) -> Dict[str, Tensor]:\\n if len(directions.shape) == 2:\\n dd = self.direction_encoding(directions).to(directions)\\n else:\\n dd = self.direction_encoding(directions[:, 0]).to(directions)\\n if self.enable_cam_embedding or self.enable_img_embedding:\\n # optionally add appearance embedding\\n if \\\"cam_idx\\\" in data_dict and self.enable_cam_embedding:\\n appearance_embedding = self.appearance_embedding(data_dict[\\\"cam_idx\\\"])\\n elif \\\"img_idx\\\" in data_dict and self.enable_img_embedding:\\n appearance_embedding = self.appearance_embedding(data_dict[\\\"img_idx\\\"])\\n else:\\n # use mean appearance embedding\\n appearance_embedding = torch.ones(\\n (*directions.shape[:-1], self.appearance_embedding_dim),\\n device=directions.device,\\n ) * self.appearance_embedding.weight.mean(dim=0)\\n dd = torch.cat([dd, appearance_embedding], dim=-1)\\n rgb_sky = self.sky_head(dd).to(directions)\\n rgb_sky = F.sigmoid(rgb_sky)\\n results = {\\\"rgb_sky\\\": rgb_sky}\\n if self.enable_feature_head:\\n self.dino_sky_head(dd).to(directions)\\n results[\\\"dino_sky_feat\\\"] = self.dino_sky_head(dd).to(directions)\\n return results\\n\\n def query_flow(\\n self, positions: Tensor, normed_timestamps: Tensor, query_density: bool = True\\n ) -> Dict[str, Tensor]:\\n \\\"\\\"\\\"\\n query flow field\\n \\\"\\\"\\\"\\n normed_positions = self.contract_points(positions)\\n flow = self.forward_flow_hash(normed_positions, normed_timestamps)\\n results = {\\n \\\"forward_flow\\\": flow[..., :3],\\n \\\"backward_flow\\\": flow[..., 3:],\\n }\\n if query_density:\\n # it's important to filter valid flows based on a dynamic density threshold.\\n # flows are valid only if they are on dynamic points.\\n dynamic_feats = self.forward_dynamic_hash(\\n normed_positions, normed_timestamps\\n )\\n (dynamic_geo_feats, _,) = torch.split(\\n dynamic_feats,\\n [self.geometry_feature_dim, self.semantic_feature_dim],\\n dim=-1,\\n )\\n dynamic_density = self.density_activation(dynamic_geo_feats[..., 0])\\n results[\\\"dynamic_density\\\"] = dynamic_density\\n return results\\n\\n def query_attributes(\\n self,\\n positions: Tensor,\\n normed_timestamps: Tensor = None,\\n query_feature_head: bool = True,\\n ):\\n \\\"\\\"\\\"\\n query attributes (density, dino features, etc.)\\n \\\"\\\"\\\"\\n results_dict = {}\\n encoded_features, normed_positions = self.forward_static_hash(positions)\\n geo_feats, semantic_feats = torch.split(\\n encoded_features,\\n [self.geometry_feature_dim, self.semantic_feature_dim],\\n dim=-1,\\n )\\n static_density = self.density_activation(geo_feats[..., 0])\\n if self.dynamic_xyz_encoder is not None and normed_timestamps is not None:\\n dynamic_feats, dynamic_hash_encodings = self.forward_dynamic_hash(\\n normed_positions, normed_timestamps, return_hash_encodings=True\\n )\\n if self.flow_xyz_encoder is not None:\\n flow = self.forward_flow_hash(normed_positions, normed_timestamps)\\n forward_flow = flow[..., :3]\\n backward_flow = flow[..., 3:]\\n results_dict[\\\"forward_flow\\\"] = forward_flow\\n results_dict[\\\"backward_flow\\\"] = backward_flow\\n temporal_aggregation_results = self.temporal_aggregation(\\n positions,\\n normed_timestamps,\\n forward_flow,\\n backward_flow,\\n dynamic_feats,\\n )\\n dynamic_feats = temporal_aggregation_results[\\\"dynamic_feats\\\"]\\n temporal_aggregation_results[\\n \\\"current_dynamic_hash_encodings\\\"\\n ] = dynamic_hash_encodings\\n results_dict.update(temporal_aggregation_results)\\n\\n (dynamic_geo_feats, dynamic_semantic_feats,) = torch.split(\\n dynamic_feats,\\n [self.geometry_feature_dim, self.semantic_feature_dim],\\n dim=-1,\\n )\\n dynamic_density = self.density_activation(dynamic_geo_feats[..., 0])\\n density = static_density + dynamic_density\\n results_dict.update(\\n {\\n \\\"density\\\": density,\\n \\\"static_density\\\": static_density,\\n \\\"dynamic_density\\\": dynamic_density,\\n # \\\"occupancy\\\": occupancy,\\n }\\n )\\n else:\\n results_dict[\\\"density\\\"] = static_density\\n if self.enable_feature_head and query_feature_head:\\n # query on demand\\n dino_feats = self.dino_head(semantic_feats)\\n if self.dynamic_xyz_encoder is not None and normed_timestamps is not None:\\n dynamic_dino_feats = self.dino_head(dynamic_semantic_feats)\\n results_dict[\\\"static_dino_feat\\\"] = dino_feats\\n results_dict[\\\"dynamic_dino_feat\\\"] = dynamic_dino_feats\\n results_dict[\\\"dino_feat\\\"] = (\\n static_density.unsqueeze(-1) * dino_feats\\n + dynamic_density.unsqueeze(-1) * dynamic_dino_feats\\n ) / (density.unsqueeze(-1) + 1e-6)\\n else:\\n results_dict[\\\"dino_feat\\\"] = dino_feats\\n return results_dict\"\n },\n {\n \"identifier\": \"render_rays\",\n \"path\": \"radiance_fields/render_utils.py\",\n \"snippet\": \"def render_rays(\\n # scene\\n radiance_field: RadianceField = None,\\n proposal_estimator: PropNetEstimator = None,\\n proposal_networks: Optional[List[DensityField]] = None,\\n data_dict: Dict[str, Tensor] = None,\\n cfg: OmegaConf = None,\\n proposal_requires_grad: bool = False,\\n return_decomposition: bool = False,\\n prefix=\\\"\\\",\\n) -> Dict[str, Tensor]:\\n \\\"\\\"\\\"Render some attributes of the scene along the rays.\\\"\\\"\\\"\\n # reshape data_dict to be (num_rays, ...)\\n rays_shape = data_dict[prefix + \\\"origins\\\"].shape\\n if len(rays_shape) == 3:\\n height, width, _ = rays_shape\\n num_rays = height * width\\n reshaped_data_dict = {}\\n for k, v in data_dict.items():\\n reshaped_data_dict[k] = v.reshape(num_rays, -1).squeeze()\\n else:\\n num_rays, _ = rays_shape\\n reshaped_data_dict = data_dict.copy()\\n\\n def prop_sigma_fn(t_starts, t_ends, proposal_network):\\n # query propsal networks for density\\n t_origins = chunk_data_dict[prefix + \\\"origins\\\"][..., None, :]\\n t_dirs = chunk_data_dict[prefix + \\\"viewdirs\\\"][..., None, :]\\n positions = t_origins + t_dirs * (t_starts + t_ends)[..., None] / 2.0\\n sub_dict = {\\n k: v[..., None].repeat_interleave(t_starts.shape[-1], dim=-1)\\n for k, v in chunk_data_dict.items()\\n if \\\"time\\\" in k\\n }\\n return proposal_network(positions, sub_dict)\\n\\n def query_fn(t_starts, t_ends):\\n # query the final nerf model for density and other information along the rays\\n t_origins = chunk_data_dict[prefix + \\\"origins\\\"][..., None, :]\\n t_dirs = chunk_data_dict[prefix + \\\"viewdirs\\\"][..., None, :].repeat_interleave(\\n t_starts.shape[-1], dim=-2\\n )\\n sub_dict = {\\n k: v[..., None].repeat_interleave(t_starts.shape[-1], dim=-1)\\n for k, v in chunk_data_dict.items()\\n if k not in [prefix + \\\"viewdirs\\\", prefix + \\\"origins\\\", \\\"pixel_coords\\\"]\\n }\\n sub_dict[\\\"t_starts\\\"], sub_dict[\\\"t_ends\\\"] = t_starts, t_ends\\n if \\\"pixel_coords\\\" in chunk_data_dict:\\n # use this for positional embedding decomposition\\n sub_dict[\\\"pixel_coords\\\"] = chunk_data_dict[\\\"pixel_coords\\\"]\\n positions = t_origins + t_dirs * (t_starts + t_ends)[..., None] / 2.0\\n # return density only when rendering lidar, i.e., no rgb or sky or features are rendered\\n results_dict: Dict[str, Tensor] = radiance_field(\\n positions, t_dirs, sub_dict, return_density_only=(prefix == \\\"lidar_\\\")\\n )\\n results_dict[\\\"density\\\"] = results_dict[\\\"density\\\"].squeeze(-1)\\n return results_dict\\n\\n results = []\\n chunk = 2**24 if radiance_field.training else cfg.render.render_chunk_size\\n for i in range(0, num_rays, chunk):\\n chunk_data_dict = {k: v[i : i + chunk] for k, v in reshaped_data_dict.items()}\\n assert proposal_networks is not None, \\\"proposal_networks is required.\\\"\\n # obtain proposed intervals\\n t_starts, t_ends = proposal_estimator.sampling(\\n prop_sigma_fns=[\\n lambda *args: prop_sigma_fn(*args, p) for p in proposal_networks\\n ],\\n num_samples=cfg.nerf.sampling.num_samples,\\n prop_samples=cfg.nerf.propnet.num_samples_per_prop,\\n n_rays=chunk_data_dict[prefix + \\\"origins\\\"].shape[0],\\n near_plane=cfg.nerf.propnet.near_plane,\\n far_plane=cfg.nerf.propnet.far_plane,\\n sampling_type=cfg.nerf.propnet.sampling_type,\\n stratified=radiance_field.training,\\n requires_grad=proposal_requires_grad,\\n )\\n # render the scene\\n chunk_results_dict = rendering(\\n t_starts,\\n t_ends,\\n query_fn=query_fn,\\n return_decomposition=return_decomposition,\\n )\\n extras = chunk_results_dict.pop(\\\"extras\\\")\\n results.append(chunk_results_dict)\\n render_results = collate(\\n results,\\n collate_fn_map={\\n **default_collate_fn_map,\\n Tensor: lambda x, **_: torch.cat(x, 0),\\n },\\n )\\n extras[\\\"density\\\"] = render_results.pop(\\\"density\\\")\\n for k, v in render_results.items():\\n # recover the original shape\\n render_results[k] = v.reshape(list(rays_shape[:-1]) + list(v.shape[1:]))\\n render_results[\\\"extras\\\"] = extras\\n return render_results\"\n },\n {\n \"identifier\": \"render_pixels\",\n \"path\": \"radiance_fields/video_utils.py\",\n \"snippet\": \"def render_pixels(\\n cfg: OmegaConf,\\n model: RadianceField,\\n proposal_estimator: PropNetEstimator,\\n dataset: SplitWrapper,\\n proposal_networks: Optional[List[DensityField]] = None,\\n compute_metrics: bool = False,\\n vis_indices: Optional[List[int]] = None,\\n return_decomposition: bool = True,\\n):\\n \\\"\\\"\\\"\\n Render pixel-related outputs from a model.\\n\\n Args:\\n ....skip obvious args\\n compute_metrics (bool, optional): Whether to compute metrics. Defaults to False.\\n vis_indices (Optional[List[int]], optional): Indices to visualize. Defaults to None.\\n return_decomposition (bool, optional): Whether to visualize the static-dynamic decomposition. Defaults to True.\\n \\\"\\\"\\\"\\n model.eval()\\n if proposal_networks is not None:\\n for p in proposal_networks:\\n p.eval()\\n if proposal_estimator is not None:\\n proposal_estimator.eval()\\n # set up render function\\n render_func = lambda data_dict: render_rays(\\n radiance_field=model,\\n proposal_estimator=proposal_estimator,\\n proposal_networks=proposal_networks,\\n data_dict=data_dict,\\n cfg=cfg,\\n return_decomposition=return_decomposition, # return static-dynamic decomposition\\n )\\n render_results = render(\\n dataset,\\n render_func,\\n model=model,\\n compute_metrics=compute_metrics,\\n vis_indices=vis_indices,\\n )\\n if compute_metrics:\\n num_samples = len(dataset) if vis_indices is None else len(vis_indices)\\n logger.info(f\\\"Eval over {num_samples} images:\\\")\\n logger.info(f\\\"\\\\tPSNR: {render_results['psnr']:.4f}\\\")\\n logger.info(f\\\"\\\\tSSIM: {render_results['ssim']:.4f}\\\")\\n logger.info(f\\\"\\\\tFeature PSNR: {render_results['feat_psnr']:.4f}\\\")\\n logger.info(f\\\"\\\\tMasked PSNR: {render_results['masked_psnr']:.4f}\\\")\\n logger.info(f\\\"\\\\tMasked SSIM: {render_results['masked_ssim']:.4f}\\\")\\n logger.info(f\\\"\\\\tMasked Feature PSNR: {render_results['masked_feat_psnr']:.4f}\\\")\\n\\n return render_results\"\n },\n {\n \"identifier\": \"save_videos\",\n \"path\": \"radiance_fields/video_utils.py\",\n \"snippet\": \"def save_videos(\\n render_results: Dict[str, List[Tensor]],\\n save_pth: str,\\n num_timestamps: int,\\n keys: List[str] = [\\\"gt_rgbs\\\", \\\"rgbs\\\", \\\"depths\\\"],\\n num_cams: int = 3,\\n save_seperate_video: bool = False,\\n save_images: bool = False,\\n fps: int = 10,\\n verbose: bool = True,\\n):\\n if save_seperate_video:\\n return_frame = save_seperate_videos(\\n render_results,\\n save_pth,\\n num_timestamps=num_timestamps,\\n keys=keys,\\n num_cams=num_cams,\\n save_images=save_images,\\n fps=fps,\\n verbose=verbose,\\n )\\n else:\\n return_frame = save_concatenated_videos(\\n render_results,\\n save_pth,\\n num_timestamps=num_timestamps,\\n keys=keys,\\n num_cams=num_cams,\\n save_images=save_images,\\n fps=fps,\\n verbose=verbose,\\n )\\n return return_frame\"\n },\n {\n \"identifier\": \"PropNetEstimator\",\n \"path\": \"third_party/nerfacc_prop_net.py\",\n \"snippet\": \"class PropNetEstimator(AbstractEstimator):\\n \\\"\\\"\\\"Proposal network transmittance estimator.\\n\\n References: \\\"Mip-NeRF 360: Unbounded Anti-Aliased Neural Radiance Fields.\\\"\\n\\n Args:\\n optimizer: The optimizer to use for the proposal networks.\\n scheduler: The learning rate scheduler to use for the proposal networks.\\n \\\"\\\"\\\"\\n\\n def __init__(\\n self,\\n optimizer: Optional[torch.optim.Optimizer] = None,\\n scheduler: Optional[torch.optim.lr_scheduler._LRScheduler] = None,\\n enable_anti_aliasing_loss: Optional[bool] = True,\\n anti_aliasing_pulse_width: Optional[List[float]] = [0.03, 0.003],\\n ) -> None:\\n super().__init__()\\n self.optimizer = optimizer\\n self.scheduler = scheduler\\n self.prop_cache: List = []\\n self.enable_anti_aliasing_loss = enable_anti_aliasing_loss\\n self.pulse_width = anti_aliasing_pulse_width\\n if self.enable_anti_aliasing_loss:\\n logger.info(\\\"Enable anti-aliasing loss, pulse width: %s\\\", self.pulse_width)\\n\\n @torch.no_grad()\\n def sampling(\\n self,\\n prop_sigma_fns: List[Callable],\\n prop_samples: List[int],\\n num_samples: int,\\n # rendering options\\n n_rays: int,\\n near_plane: float,\\n far_plane: float,\\n sampling_type: Literal[\\n \\\"uniform\\\", \\\"lindisp\\\", \\\"sqrt\\\", \\\"log\\\", \\\"uniform_lindisp\\\"\\n ] = \\\"uniform_lindisp\\\",\\n # training options\\n stratified: bool = False,\\n requires_grad: bool = False,\\n ) -> Tuple[Tensor, Tensor]:\\n \\\"\\\"\\\"Sampling with CDFs from proposal networks.\\n\\n Note:\\n When `requires_grad` is `True`, the gradients are allowed to flow\\n through the proposal networks, and the outputs of the proposal\\n networks are cached to update them later when calling `update_every_n_steps()`\\n\\n Args:\\n prop_sigma_fns: Proposal network evaluate functions. It should be a list\\n of functions that take in samples {t_starts (n_rays, n_samples),\\n t_ends (n_rays, n_samples)} and returns the post-activation densities\\n (n_rays, n_samples).\\n prop_samples: Number of samples to draw from each proposal network. Should\\n be the same length as `prop_sigma_fns`.\\n num_samples: Number of samples to draw in the end.\\n n_rays: Number of rays.\\n near_plane: Near plane.\\n far_plane: Far plane.\\n sampling_type: Sampling type. Either \\\"uniform\\\" or \\\"lindisp\\\". Default to\\n \\\"lindisp\\\".\\n stratified: Whether to use stratified sampling. Default to `False`.\\n requires_grad: Whether to allow gradients to flow through the proposal\\n networks. Default to `False`.\\n\\n Returns:\\n A tuple of {Tensor, Tensor}:\\n\\n - **t_starts**: The starts of the samples. Shape (n_rays, num_samples).\\n - **t_ends**: The ends of the samples. Shape (n_rays, num_samples).\\n\\n \\\"\\\"\\\"\\n assert len(prop_sigma_fns) == len(prop_samples), (\\n \\\"The number of proposal networks and the number of samples \\\"\\n \\\"should be the same.\\\"\\n )\\n cdfs = torch.cat(\\n [\\n torch.zeros((n_rays, 1), device=self.device),\\n torch.ones((n_rays, 1), device=self.device),\\n ],\\n dim=-1,\\n )\\n intervals = RayIntervals(vals=cdfs)\\n\\n for i, (level_fn, level_samples) in enumerate(\\n zip(prop_sigma_fns, prop_samples)\\n ):\\n intervals, _ = importance_sampling(\\n intervals, cdfs, level_samples, stratified\\n )\\n t_vals = _transform_stot(\\n sampling_type, intervals.vals, near_plane, far_plane\\n )\\n t_starts = t_vals[..., :-1]\\n t_ends = t_vals[..., 1:]\\n\\n with torch.set_grad_enabled(requires_grad):\\n sigmas = level_fn(t_starts, t_ends)[\\\"density\\\"].squeeze(-1)\\n assert sigmas.shape == t_starts.shape\\n trans, _ = render_transmittance_from_density(t_starts, t_ends, sigmas)\\n cdfs = 1.0 - torch.cat(\\n [trans, torch.zeros_like(trans[..., :1])], dim=-1\\n )\\n if requires_grad:\\n self.prop_cache.append((intervals, cdfs, i))\\n\\n intervals, _ = importance_sampling(intervals, cdfs, num_samples, stratified)\\n t_vals = _transform_stot(sampling_type, intervals.vals, near_plane, far_plane)\\n t_starts = t_vals[..., :-1]\\n t_ends = t_vals[..., 1:]\\n if requires_grad:\\n self.prop_cache.append((intervals, None, None))\\n\\n return t_starts, t_ends\\n\\n @torch.enable_grad()\\n def compute_loss(self, trans: Tensor, loss_scaler: float = 1.0) -> Tensor:\\n \\\"\\\"\\\"Compute the loss for the proposal networks.\\n\\n Args:\\n trans: The transmittance of all samples. Shape (n_rays, num_samples).\\n loss_scaler: The loss scaler. Default to 1.0.\\n\\n Returns:\\n The loss for the proposal networks.\\n \\\"\\\"\\\"\\n if len(self.prop_cache) == 0:\\n return torch.zeros((), device=self.device)\\n\\n intervals, _, _ = self.prop_cache.pop()\\n # get cdfs at all edges of intervals\\n cdfs = 1.0 - torch.cat([trans, torch.zeros_like(trans[..., :1])], dim=-1)\\n cdfs = cdfs.detach()\\n loss = 0.0\\n\\n if self.enable_anti_aliasing_loss:\\n w_normalize = (cdfs[..., 1:] - cdfs[..., :-1]) / (\\n intervals.vals[..., 1:] - intervals.vals[..., :-1]\\n )\\n c1, w1 = blur_stepfun(intervals.vals, w_normalize, self.pulse_width[0])\\n c2, w2 = blur_stepfun(intervals.vals, w_normalize, self.pulse_width[1])\\n area1 = 0.5 * (w1[..., 1:] + w1[..., :-1]) * (c1[..., 1:] - c1[..., :-1])\\n area2 = 0.5 * (w2[..., 1:] + w2[..., :-1]) * (c2[..., 1:] - c2[..., :-1])\\n cdfs1 = torch.cat(\\n [\\n torch.zeros_like(area1[..., :1]),\\n torch.cumsum(area1, dim=-1),\\n ],\\n dim=-1,\\n )\\n cdfs2 = torch.cat(\\n [\\n torch.zeros_like(area2[..., :1]),\\n torch.cumsum(area2, dim=-1),\\n ],\\n dim=-1,\\n )\\n cs = [c1, c2]\\n ws = [w1, w2]\\n _cdfs = [cdfs1, cdfs2]\\n while self.prop_cache:\\n prop_intervals, prop_cdfs, prop_id = self.prop_cache.pop()\\n wp = prop_cdfs[..., 1:] - prop_cdfs[..., :-1]\\n cdf_interp = sorted_interp_quad(\\n prop_intervals.vals, cs[prop_id], ws[prop_id], _cdfs[prop_id]\\n )\\n w_s = torch.diff(cdf_interp, dim=-1)\\n loss += ((w_s - wp).clamp_min(0) ** 2 / (wp + 1e-5)).mean()\\n else:\\n while self.prop_cache:\\n prop_intervals, prop_cdfs, _ = self.prop_cache.pop()\\n loss += _pdf_loss(intervals, cdfs, prop_intervals, prop_cdfs).mean()\\n return loss * loss_scaler\\n\\n @torch.enable_grad()\\n def update_every_n_steps(\\n self,\\n trans: Tensor,\\n requires_grad: bool = False,\\n loss_scaler: float = 1.0,\\n ) -> float:\\n \\\"\\\"\\\"Update the estimator every n steps during training.\\n\\n Args:\\n trans: The transmittance of all samples. Shape (n_rays, num_samples).\\n requires_grad: Whether to allow gradients to flow through the proposal\\n networks. Default to `False`.\\n loss_scaler: The loss scaler to use. Default to 1.0.\\n\\n Returns:\\n The loss of the proposal networks for logging (a float scalar).\\n \\\"\\\"\\\"\\n if requires_grad:\\n return self._update(trans=trans, loss_scaler=loss_scaler)\\n else:\\n if self.scheduler is not None:\\n self.scheduler.step()\\n return 0.0\\n\\n @torch.enable_grad()\\n def _update(self, trans: Tensor, loss_scaler: float = 1.0) -> float:\\n assert len(self.prop_cache) > 0\\n assert self.optimizer is not None, \\\"No optimizer is provided.\\\"\\n\\n loss = self.compute_loss(trans, loss_scaler)\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n if self.scheduler is not None:\\n self.scheduler.step()\\n return loss.item()\"\n },\n {\n \"identifier\": \"get_proposal_requires_grad_fn\",\n \"path\": \"third_party/nerfacc_prop_net.py\",\n \"snippet\": \"def get_proposal_requires_grad_fn(\\n target: float = 5.0, num_steps: int = 1000\\n) -> Callable:\\n schedule = lambda s: min(s / num_steps, 1.0) * target\\n\\n steps_since_last_grad = 0\\n\\n def proposal_requires_grad_fn(step: int) -> bool:\\n nonlocal steps_since_last_grad\\n target_steps_since_last_grad = schedule(step)\\n requires_grad = steps_since_last_grad > target_steps_since_last_grad\\n if requires_grad:\\n steps_since_last_grad = 0\\n steps_since_last_grad += 1\\n return requires_grad\\n\\n return proposal_requires_grad_fn\"\n },\n {\n \"identifier\": \"MetricLogger\",\n \"path\": \"utils/logging.py\",\n \"snippet\": \"class MetricLogger(object):\\n def __init__(self, delimiter=\\\"\\\\t\\\", output_file=None):\\n self.meters = defaultdict(SmoothedValue)\\n self.delimiter = delimiter\\n self.output_file = output_file\\n\\n def update(self, **kwargs):\\n for k, v in kwargs.items():\\n if isinstance(v, torch.Tensor):\\n v = v.item()\\n assert isinstance(v, (float, int))\\n self.meters[k].update(v)\\n\\n def __getattr__(self, attr):\\n if attr in self.meters:\\n return self.meters[attr]\\n if attr in self.__dict__:\\n return self.__dict__[attr]\\n raise AttributeError(\\n f\\\"'{type(self).__name__}' object has no attribute '{attr}'\\\"\\n )\\n\\n def __str__(self):\\n loss_str = []\\n for name, meter in self.meters.items():\\n loss_str.append(f\\\"{name}: {str(meter)}\\\")\\n return self.delimiter.join(loss_str)\\n\\n def synchronize_between_processes(self):\\n for meter in self.meters.values():\\n meter.synchronize_between_processes()\\n\\n def add_meter(self, name, meter):\\n self.meters[name] = meter\\n\\n def dump_in_output_file(self, iteration, iter_time, data_time):\\n if self.output_file is None:\\n return\\n dict_to_dump = dict(\\n iteration=iteration,\\n iter_time=iter_time,\\n data_time=data_time,\\n )\\n dict_to_dump.update({k: v.median for k, v in self.meters.items()})\\n with open(self.output_file, \\\"a\\\") as f:\\n f.write(json.dumps(dict_to_dump) + \\\"\\\\n\\\")\\n pass\\n\\n def log_every(\\n self, iterable, print_freq, header=None, n_iterations=None, start_iteration=0\\n ):\\n i = start_iteration\\n if not header:\\n header = \\\"\\\"\\n start_time = time.time()\\n end = time.time()\\n iter_time = SmoothedValue(fmt=\\\"{avg:.6f}\\\")\\n data_time = SmoothedValue(fmt=\\\"{avg:.6f}\\\")\\n\\n if n_iterations is None:\\n n_iterations = len(iterable)\\n\\n space_fmt = \\\":\\\" + str(len(str(n_iterations))) + \\\"d\\\"\\n\\n log_list = [\\n header,\\n \\\"[{0\\\" + space_fmt + \\\"}/{1}]\\\",\\n \\\"eta: {eta}\\\",\\n \\\"elapsed: {elapsed_time_str}\\\",\\n \\\"{meters}\\\",\\n \\\"time: {time}\\\",\\n \\\"data: {data}\\\",\\n ]\\n if torch.cuda.is_available():\\n log_list += [\\\"max mem: {memory:.0f}\\\"]\\n\\n log_msg = self.delimiter.join(log_list)\\n MB = 1024.0 * 1024.0\\n for obj in iterable:\\n data_time.update(time.time() - end)\\n yield obj\\n iter_time.update(time.time() - end)\\n if i % print_freq == 0 or i == n_iterations - 1:\\n self.dump_in_output_file(\\n iteration=i, iter_time=iter_time.avg, data_time=data_time.avg\\n )\\n eta_seconds = iter_time.global_avg * (n_iterations - i)\\n eta_string = str(datetime.timedelta(seconds=int(eta_seconds)))\\n elapsed_time = time.time() - start_time\\n elapsed_time_str = str(datetime.timedelta(seconds=int(elapsed_time)))\\n\\n if torch.cuda.is_available():\\n logger.info(\\n log_msg.format(\\n i,\\n n_iterations,\\n eta=eta_string,\\n elapsed_time_str=elapsed_time_str,\\n meters=str(self),\\n time=str(iter_time),\\n data=str(data_time),\\n memory=torch.cuda.max_memory_allocated() / MB,\\n )\\n )\\n else:\\n logger.info(\\n log_msg.format(\\n i,\\n n_iterations,\\n eta=eta_string,\\n meters=str(self),\\n time=str(iter_time),\\n data=str(data_time),\\n )\\n )\\n i += 1\\n end = time.time()\\n if i >= n_iterations:\\n break\\n total_time = time.time() - start_time\\n total_time_str = str(datetime.timedelta(seconds=int(total_time)))\\n logger.info(\\n f\\\"{header} Total time: {total_time_str} ({total_time / n_iterations:.6f} s / it)\\\"\\n )\"\n },\n {\n \"identifier\": \"setup_logging\",\n \"path\": \"utils/logging.py\",\n \"snippet\": \"def setup_logging(\\n output: Optional[str] = None,\\n *,\\n name: Optional[str] = None,\\n level: int = logging.DEBUG,\\n capture_warnings: bool = True,\\n time_string: Optional[str] = None,\\n) -> None:\\n \\\"\\\"\\\"\\n Setup logging.\\n\\n Args:\\n output: A file name or a directory to save log files. If None, log\\n files will not be saved. If output ends with \\\".txt\\\" or \\\".log\\\", it\\n is assumed to be a file name.\\n Otherwise, logs will be saved to `output/log.txt`.\\n name: The name of the logger to configure, by default the root logger.\\n level: The logging level to use.\\n capture_warnings: Whether warnings should be captured as logs.\\n \\\"\\\"\\\"\\n logging.captureWarnings(capture_warnings)\\n _configure_logger(name, level=level, output=output, time_string=time_string)\"\n },\n {\n \"identifier\": \"visualize_voxels\",\n \"path\": \"utils/visualization_tools.py\",\n \"snippet\": \"def visualize_voxels(\\n cfg: OmegaConf,\\n model: RadianceField,\\n proposal_estimator: PropNetEstimator = None,\\n proposal_networks: DensityField = None,\\n dataset: SceneDataset = None,\\n device: str = \\\"cuda\\\",\\n save_html: bool = True,\\n is_dynamic: bool = False,\\n):\\n model.eval()\\n for p in proposal_networks:\\n p.eval()\\n if proposal_estimator is not None:\\n proposal_estimator.eval()\\n if proposal_networks is not None:\\n for p in proposal_networks:\\n p.eval()\\n\\n vis_voxel_aabb = torch.tensor(model.aabb, device=device)\\n # slightly expand the aabb to make sure all points are covered\\n vis_voxel_aabb[1:3] -= 1\\n vis_voxel_aabb[3:] += 1\\n aabb_min, aabb_max = torch.split(vis_voxel_aabb, 3, dim=-1)\\n aabb_length = aabb_max - aabb_min\\n\\n # compute the voxel resolution for visualization\\n static_voxel_resolution = torch.ceil(\\n (aabb_max - aabb_min) / cfg.render.vis_voxel_size\\n ).long()\\n empty_static_voxels = torch.zeros(*static_voxel_resolution, device=device)\\n if is_dynamic:\\n # use a slightly smaller voxel size for dynamic voxels\\n dynamic_voxel_resolution = torch.ceil(\\n (aabb_max - aabb_min) / cfg.render.vis_voxel_size * 0.8\\n ).long()\\n all_occupied_dynamic_points = []\\n empty_dynamic_voxels = torch.zeros(*dynamic_voxel_resolution, device=device)\\n\\n # collect some patches for PCA\\n to_compute_pca_patches = []\\n\\n pbar = tqdm(\\n dataset.full_pixel_set,\\n desc=\\\"querying depth\\\",\\n dynamic_ncols=True,\\n total=len(dataset.full_pixel_set),\\n )\\n for i, data_dict in enumerate(pbar):\\n data_dict = dataset.full_pixel_set[i]\\n for k, v in data_dict.items():\\n data_dict[k] = v.to(device)\\n if i < dataset.num_cams:\\n # collect all patches from the first timestep\\n with torch.no_grad():\\n render_results = render_rays(\\n radiance_field=model,\\n proposal_estimator=proposal_estimator,\\n proposal_networks=proposal_networks,\\n data_dict=data_dict,\\n cfg=cfg,\\n proposal_requires_grad=False,\\n )\\n if \\\"dino_pe_free\\\" in render_results:\\n dino_feats = render_results[\\\"dino_pe_free\\\"]\\n else:\\n dino_feats = render_results[\\\"dino_feat\\\"]\\n dino_feats = dino_feats.reshape(-1, dino_feats.shape[-1])\\n to_compute_pca_patches.append(dino_feats)\\n # query the depth. we force a lidar mode here so that the renderer will skip\\n # querying other features such as colors, features, etc.\\n data_dict[\\\"lidar_origins\\\"] = data_dict[\\\"origins\\\"].to(device)\\n data_dict[\\\"lidar_viewdirs\\\"] = data_dict[\\\"viewdirs\\\"].to(device)\\n data_dict[\\\"lidar_normed_timestamps\\\"] = data_dict[\\\"normed_timestamps\\\"].to(device)\\n with torch.no_grad():\\n render_results = render_rays(\\n radiance_field=model,\\n proposal_estimator=proposal_estimator,\\n proposal_networks=proposal_networks,\\n data_dict=data_dict,\\n cfg=cfg,\\n proposal_requires_grad=False,\\n prefix=\\\"lidar_\\\", # force lidar mode\\n return_decomposition=True,\\n )\\n # ==== get the static voxels ======\\n if is_dynamic:\\n static_depth = render_results[\\\"static_depth\\\"]\\n else:\\n static_depth = render_results[\\\"depth\\\"]\\n world_coords = (\\n data_dict[\\\"lidar_origins\\\"] + data_dict[\\\"lidar_viewdirs\\\"] * static_depth\\n )\\n world_coords = world_coords[static_depth.squeeze() < 80]\\n voxel_coords = world_coords_to_voxel_coords(\\n world_coords, aabb_min, aabb_max, static_voxel_resolution\\n )\\n voxel_coords = voxel_coords.long()\\n selector = (\\n (voxel_coords[..., 0] >= 0)\\n & (voxel_coords[..., 0] < static_voxel_resolution[0])\\n & (voxel_coords[..., 1] >= 0)\\n & (voxel_coords[..., 1] < static_voxel_resolution[1])\\n & (voxel_coords[..., 2] >= 0)\\n & (voxel_coords[..., 2] < static_voxel_resolution[2])\\n )\\n # split the voxel_coords into separate dimensions\\n voxel_coords_x = voxel_coords[..., 0][selector]\\n voxel_coords_y = voxel_coords[..., 1][selector]\\n voxel_coords_z = voxel_coords[..., 2][selector]\\n # index into empty_voxels using the separated coordinates\\n empty_static_voxels[voxel_coords_x, voxel_coords_y, voxel_coords_z] = 1\\n\\n # ==== get the dynamic voxels ======\\n if is_dynamic:\\n dynamic_depth = render_results[\\\"dynamic_depth\\\"]\\n world_coords = (\\n data_dict[\\\"lidar_origins\\\"] + data_dict[\\\"lidar_viewdirs\\\"] * dynamic_depth\\n )\\n voxel_coords = world_coords_to_voxel_coords(\\n world_coords, aabb_min, aabb_max, dynamic_voxel_resolution\\n )\\n voxel_coords = voxel_coords.long()\\n selector = (\\n (voxel_coords[..., 0] >= 0)\\n & (voxel_coords[..., 0] < dynamic_voxel_resolution[0])\\n & (voxel_coords[..., 1] >= 0)\\n & (voxel_coords[..., 1] < dynamic_voxel_resolution[1])\\n & (voxel_coords[..., 2] >= 0)\\n & (voxel_coords[..., 2] < dynamic_voxel_resolution[2])\\n )\\n # split the voxel_coords into separate dimensions\\n voxel_coords_x = voxel_coords[..., 0][selector]\\n voxel_coords_y = voxel_coords[..., 1][selector]\\n voxel_coords_z = voxel_coords[..., 2][selector]\\n # index into empty_voxels using the separated coordinates\\n empty_dynamic_voxels[voxel_coords_x, voxel_coords_y, voxel_coords_z] = 1\\n if i % dataset.num_cams == 0 and i > 0:\\n all_occupied_dynamic_points.append(\\n voxel_coords_to_world_coords(\\n aabb_min,\\n aabb_max,\\n dynamic_voxel_resolution,\\n torch.nonzero(empty_dynamic_voxels),\\n )\\n )\\n empty_dynamic_voxels = torch.zeros(\\n *dynamic_voxel_resolution, device=device\\n )\\n # compute the pca reduction\\n dummy_pca_reduction, color_min, color_max = get_robust_pca(\\n torch.cat(to_compute_pca_patches, dim=0).to(device), m=2.5\\n )\\n # now let's query the features\\n all_occupied_static_points = voxel_coords_to_world_coords(\\n aabb_min, aabb_max, static_voxel_resolution, torch.nonzero(empty_static_voxels)\\n )\\n chunk = 2**18\\n pca_colors = []\\n occupied_points = []\\n pbar = tqdm(\\n range(0, all_occupied_static_points.shape[0], chunk),\\n desc=\\\"querying static features\\\",\\n dynamic_ncols=True,\\n )\\n for i in pbar:\\n occupied_points_chunk = all_occupied_static_points[i : i + chunk]\\n density_list = []\\n # we need to accumulate the density from all proposal networks as well\\n # to ensure reliable density estimation\\n for p in proposal_networks:\\n density_list.append(p(occupied_points_chunk)[\\\"density\\\"].squeeze(-1))\\n with torch.no_grad():\\n results = model.forward(\\n occupied_points_chunk,\\n query_feature_head=False,\\n )\\n density_list.append(results[\\\"density\\\"])\\n density = torch.stack(density_list, dim=0)\\n density = torch.mean(density, dim=0)\\n # use a preset threshold to determine whether a voxel is occupied\\n selector = density > 0.5\\n occupied_points_chunk = occupied_points_chunk[selector]\\n if len(occupied_points_chunk) == 0:\\n # skip if no occupied points in this chunk\\n continue\\n with torch.no_grad():\\n feats = model.forward(\\n occupied_points_chunk,\\n query_feature_head=True,\\n query_pe_head=False,\\n )[\\\"dino_feat\\\"]\\n colors = feats @ dummy_pca_reduction\\n del feats\\n colors = (colors - color_min) / (color_max - color_min)\\n pca_colors.append(torch.clamp(colors, 0, 1))\\n occupied_points.append(occupied_points_chunk)\\n\\n pca_colors = torch.cat(pca_colors, dim=0)\\n occupied_points = torch.cat(occupied_points, dim=0)\\n if is_dynamic:\\n dynamic_pca_colors = []\\n dynamic_occupied_points = []\\n unq_timestamps = dataset.pixel_source.unique_normalized_timestamps.to(device)\\n # query every 10 frames\\n pbar = tqdm(\\n range(0, len(all_occupied_dynamic_points), 10),\\n desc=\\\"querying dynamic fields\\\",\\n dynamic_ncols=True,\\n )\\n for i in pbar:\\n occupied_points_chunk = all_occupied_dynamic_points[i]\\n normed_timestamps = unq_timestamps[i].repeat(\\n occupied_points_chunk.shape[0], 1\\n )\\n with torch.no_grad():\\n results = model.forward(\\n occupied_points_chunk,\\n data_dict={\\\"normed_timestamps\\\": normed_timestamps},\\n query_feature_head=False,\\n )\\n selector = results[\\\"dynamic_density\\\"].squeeze() > 0.1\\n occupied_points_chunk = occupied_points_chunk[selector]\\n if len(occupied_points_chunk) == 0:\\n continue\\n # query some features\\n normed_timestamps = unq_timestamps[i].repeat(\\n occupied_points_chunk.shape[0], 1\\n )\\n with torch.no_grad():\\n feats = model.forward(\\n occupied_points_chunk,\\n data_dict={\\\"normed_timestamps\\\": normed_timestamps},\\n query_feature_head=True,\\n query_pe_head=False,\\n )[\\\"dynamic_dino_feat\\\"]\\n colors = feats @ dummy_pca_reduction\\n del feats\\n colors = (colors - color_min) / (color_max - color_min)\\n dynamic_pca_colors.append(torch.clamp(colors, 0, 1))\\n dynamic_occupied_points.append(occupied_points_chunk)\\n dynamic_coords = [x.cpu().numpy() for x in dynamic_occupied_points]\\n dynamic_colors = [x.cpu().numpy() for x in dynamic_pca_colors]\\n else:\\n dynamic_coords = None\\n dynamic_colors = None\\n\\n figure = vis_occ_plotly(\\n vis_aabb=vis_voxel_aabb.cpu().numpy().tolist(),\\n coords=occupied_points.cpu().numpy(),\\n colors=pca_colors.cpu().numpy(),\\n dynamic_coords=dynamic_coords,\\n dynamic_colors=dynamic_colors,\\n x_ratio=1,\\n y_ratio=(aabb_length[1] / aabb_length[0]).item(),\\n z_ratio=(aabb_length[2] / aabb_length[0]).item(),\\n size=3,\\n black_bg=True,\\n title=f\\\"Lifted {cfg.data.pixel_source.feature_model_type} Features, PE_removed: {cfg.nerf.model.head.enable_learnable_pe}\\\",\\n )\\n # for plotly\\n data = figure.to_dict()[\\\"data\\\"]\\n layout = figure.to_dict()[\\\"layout\\\"]\\n output_path = os.path.join(cfg.log_dir, f\\\"feature_field.json\\\")\\n with open(output_path, \\\"w\\\") as f:\\n json.dump({\\\"data\\\": data, \\\"layout\\\": layout}, f, cls=NumpyEncoder)\\n logger.info(f\\\"Saved to {output_path}\\\")\\n output_path = os.path.join(cfg.log_dir, f\\\"feature_field.html\\\")\\n if save_html:\\n figure.write_html(output_path)\\n logger.info(f\\\"Query result saved to {output_path}\\\")\"\n },\n {\n \"identifier\": \"visualize_scene_flow\",\n \"path\": \"utils/visualization_tools.py\",\n \"snippet\": \"def visualize_scene_flow(\\n cfg: OmegaConf,\\n model: RadianceField,\\n dataset: SceneDataset = None,\\n device: str = \\\"cuda\\\",\\n save_html: bool = True,\\n):\\n pbar = tqdm(\\n range(0, len(dataset.full_lidar_set) - 1, 10),\\n desc=\\\"querying flow\\\",\\n dynamic_ncols=True,\\n )\\n predicted_flow_colors, gt_flow_colors = [], []\\n dynamic_coords = []\\n for i in pbar:\\n data_dict = dataset.full_lidar_set[i].copy()\\n lidar_flow_class = data_dict[\\\"lidar_flow_class\\\"]\\n for k, v in data_dict.items():\\n # remove invalid flow (the information is from GT)\\n data_dict[k] = v[lidar_flow_class != -1]\\n\\n if data_dict[k].shape[0] == 0:\\n logger.info(f\\\"no valid points, skipping...\\\")\\n continue\\n # filter out ground points\\n # for k, v in data_dict.items():\\n # data_dict[k] = v[~data_dict[\\\"lidar_ground\\\"]]\\n valid_lidar_mask = dataset.get_valid_lidar_mask(i, data_dict)\\n for k, v in data_dict.items():\\n data_dict[k] = v[valid_lidar_mask]\\n lidar_points = (\\n data_dict[\\\"lidar_origins\\\"]\\n + data_dict[\\\"lidar_ranges\\\"] * data_dict[\\\"lidar_viewdirs\\\"]\\n )\\n normalized_timestamps = data_dict[\\\"lidar_normed_timestamps\\\"]\\n with torch.no_grad():\\n pred_results = model.query_flow(\\n positions=lidar_points,\\n normed_timestamps=normalized_timestamps,\\n )\\n pred_flow = pred_results[\\\"forward_flow\\\"]\\n # flow is only valid when the point is not static\\n pred_flow[pred_results[\\\"dynamic_density\\\"] < 0.2] *= 0\\n\\n predicted_flow_colors.append(\\n scene_flow_to_rgb(pred_flow, flow_max_radius=2.0, background=\\\"bright\\\")\\n .cpu()\\n .numpy()\\n )\\n gt_flow_colors.append(\\n scene_flow_to_rgb(\\n data_dict[\\\"lidar_flow\\\"], flow_max_radius=2.0, background=\\\"bright\\\"\\n )\\n .cpu()\\n .numpy()\\n )\\n dynamic_coords.append(lidar_points.cpu().numpy())\\n\\n vis_voxel_aabb = torch.tensor(model.aabb, device=device)\\n # slightly expand the aabb to make sure all points are covered\\n vis_voxel_aabb[1:3] -= 1\\n vis_voxel_aabb[3:] += 1\\n aabb_min, aabb_max = torch.split(vis_voxel_aabb, 3, dim=-1)\\n aabb_length = aabb_max - aabb_min\\n pred_figure = vis_occ_plotly(\\n vis_aabb=vis_voxel_aabb.cpu().numpy().tolist(),\\n dynamic_coords=dynamic_coords,\\n dynamic_colors=predicted_flow_colors,\\n x_ratio=1,\\n y_ratio=(aabb_length[1] / aabb_length[0]).item(),\\n z_ratio=(aabb_length[2] / aabb_length[0]).item(),\\n size=2,\\n black_bg=True,\\n title=f\\\"Predicted Flow\\\",\\n )\\n gt_figure = vis_occ_plotly(\\n vis_aabb=vis_voxel_aabb.cpu().numpy().tolist(),\\n dynamic_coords=dynamic_coords,\\n dynamic_colors=gt_flow_colors,\\n x_ratio=1,\\n y_ratio=(aabb_length[1] / aabb_length[0]).item(),\\n z_ratio=(aabb_length[2] / aabb_length[0]).item(),\\n size=2,\\n black_bg=True,\\n title=f\\\"GT Flow\\\",\\n )\\n if save_html:\\n output_path = os.path.join(cfg.log_dir, f\\\"predicted_flow.html\\\")\\n pred_figure.write_html(output_path)\\n logger.info(f\\\"Predicted flow result saved to {output_path}\\\")\\n output_path = os.path.join(cfg.log_dir, f\\\"gt_flow.html\\\")\\n gt_figure.write_html(output_path)\\n logger.info(f\\\"GT flow saved to {output_path}\\\")\"\n }\n]","isConversational":false},"import_statement":{"kind":"string","value":"import argparse\nimport json\nimport logging\nimport os\nimport time\nimport imageio\nimport numpy as np\nimport torch\nimport torch.utils.data\nimport builders\nimport loss\nimport utils.misc as misc\nimport wandb\nfrom typing import List, Optional\nfrom omegaconf import OmegaConf\nfrom tqdm import tqdm\nfrom datasets import metrics\nfrom datasets.base import SceneDataset\nfrom radiance_fields import DensityField, RadianceField\nfrom radiance_fields.render_utils import render_rays\nfrom radiance_fields.video_utils import render_pixels, save_videos\nfrom third_party.nerfacc_prop_net import PropNetEstimator, get_proposal_requires_grad_fn\nfrom utils.logging import MetricLogger, setup_logging\nfrom utils.visualization_tools import visualize_voxels, visualize_scene_flow\n from datasets.waymo import WaymoDataset\n from datasets.nuscenes import NuScenesDataset"},"token_num":{"kind":"number","value":19797,"string":"19,797"},"cropped_code":{"kind":"string","value":" )\n parser.add_argument(\n \"--render_data_video_only\",\n action=\"store_true\",\n help=\"Quit after rendering a data video\",\n )\n parser.add_argument(\n \"--render_video_postfix\",\n type=str,\n default=None,\n help=\"an optional postfix for video\",\n )\n parser.add_argument(\n \"--output_root\",\n default=\"./work_dirs/\",\n help=\"path to save checkpoints and logs\",\n type=str,\n )\n # wandb logging part\n parser.add_argument(\n \"--enable_wandb\", action=\"store_true\", help=\"enable wandb logging\"\n )\n parser.add_argument(\n \"--entity\",\n default=\"YOUR ENTITY NAME\",\n type=str,\n help=\"wandb entity name\",\n required=False,\n )\n parser.add_argument(\n \"--project\",\n default=\"emernerf\",\n type=str,\n help=\"wandb project name, also used to enhance log_dir\",\n required=True,\n )\n parser.add_argument(\n \"--run_name\",\n default=\"debug\",\n type=str,\n help=\"wandb run name, also used to enhance log_dir\",\n required=True,\n )\n parser.add_argument(\n \"opts\",\n help=\"Modify config options using the command-line\",\n default=None,\n nargs=argparse.REMAINDER,\n )\n return parser\n\n\ndef setup(args):\n # ------ get config from args -------- #\n default_config = OmegaConf.create(OmegaConf.load(\"configs/default_config.yaml\"))\n cfg = OmegaConf.load(args.config_file)\n cfg = OmegaConf.merge(default_config, cfg, OmegaConf.from_cli(args.opts))\n log_dir = os.path.join(args.output_root, args.project, args.run_name)\n cfg.log_dir = log_dir\n cfg.nerf.model.num_cams = cfg.data.pixel_source.num_cams\n cfg.nerf.model.unbounded = cfg.nerf.unbounded\n cfg.nerf.propnet.unbounded = cfg.nerf.unbounded\n cfg.nerf.model.resume_from = cfg.resume_from\n os.makedirs(log_dir, exist_ok=True)\n for folder in [\n \"images\",\n \"full_videos\",\n \"test_videos\",\n \"lowres_videos\",\n \"metrics\",\n \"configs_bk\",\n \"buffer_maps\",\n ]:\n os.makedirs(os.path.join(log_dir, folder), exist_ok=True)\n # ------ setup logging -------- #\n if args.enable_wandb:\n # sometimes wandb fails to init in cloud machines, so we give it several (many) tries\n while (\n wandb.init(\n project=args.project,\n entity=args.entity,\n sync_tensorboard=True,\n settings=wandb.Settings(start_method=\"fork\"),\n )\n is not wandb.run\n ):\n continue\n wandb.run.name = args.run_name\n wandb.run.save()\n wandb.config.update(OmegaConf.to_container(cfg, resolve=True))\n wandb.config.update(args)\n\n misc.fix_random_seeds(cfg.optim.seed)\n\n global logger\n setup_logging(output=log_dir, level=logging.INFO, time_string=current_time)\n logger.info(\n \"\\n\".join(\"%s: %s\" % (k, str(v)) for k, v in sorted(dict(vars(args)).items()))\n )\n # -------- write config -------- #\n logger.info(f\"Config:\\n{OmegaConf.to_yaml(cfg)}\")\n saved_cfg_path = os.path.join(log_dir, \"config.yaml\")\n with open(saved_cfg_path, \"w\") as f:\n OmegaConf.save(config=cfg, f=f)\n # also save a backup copy\n saved_cfg_path_bk = os.path.join(\n log_dir, \"configs_bk\", f\"config_{current_time}.yaml\"\n )\n with open(saved_cfg_path_bk, \"w\") as f:\n OmegaConf.save(config=cfg, f=f)\n logger.info(f\"Full config saved to {saved_cfg_path}, and {saved_cfg_path_bk}\")\n return cfg\n\n\n@torch.no_grad()\ndef do_evaluation(\n step: int = 0,\n cfg: OmegaConf = None,\n model: RadianceField = None,\n proposal_networks: Optional[List[DensityField]] = None,\n"},"all_code":{"kind":"string","value":"\n\n\nlogger = logging.getLogger()\ncurrent_time = time.strftime(\"%Y-%m-%d_%H-%M-%S\", time.localtime())\n\n# a global list of keys to render,\n# comment out the keys you don't want to render or uncomment the keys you want to render\nrender_keys = [\n \"gt_rgbs\",\n \"rgbs\",\n \"depths\",\n # \"median_depths\",\n \"gt_dino_feats\",\n \"dino_feats\",\n \"dynamic_rgbs\",\n \"dynamic_depths\",\n \"static_rgbs\",\n \"static_depths\",\n \"forward_flows\",\n \"backward_flows\",\n \"dynamic_rgb_on_static_dinos\",\n \"dino_pe\",\n \"dino_feats_pe_free\",\n # \"dynamic_dino_on_static_rgbs\",\n # \"shadow_reduced_static_rgbs\",\n # \"shadow_only_static_rgbs\",\n # \"shadows\",\n # \"gt_sky_masks\",\n # \"sky_masks\",\n]\n\n\ndef get_args_parser():\n parser = argparse.ArgumentParser(\"Train EmernNerf for a single scene\")\n parser.add_argument(\"--config_file\", help=\"path to config file\", type=str)\n parser.add_argument(\n \"--eval_only\", action=\"store_true\", help=\"perform evaluation only\"\n )\n parser.add_argument(\n \"--visualize_voxel\", action=\"store_true\", help=\"perform evaluation only\"\n )\n parser.add_argument(\n \"--render_data_video\",\n action=\"store_true\",\n help=\"Render a data video\",\n )\n parser.add_argument(\n \"--render_data_video_only\",\n action=\"store_true\",\n help=\"Quit after rendering a data video\",\n )\n parser.add_argument(\n \"--render_video_postfix\",\n type=str,\n default=None,\n help=\"an optional postfix for video\",\n )\n parser.add_argument(\n \"--output_root\",\n default=\"./work_dirs/\",\n help=\"path to save checkpoints and logs\",\n type=str,\n )\n # wandb logging part\n parser.add_argument(\n \"--enable_wandb\", action=\"store_true\", help=\"enable wandb logging\"\n )\n parser.add_argument(\n \"--entity\",\n default=\"YOUR ENTITY NAME\",\n type=str,\n help=\"wandb entity name\",\n required=False,\n )\n parser.add_argument(\n \"--project\",\n default=\"emernerf\",\n type=str,\n help=\"wandb project name, also used to enhance log_dir\",\n required=True,\n )\n parser.add_argument(\n \"--run_name\",\n default=\"debug\",\n type=str,\n help=\"wandb run name, also used to enhance log_dir\",\n required=True,\n )\n parser.add_argument(\n \"opts\",\n help=\"Modify config options using the command-line\",\n default=None,\n nargs=argparse.REMAINDER,\n )\n return parser\n\n\ndef setup(args):\n # ------ get config from args -------- #\n default_config = OmegaConf.create(OmegaConf.load(\"configs/default_config.yaml\"))\n cfg = OmegaConf.load(args.config_file)\n cfg = OmegaConf.merge(default_config, cfg, OmegaConf.from_cli(args.opts))\n log_dir = os.path.join(args.output_root, args.project, args.run_name)\n cfg.log_dir = log_dir\n cfg.nerf.model.num_cams = cfg.data.pixel_source.num_cams\n cfg.nerf.model.unbounded = cfg.nerf.unbounded\n cfg.nerf.propnet.unbounded = cfg.nerf.unbounded\n cfg.nerf.model.resume_from = cfg.resume_from\n os.makedirs(log_dir, exist_ok=True)\n for folder in [\n \"images\",\n \"full_videos\",\n \"test_videos\",\n \"lowres_videos\",\n \"metrics\",\n \"configs_bk\",\n \"buffer_maps\",\n ]:\n os.makedirs(os.path.join(log_dir, folder), exist_ok=True)\n # ------ setup logging -------- #\n if args.enable_wandb:\n # sometimes wandb fails to init in cloud machines, so we give it several (many) tries\n while (\n wandb.init(\n project=args.project,\n entity=args.entity,\n sync_tensorboard=True,\n settings=wandb.Settings(start_method=\"fork\"),\n )\n is not wandb.run\n ):\n continue\n wandb.run.name = args.run_name\n wandb.run.save()\n wandb.config.update(OmegaConf.to_container(cfg, resolve=True))\n wandb.config.update(args)\n\n misc.fix_random_seeds(cfg.optim.seed)\n\n global logger\n setup_logging(output=log_dir, level=logging.INFO, time_string=current_time)\n logger.info(\n \"\\n\".join(\"%s: %s\" % (k, str(v)) for k, v in sorted(dict(vars(args)).items()))\n )\n # -------- write config -------- #\n logger.info(f\"Config:\\n{OmegaConf.to_yaml(cfg)}\")\n saved_cfg_path = os.path.join(log_dir, \"config.yaml\")\n with open(saved_cfg_path, \"w\") as f:\n OmegaConf.save(config=cfg, f=f)\n # also save a backup copy\n saved_cfg_path_bk = os.path.join(\n log_dir, \"configs_bk\", f\"config_{current_time}.yaml\"\n )\n with open(saved_cfg_path_bk, \"w\") as f:\n OmegaConf.save(config=cfg, f=f)\n logger.info(f\"Full config saved to {saved_cfg_path}, and {saved_cfg_path_bk}\")\n return cfg\n\n\n@torch.no_grad()\ndef do_evaluation(\n step: int = 0,\n cfg: OmegaConf = None,\n model: RadianceField = None,\n proposal_networks: Optional[List[DensityField]] = None,"},"next_line":{"kind":"string","value":" proposal_estimator: PropNetEstimator = None,"},"gold_snippet_index":{"kind":"number","value":7,"string":"7"},"created_at":{"kind":"string","value":"2023-10-11 20:56:27+00:00"},"level":{"kind":"string","value":"24k"}}}],"truncated":false,"partial":false},"paginationData":{"pageIndex":56,"numItemsPerPage":100,"numTotalItems":8033,"offset":5600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSJ9.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc3NDE1MDYyMywic3ViIjoiL2RhdGFzZXRzL3RpYW55YW5nL3JlcG9iZW5jaF9weXRob25fdjEuMSIsImV4cCI6MTc3NDE1NDIyMywiaXNzIjoiaHR0cHM6Ly9odWdnaW5nZmFjZS5jbyJ9.3STpb7hELINsqaCKOGhWOMNvY-lBRZIf02qrASXcuqholZJ_o8iaSKlGAudjcQy7bvzHnZpKFo9lHdY_U1UHCQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"cross_file_first","numRows":8033,"numBytesParquet":163954346},{"config":"default","split":"cross_file_random","numRows":7618,"numBytesParquet":153067110},{"config":"default","split":"in_file","numRows":7910,"numBytesParquet":155972843}]},"discussionsStats":{"closed":0,"open":1,"total":1},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[{"views":[{"key":"default/cross_file_first","displayName":"cross_file_first","viewName":"cross_file_first"},{"key":"default/cross_file_random","displayName":"cross_file_random","viewName":"cross_file_random"},{"key":"default/in_file","displayName":"in_file","viewName":"in_file"}],"sql":"WITH matched AS (\n SELECT cff_repo\n FROM same_split\n WHERE cff_level IN ('2k','4k','8k','12k')\n GROUP BY cff_repo\n HAVING COUNT(DISTINCT cff_level) = 4\n)\nSELECT scff.cff_repo, scff.cff_level, scff.cff_next_line, scff.cff_file_path\nFROM same_split scff\nJOIN matched m\n ON scff.cff_repo = m.cff_repo\nWHERE scff.cff_level IN ('2k','4k','8k','12k')\nORDER BY scff.cff_level, scff.cff_repo, scff.cff_next_line;","title":"SQL Console for tianyang/repobench_python_v1.1","createdAt":"2026-02-16T12:58:32.763Z","slug":"GYS17Jn","private":false,"justification":"Identifies repositories that have consistent code formatting levels across multiple scales (2k, 4k, 8k, 12k) and reveals the structured formatting patterns within these repositories.","viewNames":["cross_file_first","cross_file_random","in_file"]},{"views":[{"key":"default/cross_file_first","displayName":"cross_file_first","viewName":"cross_file_first"},{"key":"default/cross_file_random","displayName":"cross_file_random","viewName":"cross_file_random"},{"key":"default/in_file","displayName":"in_file","viewName":"in_file"}],"sql":" SELECT\n cff.repo_name as cff_repo,\n cff.file_path as cff_file_path,\n cff.level AS cff_level,\n cff.next_line AS cff_next_line,\n cfr.repo_name as cfr_repo,\n cfr.file_path as cfr_file_path,\n cfr.level AS cfr_level,\n cfr.next_line AS cfr_next_line,\n iff.repo_name as iff_repo,\n iff.file_path as iff_file_path,\n iff.level AS iff_level,\n iff.next_line AS iff_next_line,\n FROM cross_file_first cff\n JOIN cross_file_random cfr\n ON cff.repo_name = cfr.repo_name and cff.file_path = cfr.file_path\n JOIN in_file iff\n ON cff.repo_name = iff.repo_name and cff.file_path = iff.file_path\n WHERE cff.level IN ('2k','4k','8k','12k','16k','24k','32k')\nORDER BY cff_level;","title":"SQL Console for tianyang/repobench_python_v1.1","createdAt":"2026-02-16T12:18:39.032Z","slug":"QYIEEK-","private":false,"justification":"Compares cross-file and in-file code structure patterns across different complexity levels, revealing how file organization strategies vary with code size and potentially informing better code architecture decisions.","viewNames":["cross_file_first","cross_file_random","in_file"]},{"views":[{"key":"default/cross_file_first","displayName":"cross_file_first","viewName":"cross_file_first"},{"key":"default/cross_file_random","displayName":"cross_file_random","viewName":"cross_file_random"},{"key":"default/in_file","displayName":"in_file","viewName":"in_file"}],"sql":"WITH matched AS (\n SELECT repo_name\n FROM cross_file_first\n WHERE level IN ('2k','4k','8k','12k','16k','24k','32k')\n GROUP BY repo_name\n HAVING COUNT(DISTINCT level) = 7\n)\nSELECT cff.repo_name, cff.level, cff.next_line\nFROM cross_file_first cff\nJOIN matched m\n ON cff.repo_name = m.repo_name\nWHERE cff.level IN ('2k','4k','8k','12k','16k','24k','32k')\nORDER BY cff.repo_name, cff.next_line, cff.level;","title":"SQL Console for tianyang/repobench_python_v1.1","createdAt":"2026-02-16T11:10:16.565Z","slug":"KP5rZyR","private":false,"justification":"Identifies repositories that have complete performance data across all seven code complexity levels, revealing consistent benchmarking patterns across different code sizes.","viewNames":["cross_file_first","cross_file_random","in_file"]},{"views":[{"key":"default/cross_file_first","displayName":"cross_file_first","viewName":"cross_file_first"},{"key":"default/cross_file_random","displayName":"cross_file_random","viewName":"cross_file_random"},{"key":"default/in_file","displayName":"in_file","viewName":"in_file"}],"sql":"SELECT repo_name, COUNT(DISTINCT level) AS levels_present\nFROM cross_file_first\nWHERE level IN ('2k','4k','8k','12k','16k','24k','32k')\nGROUP BY repo_name\nHAVING COUNT(DISTINCT level) = 7;\n","title":"SQL Console for tianyang/repobench_python_v1.1","createdAt":"2026-02-16T11:07:20.043Z","slug":"jD2BZzH","private":false,"justification":"Identifies repositories that contain all 7 distinct quality levels (2k through 32k), revealing complete datasets that might be useful for comprehensive analysis.","viewNames":["cross_file_first","cross_file_random","in_file"]}],"user":[]}}">
repo_name stringlengths 7 71 | file_path stringlengths 5 118 | context list | import_statement stringlengths 45 12.5k | token_num int64 641 99.4k | cropped_code stringlengths 44 17k | all_code stringlengths 43 754k | next_line stringlengths 2 330 | gold_snippet_index int64 0 68 | created_at stringlengths 25 25 | level stringclasses 9
values |
|---|---|---|---|---|---|---|---|---|---|---|
AMAAI-Lab/mustango | diffusers/src/diffusers/models/transformer_2d.py | [
{
"identifier": "ConfigMixin",
"path": "diffusers/src/diffusers/configuration_utils.py",
"snippet": "class ConfigMixin:\n r\"\"\"\n Base class for all configuration classes. Stores all configuration parameters under `self.config` Also handles all\n methods for loading/downloading/saving classes... | from dataclasses import dataclass
from typing import Any, Dict, Optional
from torch import nn
from ..configuration_utils import ConfigMixin, register_to_config
from ..models.embeddings import ImagePositionalEmbeddings
from ..utils import BaseOutput, deprecate
from .attention import BasicTransformerBlock
from .embeddings import PatchEmbed
from .modeling_utils import ModelMixin
import torch
import torch.nn.functional as F | 18,093 |
class Transformer2DModel(ModelMixin, ConfigMixin):
"""
Transformer model for image-like data. Takes either discrete (classes of vector embeddings) or continuous (actual
embeddings) inputs.
When input is continuous: First, project the input (aka embedding) and reshape to b, t, d. Then apply standard
transformer action. Finally, reshape to image.
When input is discrete: First, input (classes of latent pixels) is converted to embeddings and has positional
embeddings applied, see `ImagePositionalEmbeddings`. Then apply standard transformer action. Finally, predict
classes of unnoised image.
Note that it is assumed one of the input classes is the masked latent pixel. The predicted classes of the unnoised
image do not contain a prediction for the masked pixel as the unnoised image cannot be masked.
Parameters:
num_attention_heads (`int`, *optional*, defaults to 16): The number of heads to use for multi-head attention.
attention_head_dim (`int`, *optional*, defaults to 88): The number of channels in each head.
in_channels (`int`, *optional*):
Pass if the input is continuous. The number of channels in the input and output.
num_layers (`int`, *optional*, defaults to 1): The number of layers of Transformer blocks to use.
dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
cross_attention_dim (`int`, *optional*): The number of encoder_hidden_states dimensions to use.
sample_size (`int`, *optional*): Pass if the input is discrete. The width of the latent images.
Note that this is fixed at training time as it is used for learning a number of position embeddings. See
`ImagePositionalEmbeddings`.
num_vector_embeds (`int`, *optional*):
Pass if the input is discrete. The number of classes of the vector embeddings of the latent pixels.
Includes the class for the masked latent pixel.
activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward.
num_embeds_ada_norm ( `int`, *optional*): Pass if at least one of the norm_layers is `AdaLayerNorm`.
The number of diffusion steps used during training. Note that this is fixed at training time as it is used
to learn a number of embeddings that are added to the hidden states. During inference, you can denoise for
up to but not more than steps than `num_embeds_ada_norm`.
attention_bias (`bool`, *optional*):
Configure if the TransformerBlocks' attention should contain a bias parameter.
"""
@register_to_config
def __init__(
self,
num_attention_heads: int = 16,
attention_head_dim: int = 88,
in_channels: Optional[int] = None,
out_channels: Optional[int] = None,
num_layers: int = 1,
dropout: float = 0.0,
norm_num_groups: int = 32,
cross_attention_dim: Optional[int] = None,
attention_bias: bool = False,
sample_size: Optional[int] = None,
num_vector_embeds: Optional[int] = None,
patch_size: Optional[int] = None,
activation_fn: str = "geglu",
num_embeds_ada_norm: Optional[int] = None,
use_linear_projection: bool = False,
only_cross_attention: bool = False,
upcast_attention: bool = False,
norm_type: str = "layer_norm",
norm_elementwise_affine: bool = True,
):
super().__init__()
self.use_linear_projection = use_linear_projection
self.num_attention_heads = num_attention_heads
self.attention_head_dim = attention_head_dim
inner_dim = num_attention_heads * attention_head_dim
# 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
# Define whether input is continuous or discrete depending on configuration
self.is_input_continuous = (in_channels is not None) and (patch_size is None)
self.is_input_vectorized = num_vector_embeds is not None
self.is_input_patches = in_channels is not None and patch_size is not None
if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
deprecation_message = (
f"The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or"
" incorrectly set to `'layer_norm'`.Make sure to set `norm_type` to `'ada_norm'` in the config."
" Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect"
" results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it"
" would be very nice if you could open a Pull request for the `transformer/config.json` file"
)
deprecate("norm_type!=num_embeds_ada_norm", "1.0.0", deprecation_message, standard_warn=False)
norm_type = "ada_norm"
if self.is_input_continuous and self.is_input_vectorized:
raise ValueError(
f"Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make"
" sure that either `in_channels` or `num_vector_embeds` is None."
)
elif self.is_input_vectorized and self.is_input_patches:
raise ValueError(
f"Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make"
" sure that either `num_vector_embeds` or `num_patches` is None."
)
elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
raise ValueError(
f"Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:"
f" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None."
)
# 2. Define input layers
if self.is_input_continuous:
self.in_channels = in_channels
self.norm = torch.nn.GroupNorm(num_groups=norm_num_groups, num_channels=in_channels, eps=1e-6, affine=True)
if use_linear_projection:
self.proj_in = nn.Linear(in_channels, inner_dim)
else:
self.proj_in = nn.Conv2d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
elif self.is_input_vectorized:
assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"
self.height = sample_size
self.width = sample_size
self.num_vector_embeds = num_vector_embeds
self.num_latent_pixels = self.height * self.width
| # Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
@dataclass
class Transformer2DModelOutput(BaseOutput):
"""
Args:
sample (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)` or `(batch size, num_vector_embeds - 1, num_latent_pixels)` if [`Transformer2DModel`] is discrete):
Hidden states conditioned on `encoder_hidden_states` input. If discrete, returns probability distributions
for the unnoised latent pixels.
"""
sample: torch.FloatTensor
class Transformer2DModel(ModelMixin, ConfigMixin):
"""
Transformer model for image-like data. Takes either discrete (classes of vector embeddings) or continuous (actual
embeddings) inputs.
When input is continuous: First, project the input (aka embedding) and reshape to b, t, d. Then apply standard
transformer action. Finally, reshape to image.
When input is discrete: First, input (classes of latent pixels) is converted to embeddings and has positional
embeddings applied, see `ImagePositionalEmbeddings`. Then apply standard transformer action. Finally, predict
classes of unnoised image.
Note that it is assumed one of the input classes is the masked latent pixel. The predicted classes of the unnoised
image do not contain a prediction for the masked pixel as the unnoised image cannot be masked.
Parameters:
num_attention_heads (`int`, *optional*, defaults to 16): The number of heads to use for multi-head attention.
attention_head_dim (`int`, *optional*, defaults to 88): The number of channels in each head.
in_channels (`int`, *optional*):
Pass if the input is continuous. The number of channels in the input and output.
num_layers (`int`, *optional*, defaults to 1): The number of layers of Transformer blocks to use.
dropout (`float`, *optional*, defaults to 0.0): The dropout probability to use.
cross_attention_dim (`int`, *optional*): The number of encoder_hidden_states dimensions to use.
sample_size (`int`, *optional*): Pass if the input is discrete. The width of the latent images.
Note that this is fixed at training time as it is used for learning a number of position embeddings. See
`ImagePositionalEmbeddings`.
num_vector_embeds (`int`, *optional*):
Pass if the input is discrete. The number of classes of the vector embeddings of the latent pixels.
Includes the class for the masked latent pixel.
activation_fn (`str`, *optional*, defaults to `"geglu"`): Activation function to be used in feed-forward.
num_embeds_ada_norm ( `int`, *optional*): Pass if at least one of the norm_layers is `AdaLayerNorm`.
The number of diffusion steps used during training. Note that this is fixed at training time as it is used
to learn a number of embeddings that are added to the hidden states. During inference, you can denoise for
up to but not more than steps than `num_embeds_ada_norm`.
attention_bias (`bool`, *optional*):
Configure if the TransformerBlocks' attention should contain a bias parameter.
"""
@register_to_config
def __init__(
self,
num_attention_heads: int = 16,
attention_head_dim: int = 88,
in_channels: Optional[int] = None,
out_channels: Optional[int] = None,
num_layers: int = 1,
dropout: float = 0.0,
norm_num_groups: int = 32,
cross_attention_dim: Optional[int] = None,
attention_bias: bool = False,
sample_size: Optional[int] = None,
num_vector_embeds: Optional[int] = None,
patch_size: Optional[int] = None,
activation_fn: str = "geglu",
num_embeds_ada_norm: Optional[int] = None,
use_linear_projection: bool = False,
only_cross_attention: bool = False,
upcast_attention: bool = False,
norm_type: str = "layer_norm",
norm_elementwise_affine: bool = True,
):
super().__init__()
self.use_linear_projection = use_linear_projection
self.num_attention_heads = num_attention_heads
self.attention_head_dim = attention_head_dim
inner_dim = num_attention_heads * attention_head_dim
# 1. Transformer2DModel can process both standard continuous images of shape `(batch_size, num_channels, width, height)` as well as quantized image embeddings of shape `(batch_size, num_image_vectors)`
# Define whether input is continuous or discrete depending on configuration
self.is_input_continuous = (in_channels is not None) and (patch_size is None)
self.is_input_vectorized = num_vector_embeds is not None
self.is_input_patches = in_channels is not None and patch_size is not None
if norm_type == "layer_norm" and num_embeds_ada_norm is not None:
deprecation_message = (
f"The configuration file of this model: {self.__class__} is outdated. `norm_type` is either not set or"
" incorrectly set to `'layer_norm'`.Make sure to set `norm_type` to `'ada_norm'` in the config."
" Please make sure to update the config accordingly as leaving `norm_type` might led to incorrect"
" results in future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it"
" would be very nice if you could open a Pull request for the `transformer/config.json` file"
)
deprecate("norm_type!=num_embeds_ada_norm", "1.0.0", deprecation_message, standard_warn=False)
norm_type = "ada_norm"
if self.is_input_continuous and self.is_input_vectorized:
raise ValueError(
f"Cannot define both `in_channels`: {in_channels} and `num_vector_embeds`: {num_vector_embeds}. Make"
" sure that either `in_channels` or `num_vector_embeds` is None."
)
elif self.is_input_vectorized and self.is_input_patches:
raise ValueError(
f"Cannot define both `num_vector_embeds`: {num_vector_embeds} and `patch_size`: {patch_size}. Make"
" sure that either `num_vector_embeds` or `num_patches` is None."
)
elif not self.is_input_continuous and not self.is_input_vectorized and not self.is_input_patches:
raise ValueError(
f"Has to define `in_channels`: {in_channels}, `num_vector_embeds`: {num_vector_embeds}, or patch_size:"
f" {patch_size}. Make sure that `in_channels`, `num_vector_embeds` or `num_patches` is not None."
)
# 2. Define input layers
if self.is_input_continuous:
self.in_channels = in_channels
self.norm = torch.nn.GroupNorm(num_groups=norm_num_groups, num_channels=in_channels, eps=1e-6, affine=True)
if use_linear_projection:
self.proj_in = nn.Linear(in_channels, inner_dim)
else:
self.proj_in = nn.Conv2d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)
elif self.is_input_vectorized:
assert sample_size is not None, "Transformer2DModel over discrete input must provide sample_size"
assert num_vector_embeds is not None, "Transformer2DModel over discrete input must provide num_embed"
self.height = sample_size
self.width = sample_size
self.num_vector_embeds = num_vector_embeds
self.num_latent_pixels = self.height * self.width
| self.latent_image_embedding = ImagePositionalEmbeddings( | 2 | 2023-11-14 23:29:31+00:00 | 24k |
BraveGroup/Drive-WM | src/diffusers/pipelines/wuerstchen/modeling_wuerstchen_diffnext.py | [
{
"identifier": "ConfigMixin",
"path": "src/diffusers/configuration_utils.py",
"snippet": "class ConfigMixin:\n r\"\"\"\n Base class for all configuration classes. All configuration parameters are stored under `self.config`. Also\n provides the [`~ConfigMixin.from_config`] and [`~ConfigMixin.sa... | import math
import numpy as np
import torch
import torch.nn as nn
from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin
from .modeling_wuerstchen_common import AttnBlock, GlobalResponseNorm, TimestepBlock, WuerstchenLayerNorm | 18,014 | # Copyright (c) 2023 Dominic Rampas MIT License
# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class WuerstchenDiffNeXt(ModelMixin, ConfigMixin):
@register_to_config
def __init__(
self,
c_in=4,
c_out=4,
c_r=64,
patch_size=2,
c_cond=1024,
c_hidden=[320, 640, 1280, 1280],
nhead=[-1, 10, 20, 20],
blocks=[4, 4, 14, 4],
level_config=["CT", "CTA", "CTA", "CTA"],
inject_effnet=[False, True, True, True],
effnet_embd=16,
clip_embd=1024,
kernel_size=3,
dropout=0.1,
):
super().__init__()
self.c_r = c_r
self.c_cond = c_cond
if not isinstance(dropout, list):
dropout = [dropout] * len(c_hidden)
# CONDITIONING
self.clip_mapper = nn.Linear(clip_embd, c_cond)
self.effnet_mappers = nn.ModuleList(
[
nn.Conv2d(effnet_embd, c_cond, kernel_size=1) if inject else None
for inject in inject_effnet + list(reversed(inject_effnet))
]
)
self.seq_norm = nn.LayerNorm(c_cond, elementwise_affine=False, eps=1e-6)
self.embedding = nn.Sequential(
nn.PixelUnshuffle(patch_size),
nn.Conv2d(c_in * (patch_size**2), c_hidden[0], kernel_size=1),
| # Copyright (c) 2023 Dominic Rampas MIT License
# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
class WuerstchenDiffNeXt(ModelMixin, ConfigMixin):
@register_to_config
def __init__(
self,
c_in=4,
c_out=4,
c_r=64,
patch_size=2,
c_cond=1024,
c_hidden=[320, 640, 1280, 1280],
nhead=[-1, 10, 20, 20],
blocks=[4, 4, 14, 4],
level_config=["CT", "CTA", "CTA", "CTA"],
inject_effnet=[False, True, True, True],
effnet_embd=16,
clip_embd=1024,
kernel_size=3,
dropout=0.1,
):
super().__init__()
self.c_r = c_r
self.c_cond = c_cond
if not isinstance(dropout, list):
dropout = [dropout] * len(c_hidden)
# CONDITIONING
self.clip_mapper = nn.Linear(clip_embd, c_cond)
self.effnet_mappers = nn.ModuleList(
[
nn.Conv2d(effnet_embd, c_cond, kernel_size=1) if inject else None
for inject in inject_effnet + list(reversed(inject_effnet))
]
)
self.seq_norm = nn.LayerNorm(c_cond, elementwise_affine=False, eps=1e-6)
self.embedding = nn.Sequential(
nn.PixelUnshuffle(patch_size),
nn.Conv2d(c_in * (patch_size**2), c_hidden[0], kernel_size=1), | WuerstchenLayerNorm(c_hidden[0], elementwise_affine=False, eps=1e-6), | 6 | 2023-11-18 01:40:55+00:00 | 24k |
wjun0830/CGDETR | cg_detr/train.py | [
{
"identifier": "BaseOptions",
"path": "cg_detr/config.py",
"snippet": "class BaseOptions(object):\n saved_option_filename = \"opt.json\"\n ckpt_filename = \"model.ckpt\"\n tensorboard_log_dir = \"tensorboard_log\"\n train_log_filename = \"train.log.txt\"\n eval_log_filename = \"eval.log.... | import os
import time
import json
import pprint
import random
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
import logging
import sys
from tqdm import tqdm, trange
from collections import defaultdict
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from cg_detr.config import BaseOptions
from cg_detr.start_end_dataset import \
StartEndDataset, start_end_collate, prepare_batch_inputs
from cg_detr.inference import eval_epoch, start_inference, setup_model
from utils.basic_utils import AverageMeter, dict_to_markdown
from utils.model_utils import count_parameters | 14,837 |
if opt.debug:
break
tb_writer.close()
def train_hl(model, criterion, optimizer, lr_scheduler, train_dataset, val_dataset, opt):
if opt.device.type == "cuda":
logger.info("CUDA enabled.")
model.to(opt.device)
tb_writer = SummaryWriter(opt.tensorboard_log_dir)
tb_writer.add_text("hyperparameters", dict_to_markdown(vars(opt), max_str_len=None))
opt.train_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str}\n"
opt.eval_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str} [Metrics] {eval_metrics_str}\n"
train_loader = DataLoader(
train_dataset,
collate_fn=start_end_collate,
batch_size=opt.bsz,
num_workers=opt.num_workers,
shuffle=True,
pin_memory=opt.pin_memory
)
prev_best_score = 0.
es_cnt = 0
# start_epoch = 0
if opt.start_epoch is None:
start_epoch = -1 if opt.eval_untrained else 0
else:
start_epoch = opt.start_epoch
save_submission_filename = "latest_{}_{}_preds.jsonl".format(opt.dset_name, opt.eval_split_name)
for epoch_i in trange(start_epoch, opt.n_epoch, desc="Epoch"):
if epoch_i > -1:
train_epoch(model, criterion, train_loader, optimizer, opt, epoch_i, tb_writer)
lr_scheduler.step()
eval_epoch_interval = 5
if opt.eval_path is not None and (epoch_i + 1) % eval_epoch_interval == 0:
with torch.no_grad():
metrics_no_nms, metrics_nms, eval_loss_meters, latest_file_paths = \
eval_epoch(model, val_dataset, opt, save_submission_filename, epoch_i, criterion, tb_writer)
# log
to_write = opt.eval_log_txt_formatter.format(
time_str=time.strftime("%Y_%m_%d_%H_%M_%S"),
epoch=epoch_i,
loss_str=" ".join(["{} {:.4f}".format(k, v.avg) for k, v in eval_loss_meters.items()]),
eval_metrics_str=json.dumps(metrics_no_nms))
with open(opt.eval_log_filepath, "a") as f:
f.write(to_write)
logger.info("metrics_no_nms {}".format(pprint.pformat(metrics_no_nms["brief"], indent=4)))
if metrics_nms is not None:
logger.info("metrics_nms {}".format(pprint.pformat(metrics_nms["brief"], indent=4)))
metrics = metrics_no_nms
for k, v in metrics["brief"].items():
tb_writer.add_scalar(f"Eval/{k}", float(v), epoch_i+1)
# stop_score = metrics["brief"]["MR-full-mAP"]
stop_score = metrics["brief"]["mAP"]
if stop_score > prev_best_score:
es_cnt = 0
prev_best_score = stop_score
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"lr_scheduler": lr_scheduler.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_best.ckpt"))
best_file_paths = [e.replace("latest", "best") for e in latest_file_paths]
for src, tgt in zip(latest_file_paths, best_file_paths):
os.renames(src, tgt)
logger.info("The checkpoint file has been updated.")
else:
es_cnt += 1
if opt.max_es_cnt != -1 and es_cnt > opt.max_es_cnt: # early stop
with open(opt.train_log_filepath, "a") as f:
f.write(f"Early Stop at epoch {epoch_i}")
logger.info(f"\n>>>>> Early stop at epoch {epoch_i} {prev_best_score}\n")
break
# save ckpt
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"lr_scheduler": lr_scheduler.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_latest.ckpt"))
save_interval = 10 if "subs_train" in opt.train_path else 50 # smaller for pretrain
if (epoch_i + 1) % save_interval == 0 or (epoch_i + 1) % opt.lr_drop == 0: # additional copies
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", f"_e{epoch_i:04d}.ckpt"))
if opt.debug:
break
tb_writer.close()
def start_training():
logger.info("Setup config, data and model...")
|
logger = logging.getLogger(__name__)
logging.basicConfig(format="%(asctime)s.%(msecs)03d:%(levelname)s:%(name)s - %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
level=logging.INFO)
def set_seed(seed, use_cuda=True):
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if use_cuda:
torch.cuda.manual_seed_all(seed)
def train_epoch(model, criterion, train_loader, optimizer, opt, epoch_i, tb_writer):
logger.info(f"[Epoch {epoch_i+1}]")
model.train()
criterion.train()
# init meters
time_meters = defaultdict(AverageMeter)
loss_meters = defaultdict(AverageMeter)
num_training_examples = len(train_loader)
timer_dataloading = time.time()
for batch_idx, batch in tqdm(enumerate(train_loader),
desc="Training Iteration",
total=num_training_examples):
time_meters["dataloading_time"].update(time.time() - timer_dataloading)
timer_start = time.time()
model_inputs, targets = prepare_batch_inputs(batch[1], opt.device, non_blocking=opt.pin_memory)
time_meters["prepare_inputs_time"].update(time.time() - timer_start)
timer_start = time.time()
outputs = model(**model_inputs, targets=targets)
loss_dict = criterion(outputs, targets)
weight_dict = criterion.weight_dict
losses = sum(loss_dict[k] * weight_dict[k] for k in loss_dict.keys() if k in weight_dict)
time_meters["model_forward_time"].update(time.time() - timer_start)
timer_start = time.time()
optimizer.zero_grad()
losses.backward()
if opt.grad_clip > 0:
nn.utils.clip_grad_norm_(model.parameters(), opt.grad_clip)
optimizer.step()
time_meters["model_backward_time"].update(time.time() - timer_start)
loss_dict["loss_overall"] = float(losses) # for logging only
for k, v in loss_dict.items():
loss_meters[k].update(float(v) * weight_dict[k] if k in weight_dict else float(v))
timer_dataloading = time.time()
if opt.debug and batch_idx == 3:
break
# print/add logs
tb_writer.add_scalar("Train/lr", float(optimizer.param_groups[0]["lr"]), epoch_i+1)
for k, v in loss_meters.items():
tb_writer.add_scalar("Train/{}".format(k), v.avg, epoch_i+1)
to_write = opt.train_log_txt_formatter.format(
time_str=time.strftime("%Y_%m_%d_%H_%M_%S"),
epoch=epoch_i+1,
loss_str=" ".join(["{} {:.4f}".format(k, v.avg) for k, v in loss_meters.items()]))
with open(opt.train_log_filepath, "a") as f:
f.write(to_write)
logger.info("Epoch time stats:")
for name, meter in time_meters.items():
d = {k: f"{getattr(meter, k):.4f}" for k in ["max", "min", "avg"]}
logger.info(f"{name} ==> {d}")
def train(model, criterion, optimizer, lr_scheduler, train_dataset, val_dataset, opt):
if opt.device.type == "cuda":
logger.info("CUDA enabled.")
model.to(opt.device)
tb_writer = SummaryWriter(opt.tensorboard_log_dir)
tb_writer.add_text("hyperparameters", dict_to_markdown(vars(opt), max_str_len=None))
opt.train_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str}\n"
opt.eval_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str} [Metrics] {eval_metrics_str}\n"
train_loader = DataLoader(
train_dataset,
collate_fn=start_end_collate,
batch_size=opt.bsz,
num_workers=opt.num_workers,
shuffle=True,
pin_memory=opt.pin_memory
)
prev_best_score = 0.
es_cnt = 0
# start_epoch = 0
if opt.start_epoch is None:
start_epoch = -1 if opt.eval_untrained else 0
else:
start_epoch = opt.start_epoch
save_submission_filename = "latest_{}_{}_preds.jsonl".format(opt.dset_name, opt.eval_split_name)
for epoch_i in trange(start_epoch, opt.n_epoch, desc="Epoch"):
if epoch_i > -1:
train_epoch(model, criterion, train_loader, optimizer, opt, epoch_i, tb_writer)
lr_scheduler.step()
eval_epoch_interval = opt.eval_epoch
if opt.eval_path is not None and (epoch_i + 1) % eval_epoch_interval == 0:
with torch.no_grad():
metrics_no_nms, metrics_nms, eval_loss_meters, latest_file_paths = \
eval_epoch(model, val_dataset, opt, save_submission_filename, epoch_i, criterion, tb_writer)
# log
to_write = opt.eval_log_txt_formatter.format(
time_str=time.strftime("%Y_%m_%d_%H_%M_%S"),
epoch=epoch_i,
loss_str=" ".join(["{} {:.4f}".format(k, v.avg) for k, v in eval_loss_meters.items()]),
eval_metrics_str=json.dumps(metrics_no_nms))
with open(opt.eval_log_filepath, "a") as f:
f.write(to_write)
logger.info("metrics_no_nms {}".format(pprint.pformat(metrics_no_nms["brief"], indent=4)))
if metrics_nms is not None:
logger.info("metrics_nms {}".format(pprint.pformat(metrics_nms["brief"], indent=4)))
metrics = metrics_no_nms
for k, v in metrics["brief"].items():
tb_writer.add_scalar(f"Eval/{k}", float(v), epoch_i+1)
if opt.dset_name in ['hl']:
stop_score = metrics["brief"]["MR-full-mAP"]
else:
stop_score = (metrics["brief"]["MR-full-R1@0.7"] + metrics["brief"]["MR-full-R1@0.5"]) / 2
if stop_score > prev_best_score:
es_cnt = 0
prev_best_score = stop_score
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"lr_scheduler": lr_scheduler.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_best.ckpt"))
best_file_paths = [e.replace("latest", "best") for e in latest_file_paths]
for src, tgt in zip(latest_file_paths, best_file_paths):
os.renames(src, tgt)
logger.info("The checkpoint file has been updated.")
else:
es_cnt += 1
if opt.max_es_cnt != -1 and es_cnt > opt.max_es_cnt: # early stop
with open(opt.train_log_filepath, "a") as f:
f.write(f"Early Stop at epoch {epoch_i}")
logger.info(f"\n>>>>> Early stop at epoch {epoch_i} {prev_best_score}\n")
break
# save ckpt
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"lr_scheduler": lr_scheduler.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_latest.ckpt"))
# save_interval = 10 if "subs_train" in opt.train_path else 50 # smaller for pretrain
# if (epoch_i + 1) % save_interval == 0 or (epoch_i + 1) % opt.lr_drop == 0: # additional copies
# checkpoint = {
# "model": model.state_dict(),
# "optimizer": optimizer.state_dict(),
# "epoch": epoch_i,
# "opt": opt
# }
# torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", f"_e{epoch_i:04d}.ckpt"))
if opt.debug:
break
tb_writer.close()
def train_hl(model, criterion, optimizer, lr_scheduler, train_dataset, val_dataset, opt):
if opt.device.type == "cuda":
logger.info("CUDA enabled.")
model.to(opt.device)
tb_writer = SummaryWriter(opt.tensorboard_log_dir)
tb_writer.add_text("hyperparameters", dict_to_markdown(vars(opt), max_str_len=None))
opt.train_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str}\n"
opt.eval_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str} [Metrics] {eval_metrics_str}\n"
train_loader = DataLoader(
train_dataset,
collate_fn=start_end_collate,
batch_size=opt.bsz,
num_workers=opt.num_workers,
shuffle=True,
pin_memory=opt.pin_memory
)
prev_best_score = 0.
es_cnt = 0
# start_epoch = 0
if opt.start_epoch is None:
start_epoch = -1 if opt.eval_untrained else 0
else:
start_epoch = opt.start_epoch
save_submission_filename = "latest_{}_{}_preds.jsonl".format(opt.dset_name, opt.eval_split_name)
for epoch_i in trange(start_epoch, opt.n_epoch, desc="Epoch"):
if epoch_i > -1:
train_epoch(model, criterion, train_loader, optimizer, opt, epoch_i, tb_writer)
lr_scheduler.step()
eval_epoch_interval = 5
if opt.eval_path is not None and (epoch_i + 1) % eval_epoch_interval == 0:
with torch.no_grad():
metrics_no_nms, metrics_nms, eval_loss_meters, latest_file_paths = \
eval_epoch(model, val_dataset, opt, save_submission_filename, epoch_i, criterion, tb_writer)
# log
to_write = opt.eval_log_txt_formatter.format(
time_str=time.strftime("%Y_%m_%d_%H_%M_%S"),
epoch=epoch_i,
loss_str=" ".join(["{} {:.4f}".format(k, v.avg) for k, v in eval_loss_meters.items()]),
eval_metrics_str=json.dumps(metrics_no_nms))
with open(opt.eval_log_filepath, "a") as f:
f.write(to_write)
logger.info("metrics_no_nms {}".format(pprint.pformat(metrics_no_nms["brief"], indent=4)))
if metrics_nms is not None:
logger.info("metrics_nms {}".format(pprint.pformat(metrics_nms["brief"], indent=4)))
metrics = metrics_no_nms
for k, v in metrics["brief"].items():
tb_writer.add_scalar(f"Eval/{k}", float(v), epoch_i+1)
# stop_score = metrics["brief"]["MR-full-mAP"]
stop_score = metrics["brief"]["mAP"]
if stop_score > prev_best_score:
es_cnt = 0
prev_best_score = stop_score
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"lr_scheduler": lr_scheduler.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_best.ckpt"))
best_file_paths = [e.replace("latest", "best") for e in latest_file_paths]
for src, tgt in zip(latest_file_paths, best_file_paths):
os.renames(src, tgt)
logger.info("The checkpoint file has been updated.")
else:
es_cnt += 1
if opt.max_es_cnt != -1 and es_cnt > opt.max_es_cnt: # early stop
with open(opt.train_log_filepath, "a") as f:
f.write(f"Early Stop at epoch {epoch_i}")
logger.info(f"\n>>>>> Early stop at epoch {epoch_i} {prev_best_score}\n")
break
# save ckpt
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"lr_scheduler": lr_scheduler.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_latest.ckpt"))
save_interval = 10 if "subs_train" in opt.train_path else 50 # smaller for pretrain
if (epoch_i + 1) % save_interval == 0 or (epoch_i + 1) % opt.lr_drop == 0: # additional copies
checkpoint = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"epoch": epoch_i,
"opt": opt
}
torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", f"_e{epoch_i:04d}.ckpt"))
if opt.debug:
break
tb_writer.close()
def start_training():
logger.info("Setup config, data and model...") | opt = BaseOptions().parse() | 0 | 2023-11-10 12:45:25+00:00 | 24k |
ej0cl6/TextEE | TextEE/models/OneIE/E2Etrainer.py | [
{
"identifier": "BasicTrainer",
"path": "TextEE/models/trainer.py",
"snippet": "class BasicTrainer(object):\n def __init__(self, config, type_set=None):\n self.config = config\n self.type_set = type_set\n \n @classmethod\n def add_extra_info_fn(cls, instances, raw_data, con... | import os, sys, logging, tqdm, pprint, copy
import torch
import numpy as np
import ipdb
from transformers import (BertTokenizer, RobertaTokenizer, XLMRobertaTokenizer,
AutoTokenizer, AdamW, get_linear_schedule_with_warmup)
from torch.utils.data import DataLoader
from torch.optim import AdamW
from ..trainer import BasicTrainer
from .E2Emodel import OneIEE2EModel
from .data import IEDataset
from .util import generate_vocabs, load_valid_patterns, save_result, best_score_by_task
from .scorer import score_graphs
from scorer import compute_f1, print_scores | 15,302 |
logger = logging.getLogger(__name__)
class OneIEE2ETrainer(BasicTrainer):
def __init__(self, config, type_set=None):
super().__init__(config, type_set)
self.tokenizer = None
self.model = None
self.valid_patterns = None
@classmethod
def add_extra_info_fn(cls, instances, raw_data, config):
extra_info_map = {}
for dt in raw_data:
extra_info = {
"entity_mentions": dt["entity_mentions"] if "entity_mentions" in dt else [],
"relation_mentions": dt["relation_mentions"] if "relation_mentions" in dt else [],
"event_mentions": dt["event_mentions"] if "event_mentions" in dt else [],
}
extra_info_map[(dt["doc_id"], dt["wnd_id"])] = extra_info
for instance in instances:
instance["extra_info"] = extra_info_map[(instance["doc_id"], instance["wnd_id"])]
return instances
def load_tokenizer_(self, checkpoint=None):
if checkpoint:
logger.info(f"Loading tokenizer from {checkpoint}")
state = torch.load(os.path.join(checkpoint, "best_model.tokenizer"))
self.tokenizer = state["tokenizer"]
else:
logger.info(f"Loading tokenizer from {self.config.pretrained_model_name}")
if self.config.pretrained_model_name.startswith('bert-'):
self.tokenizer = BertTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir)
elif self.config.pretrained_model_name.startswith('roberta-'):
self.tokenizer = RobertaTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir)
elif self.config.pretrained_model_name.startswith('xlm-roberta-'):
self.tokenizer = XLMRobertaTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir)
else:
self.tokenizer = AutoTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir, do_lower_case=False)
def load_model_(self, checkpoint=None):
assert self.tokenizer
if checkpoint:
logger.info(f"Loading model from {checkpoint}")
state = torch.load(os.path.join(checkpoint, "best_model.state"), map_location=f'cuda:{self.config.gpu_device}')
self.vocabs = state["vocabs"]
self.type_set = state["type_set"]
self.valid_patterns = state["valid_patterns"]
self.model = OneIEE2EModel(self.config, self.vocabs, self.valid_patterns)
self.model.load_state_dict(state['model'])
self.model.cuda(device=self.config.gpu_device)
else:
|
logger = logging.getLogger(__name__)
class OneIEE2ETrainer(BasicTrainer):
def __init__(self, config, type_set=None):
super().__init__(config, type_set)
self.tokenizer = None
self.model = None
self.valid_patterns = None
@classmethod
def add_extra_info_fn(cls, instances, raw_data, config):
extra_info_map = {}
for dt in raw_data:
extra_info = {
"entity_mentions": dt["entity_mentions"] if "entity_mentions" in dt else [],
"relation_mentions": dt["relation_mentions"] if "relation_mentions" in dt else [],
"event_mentions": dt["event_mentions"] if "event_mentions" in dt else [],
}
extra_info_map[(dt["doc_id"], dt["wnd_id"])] = extra_info
for instance in instances:
instance["extra_info"] = extra_info_map[(instance["doc_id"], instance["wnd_id"])]
return instances
def load_tokenizer_(self, checkpoint=None):
if checkpoint:
logger.info(f"Loading tokenizer from {checkpoint}")
state = torch.load(os.path.join(checkpoint, "best_model.tokenizer"))
self.tokenizer = state["tokenizer"]
else:
logger.info(f"Loading tokenizer from {self.config.pretrained_model_name}")
if self.config.pretrained_model_name.startswith('bert-'):
self.tokenizer = BertTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir)
elif self.config.pretrained_model_name.startswith('roberta-'):
self.tokenizer = RobertaTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir)
elif self.config.pretrained_model_name.startswith('xlm-roberta-'):
self.tokenizer = XLMRobertaTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir)
else:
self.tokenizer = AutoTokenizer.from_pretrained(self.config.pretrained_model_name, cache_dir=self.config.cache_dir, do_lower_case=False)
def load_model_(self, checkpoint=None):
assert self.tokenizer
if checkpoint:
logger.info(f"Loading model from {checkpoint}")
state = torch.load(os.path.join(checkpoint, "best_model.state"), map_location=f'cuda:{self.config.gpu_device}')
self.vocabs = state["vocabs"]
self.type_set = state["type_set"]
self.valid_patterns = state["valid_patterns"]
self.model = OneIEE2EModel(self.config, self.vocabs, self.valid_patterns)
self.model.load_state_dict(state['model'])
self.model.cuda(device=self.config.gpu_device)
else: | self.valid_patterns = load_valid_patterns(self.config.valid_pattern_path, self.vocabs) | 4 | 2023-11-15 21:32:56+00:00 | 24k |
ahayler/s4c | models/bts/trainer_overfit.py | [
{
"identifier": "make_datasets",
"path": "datasets/data_util.py",
"snippet": "def make_datasets(config):\n type = config.get(\"type\", \"KITTI_Raw\")\n if type == \"KITTI_Odometry\":\n train_dataset = KittiOdometryDataset(\n base_path=config[\"data_path\"],\n frame_cou... | import math
import ignite.distributed as idist
import torch
import numpy as np
from copy import copy
from typing import Optional, Union, Iterable, Sequence
from ignite.contrib.handlers import TensorboardLogger
from ignite.engine import Engine
from matplotlib import pyplot as plt
from torch import optim, nn
from torch.utils.data import DataLoader, Dataset, Sampler
from torch.utils.data.dataloader import T_co, _collate_fn_t, _worker_init_fn_t
from torchvision.utils import make_grid
from datasets.data_util import make_datasets
from models.common.model.scheduler import make_scheduler
from models.common.render import NeRFRenderer
from models.bts.model.loss import ReconstructionLoss
from models.bts.trainer import get_metrics, BTSWrapper, BTSNet
from scripts.inference_setup import render_profile
from utils.array_operations import map_fn, unsqueezer, to
from utils.base_trainer import base_training
from utils.plotting import color_tensor, color_segmentation_tensor | 16,170 |
class EncoderDummy(nn.Module):
def __init__(self, size, feat_dim, num_views=1) -> None:
super().__init__()
self.feats = nn.Parameter(torch.randn(num_views, feat_dim, *size))
self.latent_size = feat_dim
def forward(self, x):
n = x.shape[0]
return [self.feats.expand(n, -1, -1, -1)]
class DataloaderDummy(DataLoader):
def __init__(self, dataset: Dataset[T_co], batch_size: Optional[int] = 1, shuffle: Optional[bool] = None,
sampler: Union[Sampler, Iterable, None] = None,
batch_sampler: Union[Sampler[Sequence], Iterable[Sequence], None] = None, num_workers: int = 0,
collate_fn: Optional[_collate_fn_t] = None, pin_memory: bool = False, drop_last: bool = False,
timeout: float = 0, worker_init_fn: Optional[_worker_init_fn_t] = None, multiprocessing_context=None,
generator=None, *, prefetch_factor: int = 2, persistent_workers: bool = False,
pin_memory_device: str = ""):
super().__init__(dataset, batch_size, shuffle, sampler, batch_sampler, num_workers, collate_fn, pin_memory,
drop_last, timeout, worker_init_fn, multiprocessing_context, generator,
prefetch_factor=prefetch_factor, persistent_workers=persistent_workers,
pin_memory_device=pin_memory_device)
self.element = to(map_fn(map_fn(dataset.__getitem__(0), torch.tensor), unsqueezer), "cuda:0")
def _get_iterator(self):
return iter([self.element])
def __iter__(self):
return super().__iter__()
def __len__(self) -> int:
return 1
class BTSWrapperOverfit(BTSWrapper):
def __init__(self, renderer, config, eval_nvs=False, size=None) -> None:
super().__init__(renderer, config, eval_nvs)
self.encoder_dummy = EncoderDummy(size, config["encoder"]["d_out"], num_views=1)
self.renderer.net.encoder = self.encoder_dummy
self.renderer.net.flip_augmentation = False
def training(local_rank, config):
return base_training(local_rank, config, get_dataflow, initialize, get_metrics, visualize)
def get_dataflow(config, logger=None):
# - Get train/test datasets
if idist.get_local_rank() > 0:
# Ensure that only local rank 0 download the dataset
# Thus each node will download a copy of the dataset
idist.barrier()
train_dataset, _ = make_datasets(config["data"])
train_dataset.load_kitti_360_segmentation_gt = True
train_dataset.length = 1
train_dataset._skip = config["data"].get("skip", 0)
vis_dataset = copy(train_dataset)
test_dataset = copy(train_dataset)
vis_dataset.return_depth = True
test_dataset.return_depth = True
if idist.get_local_rank() == 0:
# Ensure that only local rank 0 download the dataset
idist.barrier()
# Setup data loader also adapted to distributed config: nccl, gloo, xla-tpu
train_loader = DataloaderDummy(train_dataset)
test_loader = DataloaderDummy(test_dataset)
vis_loader = DataloaderDummy(vis_dataset)
return train_loader, test_loader, vis_loader
def initialize(config: dict, logger=None):
arch = config["model_conf"].get("arch", "BTSNet")
net = globals()[arch](config["model_conf"])
renderer = NeRFRenderer.from_conf(config["renderer"])
renderer = renderer.bind_parallel(net, gpus=None).eval()
mode = config.get("mode", "depth")
model = BTSWrapperOverfit(
renderer,
config["model_conf"],
mode == "nvs",
size=config["data"].get("image_size", (192, 640))
)
model = idist.auto_model(model)
optimizer = optim.Adam(model.parameters(), lr=config["learning_rate"])
optimizer = idist.auto_optim(optimizer)
lr_scheduler = make_scheduler(config.get("scheduler", {}), optimizer)
|
class EncoderDummy(nn.Module):
def __init__(self, size, feat_dim, num_views=1) -> None:
super().__init__()
self.feats = nn.Parameter(torch.randn(num_views, feat_dim, *size))
self.latent_size = feat_dim
def forward(self, x):
n = x.shape[0]
return [self.feats.expand(n, -1, -1, -1)]
class DataloaderDummy(DataLoader):
def __init__(self, dataset: Dataset[T_co], batch_size: Optional[int] = 1, shuffle: Optional[bool] = None,
sampler: Union[Sampler, Iterable, None] = None,
batch_sampler: Union[Sampler[Sequence], Iterable[Sequence], None] = None, num_workers: int = 0,
collate_fn: Optional[_collate_fn_t] = None, pin_memory: bool = False, drop_last: bool = False,
timeout: float = 0, worker_init_fn: Optional[_worker_init_fn_t] = None, multiprocessing_context=None,
generator=None, *, prefetch_factor: int = 2, persistent_workers: bool = False,
pin_memory_device: str = ""):
super().__init__(dataset, batch_size, shuffle, sampler, batch_sampler, num_workers, collate_fn, pin_memory,
drop_last, timeout, worker_init_fn, multiprocessing_context, generator,
prefetch_factor=prefetch_factor, persistent_workers=persistent_workers,
pin_memory_device=pin_memory_device)
self.element = to(map_fn(map_fn(dataset.__getitem__(0), torch.tensor), unsqueezer), "cuda:0")
def _get_iterator(self):
return iter([self.element])
def __iter__(self):
return super().__iter__()
def __len__(self) -> int:
return 1
class BTSWrapperOverfit(BTSWrapper):
def __init__(self, renderer, config, eval_nvs=False, size=None) -> None:
super().__init__(renderer, config, eval_nvs)
self.encoder_dummy = EncoderDummy(size, config["encoder"]["d_out"], num_views=1)
self.renderer.net.encoder = self.encoder_dummy
self.renderer.net.flip_augmentation = False
def training(local_rank, config):
return base_training(local_rank, config, get_dataflow, initialize, get_metrics, visualize)
def get_dataflow(config, logger=None):
# - Get train/test datasets
if idist.get_local_rank() > 0:
# Ensure that only local rank 0 download the dataset
# Thus each node will download a copy of the dataset
idist.barrier()
train_dataset, _ = make_datasets(config["data"])
train_dataset.load_kitti_360_segmentation_gt = True
train_dataset.length = 1
train_dataset._skip = config["data"].get("skip", 0)
vis_dataset = copy(train_dataset)
test_dataset = copy(train_dataset)
vis_dataset.return_depth = True
test_dataset.return_depth = True
if idist.get_local_rank() == 0:
# Ensure that only local rank 0 download the dataset
idist.barrier()
# Setup data loader also adapted to distributed config: nccl, gloo, xla-tpu
train_loader = DataloaderDummy(train_dataset)
test_loader = DataloaderDummy(test_dataset)
vis_loader = DataloaderDummy(vis_dataset)
return train_loader, test_loader, vis_loader
def initialize(config: dict, logger=None):
arch = config["model_conf"].get("arch", "BTSNet")
net = globals()[arch](config["model_conf"])
renderer = NeRFRenderer.from_conf(config["renderer"])
renderer = renderer.bind_parallel(net, gpus=None).eval()
mode = config.get("mode", "depth")
model = BTSWrapperOverfit(
renderer,
config["model_conf"],
mode == "nvs",
size=config["data"].get("image_size", (192, 640))
)
model = idist.auto_model(model)
optimizer = optim.Adam(model.parameters(), lr=config["learning_rate"])
optimizer = idist.auto_optim(optimizer)
lr_scheduler = make_scheduler(config.get("scheduler", {}), optimizer)
| criterion = ReconstructionLoss(config["loss"], config["model_conf"].get("use_automasking", False)) | 3 | 2023-11-12 21:53:27+00:00 | 24k |
newcastleuniversity/DISPEL | dispel/processing/extract.py | [
{
"identifier": "EntityType",
"path": "dispel/data/core.py",
"snippet": "class ReadingSchema:\nclass Evaluation(Epoch):\nclass Session(Epoch):\nclass Reading(FlagMixIn):\n def __init__(\n self,\n *args,\n uuid: str,\n finished: Optional[bool] = None,\n exit_reason: ... | import inspect
import math
import warnings
import numpy as np
import pandas as pd
from typing import (
Any,
Callable,
Dict,
Generator,
Iterable,
List,
Optional,
Sequence,
Tuple,
Union,
cast,
)
from deprecated import deprecated
from dispel.data.core import EntityType, Reading
from dispel.data.flags import Flag, FlagSeverity, FlagType, WrappedResult
from dispel.data.levels import Level
from dispel.data.measures import (
MeasureId,
MeasureSet,
MeasureValue,
MeasureValueDefinition,
)
from dispel.data.values import AbbreviatedValue as AV
from dispel.data.values import (
DefinitionId,
DefinitionIdType,
ValueDefinition,
ValueDefinitionPrototype,
)
from dispel.processing.core import (
ErrorHandling,
ProcessingControlResult,
ProcessingResult,
ProcessingStep,
ProcessResultType,
)
from dispel.processing.data_set import (
MutateDataSetProcessingStepBase,
TransformationFunctionGeneratorType,
WrapResultGeneratorType,
)
from dispel.processing.flags import FlagStepMixin
from dispel.processing.level import LevelFilterType, LevelProcessingResult
from dispel.processing.transform import TransformStepChainMixIn
from dispel.stats.core import iqr, npcv, percentile_95, variation, variation_increase | 15,453 | ... 'data-set-id',
... [
... {'func': np.mean, 'method': 'average'},
... {'func': np.median, 'method': 'median'}
... ],
... ValueDefinitionPrototype(
... id_='measure-{method}',
... name='{method} measure',
... unit='s'
... )
... )
This extraction step will result in two measure values, one for the mean and one
with the median.
"""
transform_functions: Iterable[Dict[str, Any]]
def __init__(
self,
data_set_ids: Optional[Union[str, Iterable[str]]] = None,
transform_functions: Optional[Iterable[Dict[str, Any]]] = None,
definition: Optional[ValueDefinitionPrototype] = None,
level_filter: Optional[LevelFilterType] = None,
yield_if_nan: Optional[bool] = None,
):
super().__init__(
definition=definition,
data_set_ids=data_set_ids,
level_filter=level_filter,
yield_if_nan=yield_if_nan,
)
if transform_functions:
self.transform_functions = transform_functions
def get_transform_functions(self) -> TransformationFunctionGeneratorType:
"""Get the transform functions applied to the data sets."""
yield from super().get_transform_functions()
for function_spec in self.transform_functions:
spec = function_spec.copy()
yield spec.pop("func"), spec
AggregationFunctionType = Union[str, Callable[[pd.Series], float]]
def agg_column(
column: str, method: AggregationFunctionType
) -> Callable[[pd.DataFrame], float]:
"""Create a function to apply an aggregation function on a column.
Parameters
----------
column
The column to be aggregated
method
A function to apply on the column
Returns
-------
Callable[[pandas.DataFrame], float]
A function that aggregates one column of a `~pandas.DataFrame`.
"""
def _function(data: pd.DataFrame) -> float:
return data[column].agg(method)
return _function
#: A list of basic used aggregation methods
BASIC_AGGREGATIONS: List[Tuple[str, str]] = [
("mean", "mean"),
("std", "standard deviation"),
]
#: A list of commonly used aggregation methods
DEFAULT_AGGREGATIONS: List[Tuple[str, str]] = [
*BASIC_AGGREGATIONS,
("median", "median"),
("min", "minimum"),
("max", "maximum"),
]
#: A list of commonly used aggregation methods plus coefficient of variation
DEFAULT_AGGREGATIONS_CV: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS,
(variation, "coefficient of variation"),
]
#: A list of commonly used aggregation methods plus 95th percentile
DEFAULT_AGGREGATIONS_Q95: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS,
(percentile_95, "95th percentile"),
]
#: A list of commonly used aggregation methods plus inter-quartile range
DEFAULT_AGGREGATIONS_IQR: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS,
(iqr, "iqr"),
]
#: An extended list of commonly used aggregation methods
EXTENDED_AGGREGATIONS: List[Tuple[str, str]] = [
*DEFAULT_AGGREGATIONS,
("skew", "skewness"),
("kurtosis", "kurtosis"),
]
DEFAULT_AGGREGATIONS_Q95_CV: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS_Q95,
(variation, "coefficient of variation"),
]
#: A dictionary containing all aggregation methods
AGGREGATION_REGISTRY: Dict[str, Tuple[AggregationFunctionType, str]] = {
**{agg: (agg, agg_label) for agg, agg_label in EXTENDED_AGGREGATIONS},
"cv": (variation, "coefficient of variation"),
| """Extraction functionalities for processing module."""
from __future__ import annotations
class MeasureDefinitionMixin:
"""A mixin class for processing steps producing measure values.
Parameters
----------
definition
An optional value definition. If no value definition is provided, the
:data:`definition` class variable will be used. Alternatively, one can overwrite
:meth:`get_definition` to provide the definition.
"""
#: The specification of the measure definition
definition: Optional[Union[ValueDefinition, ValueDefinitionPrototype]] = None
def __init__(self, *args, **kwargs):
definition = kwargs.pop("definition", None)
self.definition = definition or self.definition
super().__init__(*args, **kwargs)
def get_definition(self, **kwargs) -> ValueDefinition:
"""Get the measure definition.
Parameters
----------
kwargs
Optional parameters that will be passed along to the creation of measure
definitions from prototypes. See
:meth:`~dispel.data.values.ValueDefinitionPrototype.create_definition`
Returns
-------
ValueDefinition
The definition of the value
"""
assert (
self.definition is not None
), "Definition must be set or get_definition must be overwritten."
definition = self.definition
if isinstance(definition, ValueDefinitionPrototype):
definition = cast(ValueDefinition, definition.create_definition(**kwargs))
return definition
def get_value(self, value: Any, **kwargs) -> MeasureValue:
"""Get a measure value based on the definition.
Parameters
----------
value
The value
kwargs
Optional arguments passed to :meth:`get_definition`.
Returns
-------
MeasureValue
The ``value`` wrapped with the definition from :meth:`get_definition`.
"""
return MeasureValue(self.get_definition(**kwargs), value)
class ExtractStep(
MeasureDefinitionMixin, TransformStepChainMixIn, MutateDataSetProcessingStepBase
):
r"""A measure extraction processing step.
This class provides a convenient way to extract a measure from one or more data sets
by specifying their id, their level_ids or level filter, a transformation function
and a measure value definition.
Parameters
----------
data_set_ids
An optional list of data set ids to be used for the transformation. See
:class:`~dispel.processing.data_set.DataSetProcessingStepMixin`.
transform_function
An optional function to be applied to the data sets. See
:class:`~dispel.processing.data_set.MutateDataSetProcessingStepBase`.
definition
An optional value definition or prototype. See
:class:`MeasureDefinitionMixin`.
level_filter
An optional filter to limit the levels being processed. See
:class:`~dispel.processing.level.LevelProcessingStep`.
yield_if_nan
If ``True``, yield null values as measure values. Otherwise, processing
will not return a measure value in case of a null result for the extraction.
Examples
--------
Assuming we wanted to compute the maximum value of a raw data set we can create the
following step
>>> from dispel.data.values import ValueDefinition
>>> from dispel.processing.extract import ExtractStep
>>> step = ExtractStep(
... 'data-set-id',
... lambda data: data.max(axis=0),
... ValueDefinition('maximum','Maximum value')
... )
A common approach is to define a processing step for re-use and leveraging the
``@transformation`` decorator to specify the transformation function:
>>> import pandas as pd
>>> from dispel.data.values import ValueDefinition
>>> from dispel.processing.extract import ExtractStep
>>> from dispel.processing.data_set import transformation
>>> class MyExtractStep(ExtractStep):
... data_set_ids = 'data-set-id'
... definition = ValueDefinition('maximum','Maximum value')
...
... @transformation
... def _max(self, data: pd.DataFrame) -> float:
... return data.max(axis=0)
Often one wants to extract multiple measures from one data set. This can be achieved
by using prototypes and optional named arguments with ``@transformation``:
>>> import pandas as pd
>>> from dispel.data.values import ValueDefinitionPrototype
>>> from dispel.processing.extract import ExtractStep
>>> from dispel.processing.data_set import transformation
>>> class MyExtractStep(ExtractStep):
... data_set_ids = 'data-set-id'
... definition = ValueDefinitionPrototype(
... id_='id-{agg_abbr}',
... name='{agg} value'
... )
...
... @transformation(agg='Maximum', agg_abbr='max')
... def _max(self, data: pd.DataFrame) -> float:
... return data.max(axis=0)
...
... @transformation(agg='Minimum', agg_abbr='min')
... def _min(self, data: pd.DataFrame) -> float:
... return data.min(axis=0)
"""
yield_if_nan: bool = False
def __init__(
self,
data_set_ids: Optional[Union[str, Iterable[str]]] = None,
transform_function: Optional[Callable[..., Any]] = None,
definition: Optional[Union[ValueDefinition, ValueDefinitionPrototype]] = None,
level_filter: Optional[LevelFilterType] = None,
yield_if_nan: Optional[bool] = None,
):
super().__init__(
definition=definition,
data_set_ids=data_set_ids,
transform_function=transform_function,
level_filter=level_filter,
)
self.yield_if_nan = yield_if_nan or self.yield_if_nan
def wrap_result(
self, res: Any, level: Level, reading: Reading, **kwargs: Any
) -> WrapResultGeneratorType:
"""Wrap the result from the processing function into a class.
Parameters
----------
res
Any result returned by the extraction step. If res is a
:class:`~dispel.data.flags.WrappedResult`, the flag contained
in the object will be automatically added to the
:class:`~dispel.data.measures.MeasureValue`, hence the flagged wrapped
results will always translate into flagged
:class:`~dispel.data.measures.MeasureValue`.
level
The current level
reading
The current reading
kwargs
Additional kwargs
Yields
------
LevelProcessingResult
The processing result
"""
try:
if len(res) == 0:
res = math.nan
warnings.warn("Extract step returned an iterable!", UserWarning)
except TypeError:
pass
if is_wrapped := isinstance(res, WrappedResult):
measure_value = res.measure_value
else:
measure_value = res
if not (is_nan := math.isnan(measure_value)) or (is_nan and self.yield_if_nan):
value = self.get_value(measure_value, **kwargs)
# If result is wrapped, add the flag to the measure value
if is_wrapped:
value.add_flags(res, ignore_duplicates=True)
yield LevelProcessingResult(
step=self,
sources=self.get_raw_data_sets(level),
result=value,
level=level,
)
@deprecated(reason="Use ExtractStep and @transformation decorator")
class ExtractMultipleStep(ExtractStep):
r"""A measure extraction processing step for multiple measures.
This processing step allows to produce multiple
:class:`~dispel.data.measures.MeasureValue`\ s by providing a list of functions and a
:class:`~dispel.data.values.ValueDefinitionPrototype` to create the
:class:`~dispel.data.values.ValueDefinition`\ s from.
Parameters
----------
data_set_ids
An optional list of data set ids to be used for the transformation. See
:class:`~dispel.processing.data_set.DataSetProcessingStepMixin`.
transform_functions
An optional list of dictionaries containing at least the processing function
under the key ``func``, which consumes the specified data sets though
``data_set_ids`` as positional arguments and returns a measure value passed to
:class:`~dispel.data.measures.MeasureValue`. Additional keywords will be passed to
:meth:`~dispel.data.values.ValueDefinitionPrototype.create_definition`. If no
functions are provided, the :data:`transform_functions` class variable will be
used.
definition
A :class:`~dispel.data.values.ValueDefinitionPrototype` that is used to create the
:class:`~dispel.data.measures.MeasureValueDefinition`\ s for the transformation
functions provided in ``transform_functions``.
level_filter
An optional filter to limit the levels being processed. See
:class:`~dispel.processing.level.LevelProcessingStep`.
yield_if_nan
If ``True``, yield null values as measure values. Otherwise, processing will not
return a measure value in case of a null result for the extraction.
Examples
--------
To ease the generation of multiple similar measures the :class:`ExtractMultipleStep`
provides a convenient way to do so. Assume you want to create both the mean and
median of a data set this can be achieved as follows:
>>> import numpy as np
>>> from dispel.data.values import ValueDefinitionPrototype
>>> from dispel.processing.extract import ExtractMultipleStep
>>> step = ExtractMultipleStep(
... 'data-set-id',
... [
... {'func': np.mean, 'method': 'average'},
... {'func': np.median, 'method': 'median'}
... ],
... ValueDefinitionPrototype(
... id_='measure-{method}',
... name='{method} measure',
... unit='s'
... )
... )
This extraction step will result in two measure values, one for the mean and one
with the median.
"""
transform_functions: Iterable[Dict[str, Any]]
def __init__(
self,
data_set_ids: Optional[Union[str, Iterable[str]]] = None,
transform_functions: Optional[Iterable[Dict[str, Any]]] = None,
definition: Optional[ValueDefinitionPrototype] = None,
level_filter: Optional[LevelFilterType] = None,
yield_if_nan: Optional[bool] = None,
):
super().__init__(
definition=definition,
data_set_ids=data_set_ids,
level_filter=level_filter,
yield_if_nan=yield_if_nan,
)
if transform_functions:
self.transform_functions = transform_functions
def get_transform_functions(self) -> TransformationFunctionGeneratorType:
"""Get the transform functions applied to the data sets."""
yield from super().get_transform_functions()
for function_spec in self.transform_functions:
spec = function_spec.copy()
yield spec.pop("func"), spec
AggregationFunctionType = Union[str, Callable[[pd.Series], float]]
def agg_column(
column: str, method: AggregationFunctionType
) -> Callable[[pd.DataFrame], float]:
"""Create a function to apply an aggregation function on a column.
Parameters
----------
column
The column to be aggregated
method
A function to apply on the column
Returns
-------
Callable[[pandas.DataFrame], float]
A function that aggregates one column of a `~pandas.DataFrame`.
"""
def _function(data: pd.DataFrame) -> float:
return data[column].agg(method)
return _function
#: A list of basic used aggregation methods
BASIC_AGGREGATIONS: List[Tuple[str, str]] = [
("mean", "mean"),
("std", "standard deviation"),
]
#: A list of commonly used aggregation methods
DEFAULT_AGGREGATIONS: List[Tuple[str, str]] = [
*BASIC_AGGREGATIONS,
("median", "median"),
("min", "minimum"),
("max", "maximum"),
]
#: A list of commonly used aggregation methods plus coefficient of variation
DEFAULT_AGGREGATIONS_CV: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS,
(variation, "coefficient of variation"),
]
#: A list of commonly used aggregation methods plus 95th percentile
DEFAULT_AGGREGATIONS_Q95: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS,
(percentile_95, "95th percentile"),
]
#: A list of commonly used aggregation methods plus inter-quartile range
DEFAULT_AGGREGATIONS_IQR: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS,
(iqr, "iqr"),
]
#: An extended list of commonly used aggregation methods
EXTENDED_AGGREGATIONS: List[Tuple[str, str]] = [
*DEFAULT_AGGREGATIONS,
("skew", "skewness"),
("kurtosis", "kurtosis"),
]
DEFAULT_AGGREGATIONS_Q95_CV: List[Tuple[Union[Callable[[Any], float], str], str]] = [
*DEFAULT_AGGREGATIONS_Q95,
(variation, "coefficient of variation"),
]
#: A dictionary containing all aggregation methods
AGGREGATION_REGISTRY: Dict[str, Tuple[AggregationFunctionType, str]] = {
**{agg: (agg, agg_label) for agg, agg_label in EXTENDED_AGGREGATIONS},
"cv": (variation, "coefficient of variation"), | "cvi": (variation_increase, "coefficient of variation increase"), | 17 | 2023-11-14 10:06:46+00:00 | 24k |
Jisencc/yolov5_dual_weighting | segment/val.py | [
{
"identifier": "DetectMultiBackend",
"path": "models/common.py",
"snippet": "class DetectMultiBackend(nn.Module):\n # YOLOv5 MultiBackend class for python inference on various backends\n def __init__(self, weights='yolov5s.pt', device=torch.device('cpu'), dnn=False, data=None, fp16=False, fuse=Tr... | import argparse
import json
import os
import subprocess
import sys
import numpy as np
import torch
import torch.nn.functional as F
from multiprocessing.pool import ThreadPool
from pathlib import Path
from tqdm import tqdm
from models.common import DetectMultiBackend
from models.yolo import SegmentationModel
from utils.callbacks import Callbacks
from utils.general import (LOGGER, NUM_THREADS, TQDM_BAR_FORMAT, Profile, check_dataset, check_img_size,
check_requirements, check_yaml, coco80_to_coco91_class, colorstr, increment_path,
non_max_suppression, print_args, scale_boxes, xywh2xyxy, xyxy2xywh)
from utils.metrics import ConfusionMatrix, box_iou
from utils.plots import output_to_target, plot_val_study
from utils.segment.dataloaders import create_dataloader
from utils.segment.general import mask_iou, process_mask, process_mask_native, scale_image
from utils.segment.metrics import Metrics, ap_per_class_box_and_mask
from utils.segment.plots import plot_images_and_masks
from utils.torch_utils import de_parallel, select_device, smart_inference_mode
from pycocotools.mask import encode
from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval | 17,353 | assert ncm == nc, f'{weights} ({ncm} classes) trained on different --data than what you passed ({nc} ' \
f'classes). Pass correct combination of --weights and --data that are trained together.'
model.warmup(imgsz=(1 if pt else batch_size, 3, imgsz, imgsz)) # warmup
pad, rect = (0.0, False) if task == 'speed' else (0.5, pt) # square inference for benchmarks
task = task if task in ('train', 'val', 'test') else 'val' # path to train/val/test images
dataloader = create_dataloader(data[task],
imgsz,
batch_size,
stride,
single_cls,
pad=pad,
rect=rect,
workers=workers,
prefix=colorstr(f'{task}: '),
overlap_mask=overlap,
mask_downsample_ratio=mask_downsample_ratio)[0]
seen = 0
confusion_matrix = ConfusionMatrix(nc=nc)
names = model.names if hasattr(model, 'names') else model.module.names # get class names
if isinstance(names, (list, tuple)): # old format
names = dict(enumerate(names))
class_map = coco80_to_coco91_class() if is_coco else list(range(1000))
s = ('%22s' + '%11s' * 10) % ('Class', 'Images', 'Instances', 'Box(P', 'R', 'mAP50', 'mAP50-95)', 'Mask(P', 'R',
'mAP50', 'mAP50-95)')
dt = Profile(), Profile(), Profile()
metrics = Metrics()
loss = torch.zeros(4, device=device)
jdict, stats = [], []
# callbacks.run('on_val_start')
pbar = tqdm(dataloader, desc=s, bar_format=TQDM_BAR_FORMAT) # progress bar
for batch_i, (im, targets, paths, shapes, masks) in enumerate(pbar):
# callbacks.run('on_val_batch_start')
with dt[0]:
if cuda:
im = im.to(device, non_blocking=True)
targets = targets.to(device)
masks = masks.to(device)
masks = masks.float()
im = im.half() if half else im.float() # uint8 to fp16/32
im /= 255 # 0 - 255 to 0.0 - 1.0
nb, _, height, width = im.shape # batch size, channels, height, width
# Inference
with dt[1]:
preds, protos, train_out = model(im) if compute_loss else (*model(im, augment=augment)[:2], None)
# Loss
if compute_loss:
loss += compute_loss((train_out, protos), targets, masks)[1] # box, obj, cls
# NMS
targets[:, 2:] *= torch.tensor((width, height, width, height), device=device) # to pixels
lb = [targets[targets[:, 0] == i, 1:] for i in range(nb)] if save_hybrid else [] # for autolabelling
with dt[2]:
preds = non_max_suppression(preds,
conf_thres,
iou_thres,
labels=lb,
multi_label=True,
agnostic=single_cls,
max_det=max_det,
nm=nm)
# Metrics
plot_masks = [] # masks for plotting
for si, (pred, proto) in enumerate(zip(preds, protos)):
labels = targets[targets[:, 0] == si, 1:]
nl, npr = labels.shape[0], pred.shape[0] # number of labels, predictions
path, shape = Path(paths[si]), shapes[si][0]
correct_masks = torch.zeros(npr, niou, dtype=torch.bool, device=device) # init
correct_bboxes = torch.zeros(npr, niou, dtype=torch.bool, device=device) # init
seen += 1
if npr == 0:
if nl:
stats.append((correct_masks, correct_bboxes, *torch.zeros((2, 0), device=device), labels[:, 0]))
if plots:
confusion_matrix.process_batch(detections=None, labels=labels[:, 0])
continue
# Masks
midx = [si] if overlap else targets[:, 0] == si
gt_masks = masks[midx]
pred_masks = process(proto, pred[:, 6:], pred[:, :4], shape=im[si].shape[1:])
# Predictions
if single_cls:
pred[:, 5] = 0
predn = pred.clone()
scale_boxes(im[si].shape[1:], predn[:, :4], shape, shapes[si][1]) # native-space pred
# Evaluate
if nl:
tbox = xywh2xyxy(labels[:, 1:5]) # target boxes
scale_boxes(im[si].shape[1:], tbox, shape, shapes[si][1]) # native-space labels
labelsn = torch.cat((labels[:, 0:1], tbox), 1) # native-space labels
correct_bboxes = process_batch(predn, labelsn, iouv)
correct_masks = process_batch(predn, labelsn, iouv, pred_masks, gt_masks, overlap=overlap, masks=True)
if plots:
confusion_matrix.process_batch(predn, labelsn)
stats.append((correct_masks, correct_bboxes, pred[:, 4], pred[:, 5], labels[:, 0])) # (conf, pcls, tcls)
pred_masks = torch.as_tensor(pred_masks, dtype=torch.uint8)
if plots and batch_i < 3:
plot_masks.append(pred_masks[:15]) # filter top 15 to plot
# Save/log
if save_txt:
save_one_txt(predn, save_conf, shape, file=save_dir / 'labels' / f'{path.stem}.txt')
if save_json:
pred_masks = scale_image(im[si].shape[1:],
pred_masks.permute(1, 2, 0).contiguous().cpu().numpy(), shape, shapes[si][1])
save_one_json(predn, jdict, path, class_map, pred_masks) # append to COCO-JSON dictionary
# callbacks.run('on_val_image_end', pred, predn, path, names, im[si])
# Plot images
if plots and batch_i < 3:
if len(plot_masks):
plot_masks = torch.cat(plot_masks, dim=0)
| # YOLOv5 🚀 by Ultralytics, AGPL-3.0 license
"""
Validate a trained YOLOv5 segment model on a segment dataset
Usage:
$ bash data/scripts/get_coco.sh --val --segments # download COCO-segments val split (1G, 5000 images)
$ python segment/val.py --weights yolov5s-seg.pt --data coco.yaml --img 640 # validate COCO-segments
Usage - formats:
$ python segment/val.py --weights yolov5s-seg.pt # PyTorch
yolov5s-seg.torchscript # TorchScript
yolov5s-seg.onnx # ONNX Runtime or OpenCV DNN with --dnn
yolov5s-seg_openvino_label # OpenVINO
yolov5s-seg.engine # TensorRT
yolov5s-seg.mlmodel # CoreML (macOS-only)
yolov5s-seg_saved_model # TensorFlow SavedModel
yolov5s-seg.pb # TensorFlow GraphDef
yolov5s-seg.tflite # TensorFlow Lite
yolov5s-seg_edgetpu.tflite # TensorFlow Edge TPU
yolov5s-seg_paddle_model # PaddlePaddle
"""
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
def save_one_txt(predn, save_conf, shape, file):
# Save one txt result
gn = torch.tensor(shape)[[1, 0, 1, 0]] # normalization gain whwh
for *xyxy, conf, cls in predn.tolist():
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh, conf) if save_conf else (cls, *xywh) # label format
with open(file, 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
def save_one_json(predn, jdict, path, class_map, pred_masks):
# Save one JSON result {"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}
def single_encode(x):
rle = encode(np.asarray(x[:, :, None], order='F', dtype='uint8'))[0]
rle['counts'] = rle['counts'].decode('utf-8')
return rle
image_id = int(path.stem) if path.stem.isnumeric() else path.stem
box = xyxy2xywh(predn[:, :4]) # xywh
box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
pred_masks = np.transpose(pred_masks, (2, 0, 1))
with ThreadPool(NUM_THREADS) as pool:
rles = pool.map(single_encode, pred_masks)
for i, (p, b) in enumerate(zip(predn.tolist(), box.tolist())):
jdict.append({
'image_id': image_id,
'category_id': class_map[int(p[5])],
'bbox': [round(x, 3) for x in b],
'score': round(p[4], 5),
'segmentation': rles[i]})
def process_batch(detections, labels, iouv, pred_masks=None, gt_masks=None, overlap=False, masks=False):
"""
Return correct prediction matrix
Arguments:
detections (array[N, 6]), x1, y1, x2, y2, conf, class
labels (array[M, 5]), class, x1, y1, x2, y2
Returns:
correct (array[N, 10]), for 10 IoU levels
"""
if masks:
if overlap:
nl = len(labels)
index = torch.arange(nl, device=gt_masks.device).view(nl, 1, 1) + 1
gt_masks = gt_masks.repeat(nl, 1, 1) # shape(1,640,640) -> (n,640,640)
gt_masks = torch.where(gt_masks == index, 1.0, 0.0)
if gt_masks.shape[1:] != pred_masks.shape[1:]:
gt_masks = F.interpolate(gt_masks[None], pred_masks.shape[1:], mode='bilinear', align_corners=False)[0]
gt_masks = gt_masks.gt_(0.5)
iou = mask_iou(gt_masks.view(gt_masks.shape[0], -1), pred_masks.view(pred_masks.shape[0], -1))
else: # boxes
iou = box_iou(labels[:, 1:], detections[:, :4])
correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)
correct_class = labels[:, 0:1] == detections[:, 5]
for i in range(len(iouv)):
x = torch.where((iou >= iouv[i]) & correct_class) # IoU > threshold and classes match
if x[0].shape[0]:
matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy() # [label, detect, iou]
if x[0].shape[0] > 1:
matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
# matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
correct[matches[:, 1].astype(int), i] = True
return torch.tensor(correct, dtype=torch.bool, device=iouv.device)
@smart_inference_mode()
def run(
data,
weights=None, # model.pt path(s)
batch_size=32, # batch size
imgsz=640, # inference size (pixels)
conf_thres=0.001, # confidence threshold
iou_thres=0.6, # NMS IoU threshold
max_det=300, # maximum detections per image
task='val', # train, val, test, speed or study
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
workers=8, # max dataloader workers (per RANK in DDP mode)
single_cls=False, # treat as single-class dataset
augment=False, # augmented inference
verbose=False, # verbose output
save_txt=False, # save results to *.txt
save_hybrid=False, # save label+prediction hybrid results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_json=False, # save a COCO-JSON results file
project=ROOT / 'runs/val-seg', # save to project/name
name='exp', # save to project/name
exist_ok=False, # existing project/name ok, do not increment
half=True, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
model=None,
dataloader=None,
save_dir=Path(''),
plots=True,
overlap=False,
mask_downsample_ratio=1,
compute_loss=None,
callbacks=Callbacks(),
):
if save_json:
check_requirements('pycocotools>=2.0.6')
process = process_mask_native # more accurate
else:
process = process_mask # faster
# Initialize/load model and set device
training = model is not None
if training: # called by train.py
device, pt, jit, engine = next(model.parameters()).device, True, False, False # get model device, PyTorch model
half &= device.type != 'cpu' # half precision only supported on CUDA
model.half() if half else model.float()
nm = de_parallel(model).model[-1].nm # number of masks
else: # called directly
device = select_device(device, batch_size=batch_size)
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
# Load model
model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine
imgsz = check_img_size(imgsz, s=stride) # check image size
half = model.fp16 # FP16 supported on limited backends with CUDA
nm = de_parallel(model).model.model[-1].nm if isinstance(model, SegmentationModel) else 32 # number of masks
if engine:
batch_size = model.batch_size
else:
device = model.device
if not (pt or jit):
batch_size = 1 # export.py models default to batch-size 1
LOGGER.info(f'Forcing --batch-size 1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models')
# Data
data = check_dataset(data) # check
# Configure
model.eval()
cuda = device.type != 'cpu'
is_coco = isinstance(data.get('val'), str) and data['val'].endswith(f'coco{os.sep}val2017.txt') # COCO dataset
nc = 1 if single_cls else int(data['nc']) # number of classes
iouv = torch.linspace(0.5, 0.95, 10, device=device) # iou vector for mAP@0.5:0.95
niou = iouv.numel()
# Dataloader
if not training:
if pt and not single_cls: # check --weights are trained on --data
ncm = model.model.nc
assert ncm == nc, f'{weights} ({ncm} classes) trained on different --data than what you passed ({nc} ' \
f'classes). Pass correct combination of --weights and --data that are trained together.'
model.warmup(imgsz=(1 if pt else batch_size, 3, imgsz, imgsz)) # warmup
pad, rect = (0.0, False) if task == 'speed' else (0.5, pt) # square inference for benchmarks
task = task if task in ('train', 'val', 'test') else 'val' # path to train/val/test images
dataloader = create_dataloader(data[task],
imgsz,
batch_size,
stride,
single_cls,
pad=pad,
rect=rect,
workers=workers,
prefix=colorstr(f'{task}: '),
overlap_mask=overlap,
mask_downsample_ratio=mask_downsample_ratio)[0]
seen = 0
confusion_matrix = ConfusionMatrix(nc=nc)
names = model.names if hasattr(model, 'names') else model.module.names # get class names
if isinstance(names, (list, tuple)): # old format
names = dict(enumerate(names))
class_map = coco80_to_coco91_class() if is_coco else list(range(1000))
s = ('%22s' + '%11s' * 10) % ('Class', 'Images', 'Instances', 'Box(P', 'R', 'mAP50', 'mAP50-95)', 'Mask(P', 'R',
'mAP50', 'mAP50-95)')
dt = Profile(), Profile(), Profile()
metrics = Metrics()
loss = torch.zeros(4, device=device)
jdict, stats = [], []
# callbacks.run('on_val_start')
pbar = tqdm(dataloader, desc=s, bar_format=TQDM_BAR_FORMAT) # progress bar
for batch_i, (im, targets, paths, shapes, masks) in enumerate(pbar):
# callbacks.run('on_val_batch_start')
with dt[0]:
if cuda:
im = im.to(device, non_blocking=True)
targets = targets.to(device)
masks = masks.to(device)
masks = masks.float()
im = im.half() if half else im.float() # uint8 to fp16/32
im /= 255 # 0 - 255 to 0.0 - 1.0
nb, _, height, width = im.shape # batch size, channels, height, width
# Inference
with dt[1]:
preds, protos, train_out = model(im) if compute_loss else (*model(im, augment=augment)[:2], None)
# Loss
if compute_loss:
loss += compute_loss((train_out, protos), targets, masks)[1] # box, obj, cls
# NMS
targets[:, 2:] *= torch.tensor((width, height, width, height), device=device) # to pixels
lb = [targets[targets[:, 0] == i, 1:] for i in range(nb)] if save_hybrid else [] # for autolabelling
with dt[2]:
preds = non_max_suppression(preds,
conf_thres,
iou_thres,
labels=lb,
multi_label=True,
agnostic=single_cls,
max_det=max_det,
nm=nm)
# Metrics
plot_masks = [] # masks for plotting
for si, (pred, proto) in enumerate(zip(preds, protos)):
labels = targets[targets[:, 0] == si, 1:]
nl, npr = labels.shape[0], pred.shape[0] # number of labels, predictions
path, shape = Path(paths[si]), shapes[si][0]
correct_masks = torch.zeros(npr, niou, dtype=torch.bool, device=device) # init
correct_bboxes = torch.zeros(npr, niou, dtype=torch.bool, device=device) # init
seen += 1
if npr == 0:
if nl:
stats.append((correct_masks, correct_bboxes, *torch.zeros((2, 0), device=device), labels[:, 0]))
if plots:
confusion_matrix.process_batch(detections=None, labels=labels[:, 0])
continue
# Masks
midx = [si] if overlap else targets[:, 0] == si
gt_masks = masks[midx]
pred_masks = process(proto, pred[:, 6:], pred[:, :4], shape=im[si].shape[1:])
# Predictions
if single_cls:
pred[:, 5] = 0
predn = pred.clone()
scale_boxes(im[si].shape[1:], predn[:, :4], shape, shapes[si][1]) # native-space pred
# Evaluate
if nl:
tbox = xywh2xyxy(labels[:, 1:5]) # target boxes
scale_boxes(im[si].shape[1:], tbox, shape, shapes[si][1]) # native-space labels
labelsn = torch.cat((labels[:, 0:1], tbox), 1) # native-space labels
correct_bboxes = process_batch(predn, labelsn, iouv)
correct_masks = process_batch(predn, labelsn, iouv, pred_masks, gt_masks, overlap=overlap, masks=True)
if plots:
confusion_matrix.process_batch(predn, labelsn)
stats.append((correct_masks, correct_bboxes, pred[:, 4], pred[:, 5], labels[:, 0])) # (conf, pcls, tcls)
pred_masks = torch.as_tensor(pred_masks, dtype=torch.uint8)
if plots and batch_i < 3:
plot_masks.append(pred_masks[:15]) # filter top 15 to plot
# Save/log
if save_txt:
save_one_txt(predn, save_conf, shape, file=save_dir / 'labels' / f'{path.stem}.txt')
if save_json:
pred_masks = scale_image(im[si].shape[1:],
pred_masks.permute(1, 2, 0).contiguous().cpu().numpy(), shape, shapes[si][1])
save_one_json(predn, jdict, path, class_map, pred_masks) # append to COCO-JSON dictionary
# callbacks.run('on_val_image_end', pred, predn, path, names, im[si])
# Plot images
if plots and batch_i < 3:
if len(plot_masks):
plot_masks = torch.cat(plot_masks, dim=0) | plot_images_and_masks(im, targets, masks, paths, save_dir / f'val_batch{batch_i}_labels.jpg', names) | 15 | 2023-11-12 13:28:26+00:00 | 24k |
cyberark/ark-sdk-python | ark_sdk_python/cli_services/dpa/vm/ark_dpa_vm_policies_editor_service.py | [
{
"identifier": "ArkInquirerRender",
"path": "ark_sdk_python/args/ark_args_formatter.py",
"snippet": "class ArkInquirerRender(ConsoleRender):\n # pylint: disable=keyword-arg-before-vararg,protected-access\n def __init__(self, event_generator=None, *args, **kwargs):\n super().__init__(event_... | from datetime import date, timedelta
from typing import Dict, Final, List, Optional
from overrides import overrides
from ark_sdk_python.args.ark_args_formatter import ArkInquirerRender
from ark_sdk_python.auth.ark_isp_auth import ArkISPAuth
from ark_sdk_python.cli_services.dpa.common.ark_dpa_base_policies_editor_service import ArkDPABasePoliciesEditorService
from ark_sdk_python.models.ark_profile import ArkProfile
from ark_sdk_python.models.cli_services.dpa.policies_editor.vm import ArkDPAVMGeneratePolicy
from ark_sdk_python.models.common import ArkProtocolType, ArkWorkspaceType
from ark_sdk_python.models.services import ArkServiceConfig
from ark_sdk_python.models.services.dpa.policies.common import ArkDPADeletePolicy, ArkDPAGetPolicy, ArkDPARuleStatus, ArkDPAUserData
from ark_sdk_python.models.services.dpa.policies.vm import (
ArkDPAVMAddPolicy,
ArkDPAVMAuthorizationRule,
ArkDPAVMAWSProviderData,
ArkDPAVMAzureProviderData,
ArkDPAVMConnectionDataType,
ArkDPAVMConnectionInformation,
ArkDPAVMFQDNOperator,
ArkDPAVMFQDNRule,
ArkDPAVMFQDNRulesConjunction,
ArkDPAVMGCPProviderData,
ArkDPAVMLocalEphemeralUserConnectionMethodData,
ArkDPAVMOnPremProviderData,
ArkDPAVMPolicy,
ArkDPAVMPolicyListItem,
ArkDPAVMProvider,
ArkDPAVMRDPLocalEphemeralUserConnectionData,
ArkDPAVMUpdatePolicy,
)
from ark_sdk_python.services.dpa.policies.vm.ark_dpa_vm_policies_service import ArkDPAVMPoliciesService
import inquirer | 14,456 |
SERVICE_CONFIG: Final[ArkServiceConfig] = ArkServiceConfig(
service_name='dpa-policies-vm-editor', required_authenticator_names=['isp'], optional_authenticator_names=[]
)
DEFAULT_GENERATED_POLICY: Final[ArkDPAVMPolicy] = ArkDPAVMPolicy(
policy_name='Default VM Policy',
status=ArkDPARuleStatus.Draft,
description='Auto generated vm policy',
providers_data={},
start_date=date.today().strftime('%Y-%m-%d'),
end_date=(date.today() + timedelta(days=7)).strftime('%Y-%m-%d'),
user_access_rules=[],
)
DEFAULT_GENERATED_AUTHORIZATION_RULE: Final[ArkDPAVMAuthorizationRule] = ArkDPAVMAuthorizationRule(
rule_name='Default VM Rule',
user_data=ArkDPAUserData(roles=['DpaAdmin'], groups=[], users=[]),
connection_information=ArkDPAVMConnectionInformation(
connect_as={},
grant_access=2,
idle_time=10,
days_of_week=[],
full_days=True,
hours_from='07:00',
hours_to='17:00',
time_zone='Asia/Jerusalem',
),
)
DEFAULT_GENERATED_PROVIDERS: Final[Dict[ArkWorkspaceType, ArkDPAVMProvider]] = {
ArkWorkspaceType.AWS: ArkDPAVMAWSProviderData(regions=[], tags=[{'key': 'value'}], vpc_ids=[], account_ids=[]),
ArkWorkspaceType.AZURE: ArkDPAVMAzureProviderData(
regions=[], tags=[{'key': 'value'}], resource_groups=[], vnet_ids=[], subscriptions=[]
),
ArkWorkspaceType.GCP: ArkDPAVMGCPProviderData(regions=[], tags=[{'key': 'value'}], network_ids=[], projects=[]),
ArkWorkspaceType.ONPREM: ArkDPAVMOnPremProviderData(
fqdn_rules_conjunction=ArkDPAVMFQDNRulesConjunction.OR,
fqdn_rules=[ArkDPAVMFQDNRule(operator=ArkDPAVMFQDNOperator.WILDCARD, computername_pattern='*', domain='default.com')],
),
}
DEFAULT_GENERATED_PROTOCOLS: Final[Dict[ArkProtocolType, ArkDPAVMConnectionDataType]] = {
ArkProtocolType.SSH: 'root',
ArkProtocolType.RDP: ArkDPAVMRDPLocalEphemeralUserConnectionData(
local_ephemeral_user=ArkDPAVMLocalEphemeralUserConnectionMethodData(assign_groups={'Administrators'})
),
}
SUPPORTED_SSH_PROTOCOL_PROVIDERS: Final[ArkWorkspaceType] = [
ArkWorkspaceType.AWS,
ArkWorkspaceType.AZURE,
ArkWorkspaceType.GCP,
ArkWorkspaceType.ONPREM,
]
SUPPORTED_RDP_PROTOCOL_PROVIDERS: Final[ArkWorkspaceType] = [ArkWorkspaceType.AWS, ArkWorkspaceType.AZURE, ArkWorkspaceType.ONPREM]
class ArkDPAVMPoliciesEditorService(
|
SERVICE_CONFIG: Final[ArkServiceConfig] = ArkServiceConfig(
service_name='dpa-policies-vm-editor', required_authenticator_names=['isp'], optional_authenticator_names=[]
)
DEFAULT_GENERATED_POLICY: Final[ArkDPAVMPolicy] = ArkDPAVMPolicy(
policy_name='Default VM Policy',
status=ArkDPARuleStatus.Draft,
description='Auto generated vm policy',
providers_data={},
start_date=date.today().strftime('%Y-%m-%d'),
end_date=(date.today() + timedelta(days=7)).strftime('%Y-%m-%d'),
user_access_rules=[],
)
DEFAULT_GENERATED_AUTHORIZATION_RULE: Final[ArkDPAVMAuthorizationRule] = ArkDPAVMAuthorizationRule(
rule_name='Default VM Rule',
user_data=ArkDPAUserData(roles=['DpaAdmin'], groups=[], users=[]),
connection_information=ArkDPAVMConnectionInformation(
connect_as={},
grant_access=2,
idle_time=10,
days_of_week=[],
full_days=True,
hours_from='07:00',
hours_to='17:00',
time_zone='Asia/Jerusalem',
),
)
DEFAULT_GENERATED_PROVIDERS: Final[Dict[ArkWorkspaceType, ArkDPAVMProvider]] = {
ArkWorkspaceType.AWS: ArkDPAVMAWSProviderData(regions=[], tags=[{'key': 'value'}], vpc_ids=[], account_ids=[]),
ArkWorkspaceType.AZURE: ArkDPAVMAzureProviderData(
regions=[], tags=[{'key': 'value'}], resource_groups=[], vnet_ids=[], subscriptions=[]
),
ArkWorkspaceType.GCP: ArkDPAVMGCPProviderData(regions=[], tags=[{'key': 'value'}], network_ids=[], projects=[]),
ArkWorkspaceType.ONPREM: ArkDPAVMOnPremProviderData(
fqdn_rules_conjunction=ArkDPAVMFQDNRulesConjunction.OR,
fqdn_rules=[ArkDPAVMFQDNRule(operator=ArkDPAVMFQDNOperator.WILDCARD, computername_pattern='*', domain='default.com')],
),
}
DEFAULT_GENERATED_PROTOCOLS: Final[Dict[ArkProtocolType, ArkDPAVMConnectionDataType]] = {
ArkProtocolType.SSH: 'root',
ArkProtocolType.RDP: ArkDPAVMRDPLocalEphemeralUserConnectionData(
local_ephemeral_user=ArkDPAVMLocalEphemeralUserConnectionMethodData(assign_groups={'Administrators'})
),
}
SUPPORTED_SSH_PROTOCOL_PROVIDERS: Final[ArkWorkspaceType] = [
ArkWorkspaceType.AWS,
ArkWorkspaceType.AZURE,
ArkWorkspaceType.GCP,
ArkWorkspaceType.ONPREM,
]
SUPPORTED_RDP_PROTOCOL_PROVIDERS: Final[ArkWorkspaceType] = [ArkWorkspaceType.AWS, ArkWorkspaceType.AZURE, ArkWorkspaceType.ONPREM]
class ArkDPAVMPoliciesEditorService( | ArkDPABasePoliciesEditorService[ArkDPAVMPolicy, ArkDPAVMPolicyListItem, ArkDPAVMAddPolicy, ArkDPAVMUpdatePolicy, ArkDPAVMGeneratePolicy] | 19 | 2023-11-13 09:24:31+00:00 | 24k |
kampta/asic | train.py | [
{
"identifier": "Logger",
"path": "commons/logger.py",
"snippet": "class Logger(SummaryWriter):\n\n def __init__(self, results_path, log_to_tb=False, log_to_wandb=True):\n super().__init__(results_path)\n self.results_path = results_path\n self.log_to_tb = log_to_tb\n self... | import argparse
import torch
import numpy as np
import json
import os
import torch.nn.functional as F
import wandb
from torch import nn, optim
from tqdm import tqdm
from pathlib import Path
from commons.logger import Logger, log_visuals
from commons.distributed import get_rank, setup_distributed, reduce_loss_dict,\
get_world_size, primary
from commons.utils import sample_tuples
from datasets.cub import CUBDataset
from datasets.in_memory import InMemoryDataset
from datasets.spair import SpairDataset
from datasets.utils import Augmentor
from models.utils import accumulate, requires_grad
from models.canonical import Canonical, CanonicalMLP
from models.asic import Asic
from losses.reg_losses import total_variation_loss
from thirdparty.lpips.lpips import get_perceptual_loss
from losses.matching_losses import LossCorrsSparse
from thirdparty.gangealing.annealing import DecayingCosineAnnealingWarmRestarts,\
lr_cycle_iters | 17,268 | if args.flow_ssl:
# in_size = extractor.num_patches
# in_ch = extractor.feat_dim
# TODO: read from the file and modfiy accordingly
raise NotImplementedError
else:
in_size = args.img_size
in_ch = 3
stn = Asic(
in_ch, in_size, mf=args.channel_multiplier, bilinear=args.bilinear,
padding_mode=args.padding_mode, use_tanh=args.use_tanh).to(device)
if args.stn_ema:
t_ema = Asic(
in_ch, in_size, mf=args.channel_multiplier, bilinear=args.bilinear,
padding_mode=args.padding_mode).to(device)
accumulate(t_ema, stn, 0)
else:
t_ema = stn
if args.mask_weight > 0:
num_ch = 4
else:
num_ch = 3
if args.use_mlp:
canon = CanonicalMLP(
input_dim=2, output_dim=num_ch, hidden_dim=args.mlp_hidden_dim,
skip_layers=args.mlp_skip_layers, num_layers=args.mlp_num_layers,
resolution=args.canon_size).to(device)
else:
canon = Canonical((1, num_ch, args.canon_size, args.canon_size),
clamp=args.clamp).to(device)
if args.canon_ema:
if args.use_mlp:
c_ema = CanonicalMLP(
input_dim=2, output_dim=num_ch, hidden_dim=args.mlp_hidden_dim,
skip_layers=args.mlp_skip_layers, num_layers=args.mlp_num_layers,
resolution=args.canon_size).to(device)
else:
c_ema = Canonical((1, num_ch, args.canon_size, args.canon_size),
clamp=args.clamp).to(device)
accumulate(c_ema, canon, 0)
else:
c_ema = canon
# Setup the perceptual loss function:
loss_fn = get_perceptual_loss(args.loss_fn, device)
if args.nbb_weight > 0.:
nbb_loss_fn = LossCorrsSparse(flow_size=in_size, T=args.sparse_temp)
nbb_loss_fn = nbb_loss_fn.to(device)
else:
nbb_loss_fn = None
if args.canon_lr == 0:
requires_grad(canon, False)
canon_optim = None
canon_sched = None
else:
canon_optim = optim.Adam(canon.parameters(), lr=args.canon_lr,
betas=(0.9, 0.999), eps=1e-8)
canon_sched = DecayingCosineAnnealingWarmRestarts(
canon_optim, T_0=1, T_mult=args.tm, decay=args.decay)
if primary():
print(f"{count_parameters(stn)} parameters in STN")
print(f"{count_parameters(canon)} parameters in Canonical")
# Setup optimizers and learning rate schedulers:
t_optim = optim.Adam(stn.parameters(), lr=args.stn_lr, betas=(0.9, 0.999),
eps=1e-8)
t_sched = DecayingCosineAnnealingWarmRestarts(
t_optim, T_0=1, T_mult=args.tm, decay=args.decay)
# See if the start iteration can be recovered when resuming training:
args.start_iter = 0
# Load pre-trained generator (and optionally resume from a GANgealing checkpoint):
ckpt_path = Path(args.results) / args.exp_name / 'checkpoint.pt'
try:
print(f"Loading model from {ckpt_path}")
ckpt = torch.load(ckpt_path)
canon.load_state_dict(ckpt["canon"])
c_ema.load_state_dict(ckpt["c_ema"])
stn.load_state_dict(ckpt["t"])
t_ema.load_state_dict(ckpt["t_ema"])
t_optim.load_state_dict(ckpt["t_optim"])
t_sched.load_state_dict(ckpt["t_sched"])
if canon_optim is not None:
canon_optim.load_state_dict(ckpt["canon_optim"])
if canon_optim is not None:
canon_sched.load_state_dict(ckpt["canon_sched"])
args.start_iter = ckpt['iter']
print(f"Checkpoint found. Resuming from {args.start_iter} iterations")
except FileNotFoundError:
print("No checkpoint found. Training from scratch.")
except KeyError:
raise Exception
# Move models to DDP if distributed training is enabled:
if args.distributed:
local_rank = int(os.environ["LOCAL_RANK"])
stn = nn.parallel.DistributedDataParallel(
stn, device_ids=[local_rank], output_device=local_rank,
broadcast_buffers=False)
canon = nn.parallel.DistributedDataParallel(
canon, device_ids=[local_rank], output_device=local_rank,
broadcast_buffers=False)
# Setup data
if args.dset.lower() == 'folder':
interim_dir = Path(args.img_dir).stem
flow_dir = Path(args.flow_dir) / interim_dir / f'{args.bb}_s{args.bb_stride}'
|
def save_state_dict(ckpt_name, c_module, t_module, c_ema, t_ema, canon_optim,
canon_sched, t_optim, t_sched, args, step,
add_step_to_name=False):
ckpt_dict = {
"canon": c_module.state_dict(),
"t": t_module.state_dict(),
"c_ema": c_ema.state_dict(),
"t_ema": t_ema.state_dict(),
"t_optim": t_optim.state_dict(),
"t_sched": t_sched.state_dict(),
"canon_optim": canon_optim.state_dict()
if canon_optim is not None else None,
"canon_sched": canon_sched.state_dict()
if canon_sched is not None else None,
"args": args,
"iter": step
}
torch.save(ckpt_dict, f'{results_path}/{ckpt_name}.pt')
if add_step_to_name:
torch.save(ckpt_dict, f'{results_path}/{ckpt_name}_{step:07d}.pt')
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
def base_training_argparse():
parser = argparse.ArgumentParser(description="Training")
# Main training arguments:
parser.add_argument("--exp-name", type=str, required=True,
help="Name for experiment run (used for logging)")
parser.add_argument("--results", type=str, default='logs',
help='path to the results directory')
parser.add_argument("--seed", default=0, type=int,
help='Random seed for this experiment')
parser.add_argument("--dset", type=str, default='cub',
choices=["cub", "spair"])
parser.add_argument("--img_dir", type=str, required=True,
help="Path to real data")
parser.add_argument("--flow_dir", type=str, default='processed_data',
help="Path to preprocessed flows")
parser.add_argument("--mask_threshold", type=int, default=1,
help="Threshold for masking")
parser.add_argument("--mask_bbox_pad", type=int, default=4,
help="Crop with some padding")
parser.add_argument("--img_size", default=256, type=int,
help='resolution of real images')
parser.add_argument("--iter", type=int, default=20000,
help="total training iterations")
parser.add_argument("--batch", type=int, default=20,
help="batch size per-GPU")
parser.add_argument("--num_workers", type=int, default=2,
help="num workers for dataloader")
# Dataset hyperparameters:
parser.add_argument("--cub_idx", type=int, default=1, help="cub category")
parser.add_argument("--split", default='test',
choices=['test', 'val'],
help='splits for training and validation')
parser.add_argument("--use_coseg_masks", action='store_true')
parser.add_argument("--num_parts", default=4, type=int)
parser.add_argument("--spair_cat", default='cat', help="cub category")
# Loss hyperparameters:
parser.add_argument("--loss_fn", type=str, default='vgg_ssl',
choices=['lpips', 'vgg_ssl'],
help="The perceptual loss to use.")
parser.add_argument("--rec_weight", type=float, default=1.,
help='weight for reconstruction loss')
parser.add_argument("--nbb_weight", type=float, default=30.,
help='weight for nbb loss')
parser.add_argument("--flow_tv_weight", default=15000.0, type=float,
help="""Loss weighting of the Total Variation
smoothness regularizer on the residual flow""")
parser.add_argument("--equi_weight", default=1.0, type=float,
help='Loss weighting for equivariance')
parser.add_argument("--sparse_topk", type=int, default=None,
help='number of sparse correspondences for loss')
parser.add_argument("--sparse_temp", type=float, default=1,
help='temperature for sparse loss')
parser.add_argument("--mask_weight", default=0.1, type=float,
help="""Loss weighting of the mask""")
parser.add_argument("--parts_weight", default=10.0, type=float,
help="""Loss weighting of the Parts Mask""")
parser.add_argument("--use_nbb_parts", action='store_true')
# Augmentation hyperparameters
parser.add_argument("--jitter", default=[0.4, 0.4, 0.2, 0.1], type=float,
nargs='+', help='augmentation mode')
parser.add_argument("--jitter_prob", default=0.8, type=float)
parser.add_argument("--gray_prob", default=0.2, type=float)
parser.add_argument("--solar_prob", default=0.2, type=float)
parser.add_argument("--tps_scale", default=0.4, type=float)
# Canonical space
parser.add_argument("--unwarp_size", type=int, default=128,
help="resolution for unwarping")
# Learned Grid hyperparameters
parser.add_argument("--canon_size", type=int, default=256,
help="resolution of canonical space")
parser.add_argument("--clamp", action='store_true',
help="clamp values of canonical space (-1, 1)")
# MLP Hyperparams
parser.add_argument("--use_mlp", action='store_true')
parser.add_argument("--mlp_hidden_dim", type=int, default=256,
help="number of hidden units per layer")
parser.add_argument("--mlp_num_layers", type=int, default=8,
help="number of layers")
parser.add_argument("--mlp_skip_layers", type=int, nargs='+',
default=[4, 7], help="skip layers")
# Model hyperparameters:
parser.add_argument("--canon_lr", type=float, default=0.003,
help="base learning rate of canonical space")
parser.add_argument("--canon_ema", action='store_true',
help='Enable ema for canonical space')
parser.add_argument("--stn_ema", action='store_true',
help='Enable ema for canonical space')
parser.add_argument("--stn_lr", type=float, default=0.003,
help="base learning rate of SpatialTransformer")
parser.add_argument("--flow_ssl", action='store_true',
help="""If specified, apply STN on SSL features)""")
parser.add_argument("--channel_multiplier", default=0.5, type=float,
help='channel multiplier for smaller models')
parser.add_argument("--bilinear", action='store_true',
help='Apply bilinear upsample/downsample')
parser.add_argument("--padding_mode", default='border',
choices=['border', 'zeros', 'reflection'], type=str,
help="""Padding algorithm for when the STN samples
beyond image boundaries""")
parser.add_argument("--use_tanh", action='store_true',
help='Use tanh activation at the flow output')
parser.add_argument("--disable_tps", action='store_true',
help='disable tps transformations')
# Backbone parameters
parser.add_argument("--bb", default='dino_vits8',
choices=['dino_vits8', 'dino_vits16', 'dino_vitb8',
'dino_vitb16', 'vit_small_patch8_224',
'vit_small_patch16_224',
'vit_base_patch16_224'],
help='backbone models')
parser.add_argument('--bb_stride', default=2, type=int,
help="stride.")
# Visualization hyperparameters:
parser.add_argument("--vis_every", type=int, default=500,
help="""frequency with which visualizations are
generated during training""")
parser.add_argument("--vis_denseres", type=int, default=32,
help='number of sparse correspondences to visualize')
parser.add_argument("--ckpt_every", type=int, default=10000,
help='frequency of checkpointing during training')
parser.add_argument("--log_every", default=25, type=int,
help='How frequently to log data to TensorBoard')
parser.add_argument("--n_sample", type=int, default=4,
help="""number of images (real and fake) to
generate visuals for""")
parser.add_argument("--disable_wandb", action='store_true',
help='Disable wandb for debugging')
# Learning Rate scheduler hyperparameters:
parser.add_argument("--period", default=10000, type=float,
help="""Period for cosine learning rate scheduler
(measured in gradient steps)""")
parser.add_argument("--decay", default=0.9, type=float,
help="""Decay factor for the cosine learning rate
scheduler""")
parser.add_argument("--tm", default=2, type=int,
help="""Period multiplier for the cosine learning
rate scheduler""")
return parser
def train(args, train_dset, canon, stn, c_ema, t_ema, canon_optim,
canon_sched, t_optim, t_sched, loss_fn, nbb_loss_fn, device, writer):
# Record modules to make saving checkpoints easier:
if args.distributed:
t_module = stn.module
c_module = canon.module
else:
t_module = stn
c_module = canon
# Initialize Spatial Transformation Generator (Thin Plate Spline)
aug = Augmentor(jitter=args.jitter, jitter_prob=args.jitter_prob,
gray_prob=args.gray_prob, solar_prob=args.solar_prob,
tps_scale=args.tps_scale).to(device)
# A model checkpoint will be saved whenever the learning rate is zero:
zero_lr_iters = lr_cycle_iters(0, args.period, args.iter, args.tm)
early_ckpt_iters = set(zero_lr_iters)
early_vis_iters = {100}
early_vis_iters.update(early_ckpt_iters)
# Initialize various training variables and constants:
rec_loss = torch.tensor(0.0, device='cuda')
flow_tv_loss = torch.tensor(0.0, device='cuda')
nbb_loss = torch.tensor(0.0, device='cuda')
equi_loss = torch.tensor(0.0, device='cuda')
mask_loss = torch.tensor(0.0, device='cuda')
parts_loss = torch.tensor(0.0, device='cuda')
accum = 0.5 ** (32 / (10 * 1000))
# Resize function for perceptual loss
if args.unwarp_size != args.img_size:
scale_factor = args.unwarp_size / args.img_size
resize_fn = nn.Upsample(scale_factor=scale_factor, mode='bilinear',
align_corners=True)
else:
resize_fn = nn.Identity()
# Pre-load on GPU
# Assuming ~30 images of size 256x256, takes up ~23 MB device memory
has_gt_kp = train_dset.kps is not None
all_imgs = train_dset.imgs = train_dset.imgs.to(device) # / 127.5 - 1.0
all_masks = train_dset.masks = train_dset.masks.unsqueeze(1).to(device)
all_parts = train_dset.parts = train_dset.parts.to(device)
if has_gt_kp:
all_kps = train_dset.kps = train_dset.kps.to(device)
# Pseudo GT
pseudo_kps = train_dset.pseudo_kps = torch.from_numpy(train_dset.pseudo_kps).to(device)
num_parts = train_dset.num_parts
loss_topk = pseudo_kps.shape[2] if args.sparse_topk is None else min(args.sparse_topk, pseudo_kps.shape[2])
# Progress bar for monitoring training:
pbar = range(args.start_iter, args.iter)
if primary():
pbar = tqdm(pbar, initial=args.start_iter, dynamic_ncols=True,
smoothing=0.2)
pck_pairs, pck_cycles = log_visuals(
c_ema, t_ema, train_dset, 0, writer, vis_sample=args.n_sample,
vis_denseres=args.vis_denseres)
best_pck_pairs = pck_pairs
best_pck_cycles = pck_cycles
requires_grad(stn, True)
requires_grad(canon, True)
for idx in pbar: # main training loop
i = idx + args.start_iter + 1
####################################
# TRAIN STN and CANON #
####################################
N = args.batch
pairs = sample_tuples(len(train_dset), count=N // 2)
src_idx, trg_idx = pairs[:, 0], pairs[:, 1]
all_idx = np.concatenate([src_idx, trg_idx])
batch_imgs = all_imgs[all_idx]
batch_parts = all_parts[all_idx]
if args.use_nbb_parts:
batch_masks = (batch_parts != num_parts).unsqueeze(1).float()
batch_masks_resized = resize_fn(batch_masks)
else:
batch_masks = all_masks[all_idx]
batch_masks_resized = resize_fn(batch_masks)
kp1 = pseudo_kps[src_idx, trg_idx][:, :loss_topk] # (N/2, K, 4)
kp2 = pseudo_kps[trg_idx, src_idx][:, :loss_topk] # (N/2, K, 4)
batch_kps_vis = kp1[..., 2] > 0 # (N/2, K)
batch_kps_wt = torch.ones_like(batch_kps_vis).float() # (N/2, K)
batch_kps = torch.cat([kp1, kp2])[..., :2] # (N, K, 2)
if args.use_nbb_parts:
nbb_parts_vis = (kp1[..., 3] != args.num_parts) * (kp2[..., 3] != args.num_parts)
batch_kps_wt *= nbb_parts_vis
# Map the images to the canonical space
flow, delta_flow = stn(batch_imgs)
unwarped = canon.unwarp(flow, args.unwarp_size)
# NBB weight
if args.nbb_weight > 0.:
nbb_loss = nbb_loss_fn(flow[:N//2], flow[N//2:],
batch_kps[:N//2], batch_kps[N//2:],
batch_kps_vis, batch_kps_wt)
if args.equi_weight > 0.:
# Apply tps transformations
if args.disable_tps:
batch_imgs_t = aug.forward_geom(aug.forward_color(batch_imgs))
batch_masks_t = aug.forward_geom(batch_masks, fixed=True)
# Apply tps to flow
flow_tf = aug.forward_geom(flow.permute(0, 3, 1, 2), fixed=True).permute(0, 2, 3, 1)
else:
batch_imgs_t = aug.forward_tps(aug.forward_color(batch_imgs))
batch_masks_t = aug.forward_tps(batch_masks, fixed=True)
# Apply tps to flow
flow_tf = aug.forward_tps(flow.permute(0, 3, 1, 2), fixed=True).permute(0, 2, 3, 1)
batch_masks_t = torch.where(batch_masks_t > 0.5, 1., 0.)
batch_masks_t_resized = resize_fn(batch_masks_t)
vis = batch_masks_t * batch_masks
# Flow of tps image
flow_ft, _ = stn(batch_imgs_t)
unwarped_ft = canon.unwarp(flow_ft, args.unwarp_size)
equi_loss = F.l1_loss(flow_ft, flow_tf.detach(), reduction='none') \
+ F.l1_loss(flow_tf, flow_ft.detach(), reduction='none')
equi_loss = (equi_loss * vis.squeeze(1).unsqueeze(-1)).mean()
if args.mask_weight > 0:
unwarped_mask = unwarped[:, [3]]
mask_loss = F.binary_cross_entropy_with_logits(unwarped_mask, batch_masks_resized)
if args.equi_weight > 0.:
unwarped_ft_mask = unwarped_ft[:, [3]]
mask_loss = 0.5 * mask_loss + \
0.5 * F.binary_cross_entropy_with_logits(
unwarped_ft_mask, batch_masks_t_resized)
# Get Total Variation Loss on flow
if args.flow_tv_weight > 0:
flow_tv_loss = total_variation_loss(delta_flow)
# Reconstruction loss
if args.rec_weight > 0:
unwarped = unwarped * batch_masks_resized
resized_img = resize_fn(batch_imgs) * batch_masks_resized
rec_loss = loss_fn(unwarped[:, :3], resized_img).mean()
if args.equi_weight > 0.:
unwarped_ft = unwarped_ft * batch_masks_t_resized
resized_img = resize_fn(batch_imgs_t) * batch_masks_t_resized
rec_loss = 0.5*rec_loss + 0.5 * loss_fn(unwarped_ft[:, :3], resized_img).mean()
# Parts Loss
if args.parts_weight > 0.:
# Calculate the centroid of each part
part_centroids = torch.zeros(num_parts+1, 2, dtype=torch.float,
device=device)
part_centroids.index_add_(0, batch_parts.reshape(-1),
flow.reshape(-1, 2))
part_counts = torch.bincount(batch_parts.reshape(-1)).float()
part_centroids = (part_centroids/part_counts.unsqueeze(-1)).detach()
# Compute the loss as the distance of the centroid from the flows
parts_loss = F.l1_loss(flow, part_centroids[batch_parts],
reduction='none')
parts_loss = (parts_loss * batch_masks.squeeze(1).unsqueeze(-1)).mean()
loss_dict = {"p": rec_loss, "ftv": flow_tv_loss,
"nbb": nbb_loss, "equi": equi_loss, "mask": mask_loss,
'parts': parts_loss}
canon.zero_grad()
stn.zero_grad()
full_stn_loss = args.rec_weight * rec_loss + \
args.flow_tv_weight * flow_tv_loss + \
args.nbb_weight * nbb_loss + args.equi_weight * equi_loss + \
args.mask_weight * mask_loss + args.parts_weight * parts_loss
full_stn_loss.backward()
t_optim.step()
epoch = max(0, i / args.period)
t_sched.step(epoch)
if args.canon_lr > 0:
canon_optim.step()
canon_sched.step(epoch)
if args.stn_ema:
accumulate(t_ema, t_module, accum)
if args.canon_ema:
accumulate(c_ema, c_module, accum)
# Aggregate loss information across GPUs
loss_reduced = reduce_loss_dict(loss_dict)
if primary():
# Display losses on the progress bar:
perceptual_loss_val = loss_reduced["p"].mean().item()
flow_tv_loss_val = loss_reduced["ftv"].mean().item()
nbb_loss_val = loss_reduced["nbb"].mean().item()
equi_loss_val = loss_reduced["equi"].mean().item()
mask_loss_val = loss_reduced["mask"].mean().item()
parts_loss_val = loss_reduced["parts"].mean().item()
p_str = f"rec: {perceptual_loss_val:.4f}; " \
if args.rec_weight > 0 else ""
ftv_str = f"ftv: {flow_tv_loss_val:.6f}; " \
if args.flow_tv_weight > 0 else ""
nbb_str = f"nbb: {nbb_loss_val:.6f}; " \
if args.nbb_weight > 0 else ""
equi_str = f"equi: {equi_loss_val:.6f}; " \
if args.equi_weight > 0 else ""
mask_str = f"mask: {mask_loss_val:.6f}; " \
if args.mask_weight > 0 else ""
parts_str = f"parts: {parts_loss_val:.6f}; " \
if args.parts_weight > 0 else ""
pbar.set_description(
f"{p_str}{nbb_str}{equi_str}{mask_str}{ftv_str}{parts_str}")
# Log losses and others metrics to TensorBoard:
if i % args.log_every == 0 or i in early_ckpt_iters or i == 1:
writer.add_scalars('', {
'Loss/Full': full_stn_loss.item(),
'Loss/Reconstruction': perceptual_loss_val,
'Loss/TotalVariation': flow_tv_loss_val,
'Loss/NBB': nbb_loss_val,
'Loss/Equi': equi_loss_val,
'Loss/Mask': mask_loss_val,
'Loss/Parts': parts_loss_val,
'Progress/STN_LearningRate': t_sched.get_last_lr()[0],
'Progress/Canon_LearningRate': canon_sched.get_last_lr()[0] if args.canon_lr > 0 else 0.
}, i)
if (i % args.ckpt_every == 0 or i in early_ckpt_iters):
save_state_dict(
'checkpoint', c_module, t_module, c_ema, t_ema,
canon_optim, canon_sched, t_optim, t_sched, args, i, True)
if i % args.vis_every == 0 or i in early_vis_iters or i == 1:
# Save visualizations to Tens orBoard
if i in early_ckpt_iters:
pbar.write(f'{i:07}: LR = {t_sched.get_last_lr()[0]}')
pck_pairs, pck_cycles = log_visuals(
c_ema, t_ema, train_dset, i, writer,
vis_sample=args.n_sample, vis_denseres=args.vis_denseres)
if has_gt_kp and best_pck_cycles[2][0] < pck_cycles[2][0]:
best_pck_pairs = pck_pairs
for k, pck_cycle in enumerate(pck_cycles):
best_pck_cycles[k] = pck_cycle
save_state_dict(
'best', c_module, t_module, c_ema, t_ema,
canon_optim, canon_sched, t_optim, t_sched, args, i)
pck_summary = {}
if has_gt_kp:
pck_summary.update({
'Progress/PCK@0.10': pck_pairs[0] * 100,
'Progress/PCK@0.01': pck_pairs[-1] * 100,
'Progress/BestPCK@0.10': best_pck_pairs[0] * 100,
'Progress/BestPCK@0.01': best_pck_pairs[-1] * 100,
})
for k, pck_cycle in enumerate(pck_cycles):
pck_summary[f'Progress/{k+2}-PCK@0.10'] = pck_cycle[0] * 100
pck_summary[f'Progress/{k+2}-PCK@0.01'] = pck_cycle[-1] * 100
if has_gt_kp:
pck_summary[f'Progress/Best{k+2}-PCK@0.10'] = best_pck_cycles[k][0] * 100
pck_summary[f'Progress/Best{k+2}-PCK@0.01'] = best_pck_cycles[k][-1] * 100
writer.add_scalars('', pck_summary, i)
if __name__ == "__main__":
device = "cuda"
parser = base_training_argparse()
args = parser.parse_args()
# Setup distributed PyTorch and create results directory:
args.distributed = setup_distributed()
results_path = os.path.join(args.results, args.exp_name)
if primary():
# exp_id = hashlib.md5(args.exp_name.encode('utf-8')).hexdigest()
use_wandb = not args.disable_wandb
if use_wandb:
wandb.init(project="asic", entity="kampta", name=args.exp_name,
reinit=True)
wandb.config.update(args)
writer = Logger(results_path, log_to_wandb=use_wandb)
with open(f'{results_path}/opt.txt', 'w') as f:
json.dump(args.__dict__, f, indent=2)
else:
writer = None
# Seed RNG:
torch.manual_seed(args.seed * get_world_size() + get_rank())
np.random.seed(args.seed * get_world_size() + get_rank())
# UNet output is same size as input by default
# When input are SSL features, we want to upsample
# the flow when loss is computed in the image space
# not upsammple the flow when loss is computed in the
# SSL featuremap space
# Initialize U-Net for regressing flow
if args.flow_ssl:
# in_size = extractor.num_patches
# in_ch = extractor.feat_dim
# TODO: read from the file and modfiy accordingly
raise NotImplementedError
else:
in_size = args.img_size
in_ch = 3
stn = Asic(
in_ch, in_size, mf=args.channel_multiplier, bilinear=args.bilinear,
padding_mode=args.padding_mode, use_tanh=args.use_tanh).to(device)
if args.stn_ema:
t_ema = Asic(
in_ch, in_size, mf=args.channel_multiplier, bilinear=args.bilinear,
padding_mode=args.padding_mode).to(device)
accumulate(t_ema, stn, 0)
else:
t_ema = stn
if args.mask_weight > 0:
num_ch = 4
else:
num_ch = 3
if args.use_mlp:
canon = CanonicalMLP(
input_dim=2, output_dim=num_ch, hidden_dim=args.mlp_hidden_dim,
skip_layers=args.mlp_skip_layers, num_layers=args.mlp_num_layers,
resolution=args.canon_size).to(device)
else:
canon = Canonical((1, num_ch, args.canon_size, args.canon_size),
clamp=args.clamp).to(device)
if args.canon_ema:
if args.use_mlp:
c_ema = CanonicalMLP(
input_dim=2, output_dim=num_ch, hidden_dim=args.mlp_hidden_dim,
skip_layers=args.mlp_skip_layers, num_layers=args.mlp_num_layers,
resolution=args.canon_size).to(device)
else:
c_ema = Canonical((1, num_ch, args.canon_size, args.canon_size),
clamp=args.clamp).to(device)
accumulate(c_ema, canon, 0)
else:
c_ema = canon
# Setup the perceptual loss function:
loss_fn = get_perceptual_loss(args.loss_fn, device)
if args.nbb_weight > 0.:
nbb_loss_fn = LossCorrsSparse(flow_size=in_size, T=args.sparse_temp)
nbb_loss_fn = nbb_loss_fn.to(device)
else:
nbb_loss_fn = None
if args.canon_lr == 0:
requires_grad(canon, False)
canon_optim = None
canon_sched = None
else:
canon_optim = optim.Adam(canon.parameters(), lr=args.canon_lr,
betas=(0.9, 0.999), eps=1e-8)
canon_sched = DecayingCosineAnnealingWarmRestarts(
canon_optim, T_0=1, T_mult=args.tm, decay=args.decay)
if primary():
print(f"{count_parameters(stn)} parameters in STN")
print(f"{count_parameters(canon)} parameters in Canonical")
# Setup optimizers and learning rate schedulers:
t_optim = optim.Adam(stn.parameters(), lr=args.stn_lr, betas=(0.9, 0.999),
eps=1e-8)
t_sched = DecayingCosineAnnealingWarmRestarts(
t_optim, T_0=1, T_mult=args.tm, decay=args.decay)
# See if the start iteration can be recovered when resuming training:
args.start_iter = 0
# Load pre-trained generator (and optionally resume from a GANgealing checkpoint):
ckpt_path = Path(args.results) / args.exp_name / 'checkpoint.pt'
try:
print(f"Loading model from {ckpt_path}")
ckpt = torch.load(ckpt_path)
canon.load_state_dict(ckpt["canon"])
c_ema.load_state_dict(ckpt["c_ema"])
stn.load_state_dict(ckpt["t"])
t_ema.load_state_dict(ckpt["t_ema"])
t_optim.load_state_dict(ckpt["t_optim"])
t_sched.load_state_dict(ckpt["t_sched"])
if canon_optim is not None:
canon_optim.load_state_dict(ckpt["canon_optim"])
if canon_optim is not None:
canon_sched.load_state_dict(ckpt["canon_sched"])
args.start_iter = ckpt['iter']
print(f"Checkpoint found. Resuming from {args.start_iter} iterations")
except FileNotFoundError:
print("No checkpoint found. Training from scratch.")
except KeyError:
raise Exception
# Move models to DDP if distributed training is enabled:
if args.distributed:
local_rank = int(os.environ["LOCAL_RANK"])
stn = nn.parallel.DistributedDataParallel(
stn, device_ids=[local_rank], output_device=local_rank,
broadcast_buffers=False)
canon = nn.parallel.DistributedDataParallel(
canon, device_ids=[local_rank], output_device=local_rank,
broadcast_buffers=False)
# Setup data
if args.dset.lower() == 'folder':
interim_dir = Path(args.img_dir).stem
flow_dir = Path(args.flow_dir) / interim_dir / f'{args.bb}_s{args.bb_stride}' | train_dset = InMemoryDataset( | 9 | 2023-11-14 16:43:16+00:00 | 24k |
atlantic-quantum/Shipyard | tests/printers/visualizer/test_visualize_pulse_sequences.py | [
{
"identifier": "CoreType",
"path": "shipyard/awg_core/awg_core.py",
"snippet": "class CoreType(Enum):\n \"\"\"Enumeration of AWG Core types\"\"\"\n\n HD = \"HD\"\n QA = \"QA\"\n SG = \"SG\""
},
{
"identifier": "ActivationRecord",
"path": "shipyard/call_stack.py",
"snippet": ... | import codecs
import json
import numpy as np
import pytest
from pathlib import Path
from shipyard.awg_core.awg_core import CoreType
from shipyard.call_stack import ActivationRecord, ARType
from shipyard.compiler import Compiler
from shipyard.duration import Duration, TimeUnits
from shipyard.passes.duration_transformer import DurationTransformer
from shipyard.passes.resolve_io_declaration import ResolveIODeclaration
from shipyard.passes.semantic_analysis.semantic_analyzer import SemanticAnalyzer
from shipyard.printers.visualizer.visualize_pulse_sequence import PulseVisualizer
from shipyard.printers.zi import waveform_functions
from shipyard.setup.internal import Frame, Instrument, Port, SetupInternal | 17,486 |
final_call_stack = {
"nested_subroutines": {"dummy": 16},
"complex_arrays": {
"dummy": 4,
"two_d": [[1, 2], [3, 4], [5, 6]],
"my_arr": [complex(1, 0), complex(0, 1), complex(0.8, 0.6)],
"second": [1, 2, 3, 4],
},
}
def files() -> list[str]:
base_path = Path(__file__).parent.parent.parent / "qasm/visualize_pulse"
plen = len(base_path.parts)
FILES = list(base_path.glob("**/*.qasm"))
return [str(Path(*path.parts[plen:])) for path in FILES]
QASM_FILES = files()
def common_files() -> list[str]:
files = []
cut = -5
for q_file in QASM_FILES:
files.append(q_file[:cut])
return files
COMMON_FILES = common_files()
@pytest.fixture(name="basic_setup")
def fixture_basic_setup() -> SetupInternal:
json_path = Path(__file__).parent.parent.parent / "setups/interpreter.json"
return SetupInternal.from_json(json_path)
def test_visit_ClassicalDeclaration():
setup_path = Path(__file__).parent.parent.parent / "setups/complex.json"
qasm_path = Path(__file__).parent.parent.parent / "qasm/interpreter/phase_freq.qasm"
compiler = Compiler(qasm_path, setup_path)
qasm_ast = compiler.load_program(qasm_path)
ResolveIODeclaration().visit(qasm_ast)
SemanticAnalyzer().visit(qasm_ast)
DurationTransformer().visit(qasm_ast)
pv = PulseVisualizer(
SetupInternal.from_json(setup_path), waveform_functions.__dict__
)
|
final_call_stack = {
"nested_subroutines": {"dummy": 16},
"complex_arrays": {
"dummy": 4,
"two_d": [[1, 2], [3, 4], [5, 6]],
"my_arr": [complex(1, 0), complex(0, 1), complex(0.8, 0.6)],
"second": [1, 2, 3, 4],
},
}
def files() -> list[str]:
base_path = Path(__file__).parent.parent.parent / "qasm/visualize_pulse"
plen = len(base_path.parts)
FILES = list(base_path.glob("**/*.qasm"))
return [str(Path(*path.parts[plen:])) for path in FILES]
QASM_FILES = files()
def common_files() -> list[str]:
files = []
cut = -5
for q_file in QASM_FILES:
files.append(q_file[:cut])
return files
COMMON_FILES = common_files()
@pytest.fixture(name="basic_setup")
def fixture_basic_setup() -> SetupInternal:
json_path = Path(__file__).parent.parent.parent / "setups/interpreter.json"
return SetupInternal.from_json(json_path)
def test_visit_ClassicalDeclaration():
setup_path = Path(__file__).parent.parent.parent / "setups/complex.json"
qasm_path = Path(__file__).parent.parent.parent / "qasm/interpreter/phase_freq.qasm"
compiler = Compiler(qasm_path, setup_path)
qasm_ast = compiler.load_program(qasm_path)
ResolveIODeclaration().visit(qasm_ast)
SemanticAnalyzer().visit(qasm_ast)
DurationTransformer().visit(qasm_ast)
pv = PulseVisualizer(
SetupInternal.from_json(setup_path), waveform_functions.__dict__
) | activation_record = ActivationRecord( | 1 | 2023-11-16 17:37:29+00:00 | 24k |
quantuminterface/qiclib | src/qiclib/code/qi_jobs.py | [
{
"identifier": "TaskRunner",
"path": "src/qiclib/hardware/taskrunner.py",
"snippet": "class TaskRunner(PlatformComponent):\n \"\"\"Driver to control the Taskrunner on the Hardware Platform.\"\"\"\n\n def __init__(\n self,\n name: str,\n connection,\n controller,\n ... | import os
import json
import functools
import warnings
import numpy as np
import qiclib.packages.utility as util
from abc import abstractmethod
from typing import Dict, List, Callable, Optional, Union, Set, Any, Type
from ..hardware.taskrunner import TaskRunner
from ..experiment.qicode.data_provider import DataProvider
from ..experiment.qicode.data_handler import DataHandler
from .qi_seq_instructions import SequencerInstruction
from .qi_var_definitions import (
_QiVariableBase,
_QiCalcBase,
_QiConstValue,
QiCellProperty,
QiExpression,
QiVariableSet,
QiCondition,
)
from .qi_pulse import QiPulse
from .qi_visitor import (
QiCMContainedCellVisitor,
QiResultCollector,
QiVarInForRange,
)
from .qi_prog_builder import QiProgramBuilder
from .qi_types import (
QiType,
QiPostTypecheckVisitor,
QiTypeFallbackVisitor,
_TypeDefiningUse,
)
from .qi_types import _TypeDefiningUse
from .qi_types import _TypeDefiningUse
from .qi_types import (
_TypeConstraintReasonQiCommand,
_IllegalTypeReason,
_add_equal_constraints,
)
from .qi_types import (
_TypeConstraintReasonQiCommand,
_IllegalTypeReason,
_add_equal_constraints,
)
from .analysis.qi_insert_mem_parameters import (
insert_recording_offset_store_commands,
insert_manipulation_pulse_frequency_store_commands,
insert_readout_pulse_frequency_store_commands,
)
from .qi_simulate import Simulator
from ..experiment.qicode.base import QiCodeExperiment
from qiclib.experiment.qicode.base import _TaskrunnerSettings
from .qi_visitor import QiStringifyJob | 17,259 | if cell_map is None:
cell_map = list(range(len(self.cells)))
str_map = ", ".join([f"q[{i}] -> sample[{m}]" for i, m in enumerate(cell_map)])
exp._job_representation = f"{self}\n\nmapped as {str_map} to\n\n{sample}"
return exp
def _prepare_experiment_params(
self,
controller,
sample: Optional[QiSample] = None,
averages: int = 1,
cell_map: Optional[List[int]] = None,
data_collection=None,
use_taskrunner=False,
):
if len(self.cells) > len(controller.cell):
raise IndexError(
f"This job requires {len(self.cells)} cells but only "
f"{len(controller.cell)} are available in the QiController."
)
if data_collection is None:
if self._custom_processing is None:
data_collection = "average"
else:
data_collection = "custom"
# If float, convert averages to int
averages = int(averages)
if sample is None:
sample = QiSample(len(controller.cell))
elif len(sample) < len(self.cells):
raise ValueError(
"Need to submit a QiSample with at least as many cells as the job "
f"has ({len(self.cells)}), but only {len(sample)} provided."
)
if cell_map is None:
# Use the first cells of the sample
cell_map = list(range(len(self.cells)))
else:
if len(cell_map) != len(self.cells):
raise ValueError(
"cell_map needs to have as many entries as the job has cells, but "
f"{len(cell_map)} entries given and {len(self.cells)} required!"
)
if len(set(cell_map)) != len(cell_map):
raise ValueError("Duplicate values not allowed in cell_map!")
if any(m < 0 or m >= len(sample) for m in cell_map):
raise IndexError(
"cell_map values can only point to valid indices within the passed"
f" QiSample object, i.e. values between 0 and {len(sample) - 1}."
)
# Translate cell_map from sample cells ("cells") to QiController cells
cell_map = [sample.cell_map[c] for c in cell_map]
if any(c < 0 or c >= len(controller.cell) for c in cell_map):
raise ValueError(
"The QiSample cell_map can only reference available QiController "
f"cells, i.e. between 0 and {len(controller.cell) - 1}."
)
self._build_program(sample, cell_map)
for_range_list = []
for cell in self.cells:
for_range_list.append(self.cell_seq_dict[cell]._for_range_list)
return (
controller,
self.cells,
self._get_sequencer_codes(),
averages,
for_range_list,
cell_map,
self._var_reg_map,
data_collection,
use_taskrunner,
)
def run(
self,
controller,
sample: Optional[QiSample] = None,
averages: int = 1,
cell_map: Optional[List[int]] = None,
data_collection=None,
use_taskrunner=False,
):
"""executes the job and returns the results
:param controller: the QiController on which the job should be executed
:param sample: the QiSample object used for execution of pulses and extracts parameters for the experiment
:param averages: the number of executions that should be averaged, by default 1
:param cell_map: A list containing the indices of the cells
:param data_collection: the data_collection mode for the result, by default "average"
:param use_taskrunner: if the execution should be handled by the Taskrunner
Some advanced schemes and data_collection modes are currently only supported
by the Taskrunner and not yet by a native control flow.
"""
exp = self.create_experiment(
controller, sample, averages, cell_map, data_collection, use_taskrunner
)
exp.run()
def run_with_data_callback(self, on_new_data: Callable[[dict], None]):
pass
def run_streamed(self):
pass
def set_custom_data_processing(
self,
file: str,
params: Optional[List] = None,
converter: Optional[Callable[[List], List]] = None,
| # Copyright © 2017-2023 Quantum Interface (quantuminterface@ipe.kit.edu)
# Richard Gebauer, IPE, Karlsruhe Institute of Technology
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
"""
This is the main module of QiCode.
Here, all important commands write QiPrograms are defined.
"""
class QiResult:
"""Result of an experiment. Can be accessed via :python:`job.cells[cell_index].data("result name")`.
Where :python:`cells` denotes a :class:`QiCells` object and :python:`cell_index` an integer.
The actual data can be retrieved as a numpy array using the :meth:`get` Method
Example
-------
.. code-block:: python
qic: QiController = ...
sample: QiSample = ...
with QiJob() as job:
q = QiCells(1)
Readout(q[0], save_to="result")
job.run(qic, sample, averages=1000)
data = job.cells[0].data("result")
:param name: The name of the variable, by default None
"""
def __init__(self, name: Optional[str] = None) -> None:
self._cell = None
self.data = None
self.recording_count = 0
self.name: str = "" if name is None else name
def get(self) -> np.ndarray:
"""gets the data of the result as a numpy array
:return: The data of the experiment
"""
return np.array(self.data)
def __str__(self) -> str:
return f'QiResult("{self.name}")'
class QiCommand:
"""Base class of every Job command.
Provides _relevant_cells, containing every cell used for the execution of the command.
Provides _associated_variable_set, containing every variable needed for the execution of the command.
"""
def __init__(self) -> None:
self._associated_variable_set = QiVariableSet()
self._relevant_cells: Set[QiCell] = set()
@abstractmethod
def accept(self, visitor, *input):
raise RuntimeError(
f"{self.__class__} doesn't implement `accept`. This is a bug."
)
def is_variable_relevant(self, variable: _QiVariableBase) -> bool:
return variable in self._associated_variable_set
def add_associated_variable(self, x):
if isinstance(x, _QiVariableBase):
self._associated_variable_set.add(x)
def __str__(self) -> str:
return "cQiCommand"
def _stringify(self) -> str:
raise NotImplementedError(f"_stringify not implemented for {repr(self)}")
_QiJobReference = None
def _add_cmd_to_job(cmd: QiCommand):
if _QiJobReference is None:
raise RuntimeError("Can not use command outside QiJob context manager.")
_QiJobReference._add_command(cmd)
def _set_job_reference(job):
"""Used for testing purposes"""
# pylint: disable=global-statement
global _QiJobReference
_QiJobReference = job
def _delete_job_reference():
"""Used for testing purposes"""
# pylint: disable=global-statement
global _QiJobReference
_QiJobReference = None
class QiCell:
"""A QiCell is an abstract representation of the qubit/cell the program is run on.
Usually, a single :python:`QiCell` is not instantiated, but instead a :class:`QiCells` object.
For a single :python:`QiCell`, use instead :python:`QiCells(1)`
A :python:`QiCell` must be instantiated inside within a :class:`QiJob` context.
The :python:`QiCell` object can be used to get properties that are defined on :class:`QiSamples <QiSample>`.
For this, index the :python:`QiCell` object using the name of the property:
.. code-block:: python
q: QiCell = ...
t1_time = q["t1"]
The actual value for the accessed property (in the example above, the T1 time) is filled in when executing a
:class:`QiJob` and providing the actual sample.
**Tasks of the QiCell**:
- Saves the pulses needed for program execution.
- Provides a dictionary functionality to define commonly used durations/properties.
- Implements a Sequencer object, which contains the assembler program after compilation.
:param cellID: A unique ID
:raises RuntimeError: When the :python:`QiCell` is instantiated outside a `QiJob`
"""
def __init__(self, cellID: int):
if not isinstance(_QiJobReference, QiJob):
raise RuntimeError("QiCell can't be used outside of QiJob.")
self.cellID = cellID
self.manipulation_pulses: List[QiPulse] = []
self.flux_pulses: List[QiPulse] = []
self.readout_pulses: List[QiPulse] = []
self._result_container: Dict[str, QiResult] = {}
# The order in which recorded values are assigned to which result container
self._result_recording_order: List[QiResult] = []
self._unresolved_property: Set[QiCellProperty] = set()
self._job_ref = _QiJobReference
self._relevant_vars: Set[_QiVariableBase] = set()
# These attributes are determined by dataflow analyses
self._initial_manip_freq: float = None
self._initial_readout_freq: float = None
self._initial_rec_offset: float = None
self._rec_length: Union[int, float, QiCellProperty] = None
self._properties: Dict[QiCellProperty, Any] = {}
def __getitem__(self, key):
if _QiJobReference != self._job_ref:
raise RuntimeError(
"Tried getting values for cells registered to other QiJob"
)
prop = self._properties.get(key, QiCellProperty(self, key))
if isinstance(prop, QiCellProperty):
self._unresolved_property.add(key)
return prop
def __setitem__(self, key, value):
if _QiJobReference != self._job_ref:
raise RuntimeError(
"Tried setting values for cells registered to other QiJob"
)
self._properties[key] = value
def __call__(self, qic):
return qic.cell[self.qic_cell]
def get_properties(self):
return self._properties.copy()
def add_pulse(self, pulse: QiPulse):
if pulse not in self.manipulation_pulses:
self.manipulation_pulses.append(pulse)
if len(self.manipulation_pulses) > 13:
raise RuntimeError("Too many pulses in use")
return self.manipulation_pulses.index(pulse) + 1 # index 0 and 15 are reserved
@property
def initial_manipulation_frequency(self):
if self._initial_manip_freq is None:
if len(self.manipulation_pulses) > 0:
warnings.warn(
"Manipulation pulses without frequency given, using 90 MHz."
)
return 90e6 # Default frequency
freq = self._initial_manip_freq
return freq() if isinstance(freq, QiCellProperty) else freq
def add_recording_length(self, length):
if self._rec_length is None:
self._rec_length = length
elif (
not self._rec_length._equal_syntax(length)
if isinstance(self._rec_length, QiExpression)
else self._rec_length != length
):
raise RuntimeError(
f"Cell {self.cellID}: Multiple definitions of recording length used."
)
def add_readout_pulse(self, pulse: QiPulse):
if pulse not in self.readout_pulses:
self.readout_pulses.append(pulse)
if len(self.readout_pulses) > 13:
raise RuntimeError("Too many pulses in use")
return self.readout_pulses.index(pulse) + 1 # index 0 and 15 are reserved
@property
def initial_readout_frequency(self):
if self._initial_readout_freq is None:
if len(self.readout_pulses) > 0:
warnings.warn("Readout pulses without frequency given, using 30 MHz.")
return 30e6 # Default frequency
freq = self._initial_readout_freq
return freq() if isinstance(freq, QiCellProperty) else freq
@property
def recording_length(self):
"""the length of the recording pulse"""
if self._rec_length is not None:
return (
self._rec_length()
if isinstance(self._rec_length, QiCellProperty)
else self._rec_length
)
return 0
@property
def initial_recording_offset(self):
"""the recording offset in seconds"""
if self._initial_rec_offset is not None:
return (
self._initial_rec_offset()
if isinstance(self._initial_rec_offset, QiCellProperty)
else self._initial_rec_offset
)
return 0
def get_result_container(self, result: str) -> QiResult:
if result in self._result_container:
return self._result_container[result] # was already added
else:
box = QiResult(result)
box._cell = self
self._result_container[result] = box
return box
def add_variable(self, var: _QiVariableBase):
self._relevant_vars.add(var)
def get_number_of_recordings(self):
return len(self._result_recording_order)
def set_default_readout(self, pulse):
pass
def reset(self):
for container in self._result_container.values():
container.data = []
def data(
self, name: Optional[str] = None
) -> Union[Dict[str, np.ndarray], np.ndarray]:
"""
Returns the data after running an experiment.
When calling this function without a name, i.e., calling :python:`cell.data()`,
returns a dictionary containing the results as numpy arrays.
When calling this function with a name, i.e., calling :python:`cell.data("result_name")`,
returns the whole dictionary.
:param name: The name of the data
:return: A single result, or a dictionary of result names mapped to results.
"""
if name is None:
result_dict = {}
for key, container in self._result_container.items():
result_dict.update({key: container.get()})
return result_dict
else:
return self._result_container[name].get()
def _resolve_properties(self, len_dict: Dict[QiCellProperty, Any]):
keys = list(self._unresolved_property)
missing_keys = self._unresolved_property.difference(len_dict.keys())
if missing_keys:
raise RuntimeError(
f"Cell {self.cellID}: Not all properties for job could be resolved. "
f"Missing properties: {missing_keys}"
)
for key in keys:
self._properties[key] = len_dict[key]
@property
def has_unresolved_properties(self):
return len(self._unresolved_property) > 0
def _get_unresolved_properties(self):
return [
key
for key in list(self._unresolved_property)
if self._properties.get(key) is None
]
def __str__(self) -> str:
return f"QiCell({self.cellID})"
class QiCells:
"""
QiCells encapsulates multiple :class`QiCell` objects.
It is a list-like object where the individual cells can be accessed using the
index operator, i.e.
.. code-block:: python
cells = QiCells(5)
cell0: QiCell = cells[0]
cell3: QiCell = cells[3]
:param num: The number of cells to create
:raises RuntimeError: When the :python:`QiCells` object is instantiated outside a :python:`QiJob`
"""
def __init__(self, num: int) -> None:
if not isinstance(_QiJobReference, QiJob):
raise RuntimeError(
"QiCells can only be used within QiJob description. "
+ "If you try to create a sample object, use the new QiSample instead."
)
self.cells = [QiCell(x) for x in range(num)]
_QiJobReference._register_cells(self.cells)
def __getitem__(self, key):
return self.cells[key]
def __len__(self):
return len(self.cells)
class QiSampleCell:
"""QiSampleCell is the representation of a single qubit/cell and its properties.
All necessary parameters to perform experiments can be stored here. For this
purpose, the QiSampleCell can be utilized as a dictionary with user-defined keys.
"""
def __init__(self, cellID: int, cells_ref: "QiSample"):
self.cellID = cellID
self._cells_ref = cells_ref
self._relevant_vars: Set[_QiVariableBase] = set()
self._properties: Dict[str, Any] = {}
def __getitem__(self, key):
return self._properties[key]
def __setitem__(self, key, value):
self._properties[key] = value
def __call__(self, qic):
return qic.cell[self.qic_cell]
@property
def qic_cell(self):
return self._cells_ref.cell_map[self.cellID]
def get_properties(self):
return self._properties.copy()
def __str__(self) -> str:
return f"QiSampleCell({self.cellID})"
def _export(self):
return {"properties": self.get_properties()}
def _import(self, prop_dict, index):
if prop_dict is None:
warnings.warn(
f"Imported JSON string does not contain 'properties' for cell[{index}]."
)
return
self._properties.update(prop_dict)
class QiSample:
"""Representation of an experiment sample and its properties.
Property keys can be arbitrary strings, and property values can be anything.
Set the keys using :python:`sample["property_key"] = property_value` and get the values
the same way, i.e., :python:`property_value = sample["property_key"]`.
Note that this class **cannot** be instantiated within a :class:`QiJob`.
Instead, it must be defined outside one.
Accessing samples defined here within a QiJob is still possible, however, using the :class:`QiCell` object:
.. code-block:: python
sample: QiSample = ...
qic: QiController = ...
sample["t1"] = 100e-6
with QiJob() as job:
q = QiCells(1)
Wait(q[0], q[0]["t1"])
job.run(qic, sample) # Note that we pass the sample object here to make the value available in the job
The :python:`QiSample` object is serializable to `JSON <https://www.json.org/>`_.
Have a look at the :meth:`save` and :meth:`load` methods for more
:param num: The number of cells/qubits this sample has.
:param cell_map: On which QiController cells these are mapped, by default [0, 1, ..., num-1]
:raises RuntimeError: When the Sample is used within a :class:`QiJob`
"""
def __init__(self, num: int, cell_map: Optional[List[int]] = None) -> None:
self._cell_map = None
if _QiJobReference is not None:
raise RuntimeError(
"QiSample can only be used outside of QiJob to define sample "
"properties. Inside a QiJob, use QiCells as placeholder for the "
"qubits/cells instead."
)
self.cells: List[QiSampleCell] = []
for x in range(num):
self.cells.append(QiSampleCell(cellID=x, cells_ref=self))
self.cell_map = cell_map or list(range(num))
def __getitem__(self, key):
return self.cells[key]
def __len__(self):
return len(self.cells)
def __str__(self):
return (
f"QiSample({len(self.cells)}, cell_map=[{','.join(map(str, self.cell_map))}]):\n"
+ "\n".join(
[
f"[{i}]: {json.dumps(props['properties'], indent=2)}"
for i, props in enumerate(self._export()["cells"])
]
)
)
def _arrange_for_controller(self) -> List[Optional[QiSampleCell]]:
inverse: List[Optional[QiSampleCell]] = [None] * (max(self.cell_map) + 1)
for cell, qi_cell_index in enumerate(self.cell_map):
inverse[qi_cell_index] = self[cell]
return inverse
@property
def cell_map(self):
return self._cell_map
@cell_map.setter
def cell_map(self, cell_map):
if len(cell_map) != len(self):
raise ValueError(
"cell_map needs to have as many entries as the there are cells, but "
f"{len(cell_map)} entries given and {len(self)} required!"
)
if len(set(cell_map)) != len(cell_map):
raise ValueError("Duplicate values not allowed in cell_map!")
if any(c < 0 for c in cell_map):
raise ValueError("Cell indices inside cell_map cannot be negative!")
self._cell_map = cell_map
def _export(self):
properties = [cell._export() for cell in self.cells]
return {"cells": properties, "cell_map": self.cell_map}
def _import(self, jsn_string):
jsn_loaded = json.loads(jsn_string)
self._evaluate_import(jsn_loaded.get("cells", None))
self.cell_map = jsn_loaded.get("cell_map", self.cell_map)
def save(self, file_path: Union[str, os.PathLike], overwrite: bool = False):
"""
Save the sample to a file denoted by the :python:`file_path` argument in JSON format.
:param file_path: Where to store the file
:param overwrite: When true, allow overwriting an existing file.
:raise FileExistsError: When overwrite is False and the file exists.
"""
mode = "w" if overwrite is True else "x"
with open(file_path, mode, encoding="utf-8") as file:
json.dump(self._export(), file)
def load(self, file_path: Union[str, os.PathLike]):
"""
Loads the file at :python:`file_path`
and assigns all properties of the loaded file to this :class:`QiSample` object.
:param file_path: Where to look for the file
"""
with open(file_path, "r", encoding="utf-8") as file:
self._import(file.read())
def _evaluate_import(self, sample):
if sample is None:
warnings.warn("Imported JSON string does not contain 'cells'.")
return
if len(sample) != len(self):
raise ValueError(
f"Imported JSON contains {len(sample)} sample cells but {len(self)} "
"expected."
)
for i in range(0, len(self)):
self.cells[i]._import(sample[i].get("properties", None), i)
class _JobDescription:
"""Saves experiment descriptions and handles storage of commands"""
def __init__(self):
self._commands: List[QiCommand] = []
self._ContextStack: List[List[QiCommand]] = []
def __getitem__(self, key):
return self._commands[key]
def __len__(self):
return len(self._commands)
def add_command(self, command):
"""Checks current command for used cells and raises error, if cells are not defined for current QiJob"""
if isinstance(command, QiCellCommand):
if _QiJobReference != command.cell._job_ref:
raise RuntimeError("Cell not defined for current job")
self._commands.append(command)
def open_new_context(self):
"""Saves current commands in a stack and clears command list"""
self._ContextStack.append(self._commands.copy())
self._commands = []
def close_context(self) -> List[QiCommand]:
"""returns the current command list, and loads the commands from top of stack"""
current_commands = self._commands.copy()
self._commands = self._ContextStack.pop()
return current_commands
def reset(self):
self._commands = []
self._ContextStack = []
class QiCellCommand(QiCommand):
"""
Cell commands are commands using only one cell, such as Play and Wait commands.
:param cell: The target cell
"""
def __init__(self, cell: QiCell):
super().__init__()
self.cell = cell
self._relevant_cells.add(cell)
def accept(self, visitor, *input):
return visitor.visit_cell_command(self, *input)
class QiVariableCommand(QiCommand):
"""Base class of variable commands cQiDeclare and cQiAssign"""
def __init__(self, var: _QiVariableBase):
super().__init__()
self.var = var
def accept(self, visitor, *input):
return visitor.visit_variable_command(self, *input)
class cQiWait(QiCellCommand):
"""Command generated by :meth:`Wait`"""
def __init__(self, cell, length: Union[QiExpression, QiCellProperty]):
super().__init__(cell)
self._length = length
if isinstance(length, _QiVariableBase):
self.add_associated_variable(length)
elif isinstance(length, _QiCalcBase):
for variable in length.contained_variables:
self.add_associated_variable(variable)
if isinstance(length, QiExpression):
length._type_info.set_type(QiType.TIME, _TypeDefiningUse.WAIT_COMMAND)
@property
def length(self):
return (
self._length() if isinstance(self._length, QiCellProperty) else self._length
)
def _stringify(self) -> str:
return f"Wait({self.cell}, {self._length})"
class _cQiPlay_base(QiCellCommand):
"""Base class of Play commands.
Saves pulses, trigger_index and adds pulse variables to associated variable set
"""
def __init__(self, cell, pulse: QiPulse):
super().__init__(cell)
self.pulse = pulse
# default False; Set True for certain commands when unrolling a loop with TimingVariable == 1 cycle
self._var_single_cycle_trigger = False
for variable in self.pulse.variables:
self.add_associated_variable(variable)
# length of command might differ from pulse length
self._length: Union[float, _QiVariableBase, QiCellProperty] = self.pulse.length
self.trigger_index = 0
@property
def length(self):
return (
self._length
if not isinstance(self._length, QiCellProperty)
else self._length()
)
@length.setter
def length(self, value):
self._length = value
class cQiPlay(_cQiPlay_base):
"""Command generated by Play()"""
def __init__(self, cell, pulse: QiPulse):
super().__init__(cell, pulse)
self.trigger_index = cell.add_pulse(pulse)
def _stringify(self) -> str:
return f"Play({self.cell}, {self.pulse._stringify()})"
class cQiPlayFlux(_cQiPlay_base):
pass
class cQiPlayReadout(_cQiPlay_base):
"""Command generated by :meth:`PlayReadout`"""
def __init__(self, cell, pulse) -> None:
super().__init__(cell, pulse)
self.recording: Union[None, cQiRecording] = None
self.trigger_index = cell.add_readout_pulse(pulse)
@property
def length(self):
length = (
self._length
if not isinstance(self._length, QiCellProperty)
else self._length()
)
# if Recording is defined and length is not defined by variable, compare both lengths
if isinstance(self.recording, cQiRecording) and not isinstance(
self._length, _QiVariableBase
):
return max(length, self.recording.length)
return length
@length.setter
def length(self, value):
self._length = value
if isinstance(self.recording, cQiRecording):
self.recording.length = value
@property
def uses_state(self):
return self.recording is not None and self.recording.uses_state
def _stringify(self) -> str:
return f"PlayReadout({self.cell}, {self.pulse._stringify()})"
class cQiRotateFrame(_cQiPlay_base):
"""Command generated by :meth:`RotateFrame`"""
def __init__(self, cell, angle: float):
# Negate phase because frame needs to be shifted in the opposite direction
# than pulses -> want to shift the state on bloch sphere but shift the frame
pulse = QiPulse(0, phase=-1 * angle)
pulse.shift_phase = True # Special property to make phase offset persistant
super().__init__(cell, pulse)
self.trigger_index = cell.add_pulse(pulse)
self.length = util.conv_cycles_to_time(1) # command needs exactly one cycle
self.angle = angle
def _stringify(self) -> str:
return f"RotateFrame({self.cell}, {self.angle})"
class cQiSync(QiCommand):
"""Command generated by :meth:`Sync`"""
def __init__(self, cells: List[QiCell]):
super().__init__()
self._relevant_cells.update(cells)
def accept(self, visitor, *input):
return visitor.visit_sync_command(self, *input)
def _stringify(self) -> str:
return (
"Sync("
+ ", ".join(
[
f"{cell}"
for cell in sorted(self._relevant_cells, key=lambda c: c.cellID)
]
)
+ ")"
)
class cQiRecording(QiCellCommand):
"""Command generated by Recording()"""
def __init__(
self,
cell: QiCell,
save_to: Union[str, _QiVariableBase, None],
state_to: Union[_QiVariableBase, None],
length: Union[int, float, QiCellProperty],
offset: Union[int, float, QiExpression],
toggleContinuous: Optional[bool] = None,
):
super().__init__(cell)
self.result_box = None
self.var = None
if (
isinstance(length, QiExpression)
and length.type == QiType.STATE
or isinstance(offset, QiExpression)
and offset.type == QiType.STATE
):
raise RuntimeError("State variable can only be used at save_to parameter.")
if isinstance(state_to, _QiVariableBase):
state_to._type_info.set_type(
QiType.STATE, _TypeDefiningUse.RECORDING_SAVE_TO
)
self.add_associated_variable(state_to)
self.var = state_to
self.save_to = save_to
assert not isinstance(
save_to, QiResult
) # support for QiResult as parameter was removed.
if isinstance(save_to, _QiVariableBase):
# TODO This should be deprecated and turned into new result variable
# to handle I/Q values instead if necessary -> consistency
if self.var is not None:
raise RuntimeError("Cannot pass variable to state_to and save_to.")
save_to._type_info.set_type(
QiType.STATE, _TypeDefiningUse.RECORDING_SAVE_TO
)
self.add_associated_variable(save_to)
self.var = save_to
elif isinstance(save_to, str):
self.result_box = cell.get_result_container(
save_to
) # container might have been added to cell before
self.save_to = save_to
cell.add_recording_length(length)
self._length = length
if isinstance(self._length, QiExpression):
self._length._type_info.set_type(
QiType.TIME, _TypeDefiningUse.RECORDING_OFFSET_EXPRESSION
)
self._offset: QiExpression = QiExpression._from(offset)
self._offset._type_info.set_type(
QiType.TIME, _TypeDefiningUse.RECORDING_OFFSET_EXPRESSION
)
for var in self._offset.contained_variables:
var._relevant_cells.add(cell)
self.toggleContinuous = toggleContinuous
self.follows_readout = False
try:
cmd = _QiJobReference.commands[-1]
if (
isinstance(cmd, cQiPlayReadout) and cmd.cell == self.cell
): # Warning if previous cmd is readout but different cell
self.follows_readout = True
cmd.recording = self
cmd._associated_variable_set.update(self._associated_variable_set)
except IndexError:
pass
@property
def uses_state(self):
return len(self._associated_variable_set) > 0
@property
def length(self):
return (
self._length() if isinstance(self._length, QiCellProperty) else self._length
)
@length.setter
def length(self, value):
self._length = value
@property
def offset(self):
return (
self._offset() if isinstance(self._offset, QiCellProperty) else self._offset
)
def _stringify_args(self) -> str:
"""Determines non-default args to explicitly stringify"""
arg_strings = [str(self.cell), str(self._length)]
if not (
isinstance(self._offset, _QiConstValue) and self._offset._given_value == 0
):
arg_strings.append(f"offset={self._offset}")
if self.result_box is not None:
arg_strings.append(f'save_to="{self.result_box.name}"')
if self.var is not None:
arg_strings.append(f"state_to={self.var}")
if self.toggleContinuous is not None:
arg_strings.append(f"toggleContinuous={self.toggleContinuous}")
return ", ".join(arg_strings)
def _stringify(self) -> str:
return f"Recording({self._stringify_args()})"
class cQiStore(QiCellCommand):
"""Command generated by :meth:`Store`"""
def __init__(self, cell, store_var: _QiVariableBase, save_to: QiResult):
super().__init__(cell)
self.store_var = store_var
self.save_to = save_to
self.add_associated_variable(store_var)
def _stringify(self) -> str:
return f"Store({self.cell}, {self.store_var}, {self.save_to})"
class cQiAssign(QiVariableCommand):
"""Command generated by :meth:`Assign`"""
def __init__(self, dst: _QiVariableBase, value: Union[QiExpression, int, float]):
if not isinstance(dst, _QiVariableBase):
raise TypeError("Target of Assign can only be a QiVariable.")
super().__init__(dst)
self._value = QiExpression._from(value)
dst._type_info.add_illegal_type(QiType.STATE, _IllegalTypeReason.ASSIGN)
_add_equal_constraints(
QiType.NORMAL, _TypeConstraintReasonQiCommand(cQiAssign), self._value, dst
)
_add_equal_constraints(
QiType.TIME, _TypeConstraintReasonQiCommand(cQiAssign), self._value, dst
)
for variable in self.value.contained_variables:
self.add_associated_variable(variable)
@property
def value(self):
return self._value
def accept(self, visitor, *input):
return visitor.visit_assign_command(self, *input)
def _stringify(self) -> str:
return f"Assign({self.var}, {self._value})"
class cQiDeclare(QiVariableCommand):
"""Command generated by initialization of new QiVariable"""
def __init__(self, dst: _QiVariableBase) -> None:
super().__init__(var=dst)
def accept(self, visitor, *input):
return visitor.visit_declare_command(self, *input)
def _stringify(self) -> str:
return f"v{self.var.str_id} = {self.var}"
class cQiASM(QiCommand):
def __init__(self, cells: QiCell, instr: SequencerInstruction, cycles: int):
super().__init__()
self._relevant_cells.add(cells)
self.asm_instruction = instr
self.cycles = cycles
def accept(self, visitor, *input):
return visitor.visit_asm_command(self, *input)
def _stringify(self) -> str:
return f"ASM({self.asm_instruction.get_riscv_instruction()})"
class cQiMemStore(QiCommand):
def __init__(self, cell: QiCell, addr: int, value):
super().__init__()
self._relevant_cells.add(cell)
self.addr = addr
self.value = value
def accept(self, visitor, *input):
return visitor.visit_mem_store_command(self, *input)
def _stringify(self):
cell_str = ", ".join(list(map(lambda x: f"{x}", self._relevant_cells)))
return f"cQiMemStore({cell_str}, {self.addr}, {self.value})"
class QiContextManager(QiCommand):
"""Base Class for If, Else, ForRange and Parallel.
Defines functions for storing commands."""
def __init__(self) -> None:
super().__init__()
self.body: List[QiCommand] = []
def __enter__(self):
_QiJobReference._open_new_context()
return self
def __exit__(self, exception_type, exception_value, traceback):
self.body = _QiJobReference._close_context()
_QiJobReference._add_command(self)
def accept(self, visitor, *input):
return visitor.visit_context_manager(self, *input)
class If(QiContextManager):
"""
Add conditional logic to the program.
If multiple cells are used inside the body, a synchronization between the cells takes place before the If.
:param condition: The condition to check
Example
-------
.. code-block:: python
with QiJob() as job:
q = QiCells(1)
x = QiIntVariable(1)
with If(x > 1):
... # won't be executed
The If statement is most commonly used to react to qubit states in real-time:
.. code-block:: python
from qiclib import jobs
with QiJob() as job:
q = QiCells(1)
state = QiStateVariable()
jobs.Readout(q[0], state_to=state)
with If(state = 0):
... # Apply some conditional logic based on the qubit state
"""
def __init__(self, condition: Optional[QiCondition] = None):
super().__init__()
self._else_body: List[QiCommand] = []
if condition is None:
raise RuntimeError("No QiCondition given")
self.condition = condition
for variable in condition.contained_variables:
self.add_associated_variable(variable)
def add_else_body(self, else_body):
self._else_body = else_body.copy()
def is_followed_by_else(self) -> bool:
return len(self._else_body) != 0
def accept(self, visitor, *input):
return visitor.visit_if(self, *input)
def _stringify(self) -> str:
return f"If({self.condition})"
class Else(QiContextManager):
"""
Adds Conditional logic if the preceding :class:`If` command evaluates to false.
:raises RuntimeError: When the preceeding command is not an :python:`If` command
Example
-------
.. code-block:: python
from qiclib import jobs
with QiJob() as job:
q = QiCells(1)
state = QiStateVariable()
jobs.Readout(q[0], state_to=state)
with If(state = 0):
... # Apply some conditional logic based on the qubit state
with Else():
... # State is 1
"""
def __enter__(self):
self.if_cmd = _QiJobReference.commands[-1]
if not isinstance(self.if_cmd, If):
raise RuntimeError("Else is not preceded by If")
_QiJobReference._open_new_context()
return self
def __exit__(self, exception_type, exception_value, traceback):
self.if_cmd.add_else_body(_QiJobReference._close_context())
class Parallel(QiContextManager):
"""Pulses defined in body are united in one trigger command."""
def __init__(self):
super().__init__()
self.entries: List[List[QiCommand]] = []
def __exit__(self, exception_type, exception_value, traceback):
temp = _QiJobReference._close_context()
self.body += temp # So visitors also find commands in Parallel blocks.
self.entries.append(temp)
containing_cells = QiCMContainedCellVisitor()
for command in temp:
if not isinstance(
command,
(
cQiPlay,
cQiPlayReadout,
cQiPlayFlux,
cQiRotateFrame,
cQiRecording,
cQiWait,
),
):
raise TypeError("Type not allowed inside Parallel()", command)
if (
isinstance(command, (cQiRecording, cQiPlayReadout))
and command.uses_state
):
raise RuntimeError("Can not save to state variable inside Parallel")
try:
if isinstance(command.length, _QiVariableBase):
self._associated_variable_set.add(command.length)
except KeyError:
pass # length was QiCellProperty
command.accept(containing_cells)
self._relevant_cells.update(containing_cells.contained_cells)
# If previous command is also parallel, combine by adding another parallel entry at previous command
try:
cmd = _QiJobReference.commands[-1]
if isinstance(cmd, Parallel) and len(cmd.entries) < 2:
cmd.entries.append(temp)
cmd._associated_variable_set.update(self._associated_variable_set)
else:
_QiJobReference._add_command(self)
except IndexError:
_QiJobReference._add_command(self)
class CmdTuple:
def __init__(self, cmd: QiCommand, start: int, end: int, choke: bool = False):
self.cmd = cmd
self.start = start
self.end = end
self.choke_cmd = choke
class TimeSlot:
def __init__(self, cmd_tuples: List[Any], start, end):
self.cmd_tuples: List[Parallel.CmdTuple] = cmd_tuples
self.start: int = start
self.end: int = end
self.duration: float = 0.0
def _clear_wait_commands(self, cmd_tuples: List[CmdTuple]):
"""Clears cQiWait commands from cmd_tuples, if any trigger command is also in cmd_tuples"""
contains_pulse = False
for cmd_tuple in cmd_tuples:
if isinstance(cmd_tuple.cmd, _cQiPlay_base):
contains_pulse = True
break
return [
cmd_tuple
for cmd_tuple in cmd_tuples
if isinstance(cmd_tuple.cmd, _cQiPlay_base) or contains_pulse is False
]
def _clear_choke_commands(self, cmd_tuples: List[CmdTuple]):
"""Clears choke commands, if at the same slot another Play or Readout command is present."""
contains_play = False
contains_readout = False
for cmd_tuple in cmd_tuples:
if isinstance(cmd_tuple.cmd, cQiPlay) and cmd_tuple.choke_cmd is False:
contains_play = True
elif (
isinstance(cmd_tuple.cmd, cQiPlayReadout)
and cmd_tuple.choke_cmd is False
):
contains_readout = True
if contains_play is False and contains_readout is False:
return cmd_tuples
cleared_tuples = []
for cmd_tuple in cmd_tuples:
# if play command is present skip choke command for play
if isinstance(cmd_tuple.cmd, cQiPlay):
if cmd_tuple.choke_cmd is True and contains_play:
continue
# if PlayReadout command is present skip choke command for PlayReadout
elif isinstance(cmd_tuple.cmd, cQiPlayReadout):
if cmd_tuple.choke_cmd is True and contains_readout:
continue
cleared_tuples.append(cmd_tuple)
return cleared_tuples
def _create_time_slots(self, annotated_bodies: List[List[CmdTuple]], max_end: int):
time_slot_list: List[Parallel.TimeSlot] = []
for start in range(0, max_end):
time_slot = self.TimeSlot([], start, start)
# find tuples with start time == start
for cmd_list in annotated_bodies:
for cmd_tuple in cmd_list:
if cmd_tuple.start == start:
time_slot.cmd_tuples.append(cmd_tuple)
time_slot.end = max(cmd_tuple.end, time_slot.end)
cmd_list.remove(cmd_tuple)
break # next cmd_list
# next start value, if nothing was found
if len(time_slot.cmd_tuples) == 0:
continue
time_slot.cmd_tuples = self._clear_wait_commands(time_slot.cmd_tuples)
time_slot.cmd_tuples = self._clear_choke_commands(time_slot.cmd_tuples)
# Add Wait command, if previous end value < start
try:
prev_time_slot = time_slot_list[-1]
if prev_time_slot.end < start:
length = util.conv_cycles_to_time(start - prev_time_slot.end)
new_wait = self.CmdTuple(
cQiWait(list(self._relevant_cells)[0], length),
start=prev_time_slot.end,
end=start,
)
time_slot_list.append(
self.TimeSlot([new_wait], prev_time_slot.end, start)
)
except IndexError:
pass
# Adjust previous end time, if previous.end > start
try:
prev_time_slot = time_slot_list[-1]
prev_time_slot.end = min(prev_time_slot.end, start)
except IndexError:
pass
time_slot_list.append(time_slot)
# Add final wait, if previous.end != max_end
try:
prev_time_slot = time_slot_list[-1]
if prev_time_slot.end < max_end:
length = util.conv_cycles_to_time(max_end - prev_time_slot.end)
new_wait = self.CmdTuple(
cQiWait(list(self._relevant_cells)[0], length),
start=prev_time_slot.end,
end=max_end,
)
time_slot_list.append(
self.TimeSlot([new_wait], prev_time_slot.end, max_end)
)
except IndexError:
pass
# calculate duration of time slot
for slot in time_slot_list:
slot.duration = util.conv_cycles_to_time(slot.end - slot.start)
return time_slot_list
def _generate_command_body(self, cell, sequencer):
"""Combines the parallel sequences to one command body."""
parallel_bodies: List[List[Parallel.CmdTuple]] = []
max_end = 0
# Generate annotated list of commands with start and end cycle
for cmd_list in self.entries:
commands: List[Parallel.CmdTuple] = []
start: int = 0
end: int = 0
for cmd in cmd_list:
var_pulse = False
if cell not in cmd._relevant_cells:
continue # skip commands for other cells
if isinstance(cmd.length, _QiVariableBase):
reg = sequencer.get_var_register(cmd.length)
if reg.valid is False or reg.value is None:
raise RuntimeError(
"Variable inside parallel not initialised or invalidated"
)
length = reg.value
if isinstance(cmd, (cQiPlay, cQiPlayReadout)):
var_pulse = True
else:
length = util.conv_time_to_cycles(cmd.length, "ceil")
if length == 0:
continue # skip commands with length 0
if isinstance(cmd, cQiRecording) or (
isinstance(cmd, cQiPlayReadout)
and isinstance(cmd.recording, cQiRecording)
):
end += length + util.conv_time_to_cycles(
sequencer.recording_delay, "ceil"
)
else:
end += length
cmd_duration = self.CmdTuple(cmd, start, end)
commands.append(cmd_duration)
if var_pulse:
# Add parallel choke command after current command, if variable length is used
parallel_choke = [self.CmdTuple(cmd, end, end + 1, choke=True)]
parallel_bodies.append(parallel_choke)
max_end = max(end + 1, max_end) # +1 to account for choke command
else:
max_end = max(end, max_end)
start = end
parallel_bodies.append(commands)
return self._create_time_slots(parallel_bodies, max_end)
def accept(self, visitor, *input):
return visitor.visit_parallel(self, *input)
def _stringify(self) -> str:
return "Parallel"
class ForRange(QiContextManager):
"""Adds ForRange to program.
If multiple cells are used inside body, a synchronisation between the cells is done before the ForRange as well as after the end of the body.
If QiTimeVariable is used as var, loops starting at 0 are unrolled, to skip pulses/waits inside body using var as length.
Raises exception if start, end and step are not set up properly."""
def __init__(
self,
var: _QiVariableBase,
start: Union[_QiVariableBase, int, float],
end: Union[_QiVariableBase, int, float],
step: Union[int, float] = 1,
):
super().__init__()
if not isinstance(var, _QiVariableBase):
raise RuntimeError(
"Can only use QiVariables as control variable in ForRanges."
)
start_expr = QiExpression._from(start)
end_expr = QiExpression._from(end)
step_expr = QiExpression._from(step)
var._type_info.add_illegal_type(QiType.STATE, _IllegalTypeReason.FOR_RANGE)
start_expr._type_info.add_illegal_type(
QiType.STATE, _IllegalTypeReason.FOR_RANGE
)
end_expr._type_info.add_illegal_type(QiType.STATE, _IllegalTypeReason.FOR_RANGE)
step_expr._type_info.add_illegal_type(
QiType.STATE, _IllegalTypeReason.FOR_RANGE
)
_add_equal_constraints(
QiType.TIME,
_TypeConstraintReasonQiCommand(ForRange),
var,
start_expr,
end_expr,
step_expr,
)
_add_equal_constraints(
QiType.FREQUENCY,
_TypeConstraintReasonQiCommand(ForRange),
var,
start_expr,
end_expr,
step_expr,
)
_add_equal_constraints(
QiType.NORMAL,
_TypeConstraintReasonQiCommand(ForRange),
var,
start_expr,
end_expr,
step_expr,
)
if not isinstance(start, _QiVariableBase) and not isinstance(
end, _QiVariableBase
):
if (start > end and step >= 0) or (start < end and step <= 0):
raise ValueError("Definition of ForRange faulty")
self.var = var
self.start = start_expr
self.end = end_expr
self.step = step_expr
self.add_associated_variable(var)
if isinstance(start, _QiVariableBase):
self.add_associated_variable(start)
if start.id == var.id:
raise RuntimeError("Loop variable can not be used as start value")
if isinstance(end, _QiVariableBase):
self.add_associated_variable(end)
if end.id == var.id:
raise RuntimeError("Loop variable can not be used as end value")
def __exit__(self, exception_type, exception_value, traceback):
super().__exit__(exception_type, exception_value, traceback)
check_variable = QiVarInForRange(self.var)
self.accept(check_variable)
def accept(self, visitor, *input):
return visitor.visit_for_range(self, *input)
@property
def is_step_positive(self) -> bool:
return self.step > 0
def _stringify(self) -> str:
return f"ForRange({self.var}, {self.start}, {self.end}, {self.step})"
class QiVariable(_QiVariableBase):
"""Used as variables for use in program.
If no type is provided as an argument, it will infer its type.
"""
def __init__(
self,
type: Union[QiType, Type[int], Type[float]] = QiType.UNKNOWN,
value=None,
name=None,
) -> None:
if type == int:
type = QiType.NORMAL
elif type == float:
type = QiType.TIME
super().__init__(type, value, name=name)
_add_cmd_to_job(cQiDeclare(self))
if self.value is not None:
val = _QiConstValue(value)
val._type_info.set_type(type, _TypeDefiningUse.VARIABLE_DEFINITION)
_add_cmd_to_job(cQiAssign(self, val))
class QiJob:
"""
Container holding program, cells and qi_result containers for execution of program.
Builds the job with its properties
:param skip_nco_sync: if the NCO synchronization at the beginning should be skipped
:param nco_sync_length: how long to wait after the nco synchronization
"""
def __init__(
self,
skip_nco_sync=False,
nco_sync_length=0,
):
self.qi_results: List[QiResult] = []
self.cells = []
self.skip_nco_sync = skip_nco_sync
self.nco_sync_length = nco_sync_length
self._description = _JobDescription()
# Build
self._performed_analyses = False
self._build_done = False
self._arranged_cells: List[Optional[QiCell]] = []
self._var_reg_map: Dict[_QiVariableBase, Dict[QiCell, int]] = {}
# Run
self._custom_processing = None
self._custom_data_handler = None
def __enter__(self):
# pylint: disable=global-statement
global _QiJobReference
_QiJobReference = self
return self
def __exit__(self, exception_type, exception_value, traceback):
for cmd in self.commands:
cmd.accept(QiTypeFallbackVisitor())
for cmd in self.commands:
cmd.accept(QiPostTypecheckVisitor())
_QiVariableBase.reset_str_id()
# pylint: disable=global-statement
global _QiJobReference
_QiJobReference = None
def _open_new_context(self):
self._description.open_new_context()
def _close_context(self):
return self._description.close_context()
def _add_command(self, command):
self._description.add_command(command)
@property
def commands(self):
"""returns the commands of the job"""
return self._description._commands
def _register_cells(self, cells: List[QiCell]):
if len(self.cells) > 0:
raise RuntimeError("Can only register one set of cells at a QiJob.")
self.cells = cells
def _run_analyses(self):
"""
Executes needed (dataflow) analyses.
These mutate the commands in QiJob by inserting additional instructions, therefore
they should only run once, in order to avoid duplicate instructions.
"""
if not self._performed_analyses:
insert_recording_offset_store_commands(self)
insert_manipulation_pulse_frequency_store_commands(self)
insert_readout_pulse_frequency_store_commands(self)
self._performed_analyses = True
def _simulate_recordings(self) -> Dict[Any, List[cQiRecording]]:
"""
Simulates the order cQiRecording executions.
The result of this simulation is used to disentangle the recordings buffer
and reassociate the individual recording results with their corresponding Recording commands.
It might return more elements than are recorded during the real execution.
"""
# We first check if there are Recording commands at positions which we can not simulate.
# i.e. If-Else, ForRanges with start or end that are neither constant nor other loop variables.
# If this is the case we cannot simulate the order.
visitor = QiResultCollector()
for cmd in self.commands:
cmd.accept(visitor)
if len(visitor.found_qi_results) == 0:
return {cell: [] for cell in self.cells}
elif visitor.recording_in_if:
raise RuntimeError("Recording command within If-Else statement.")
# Next we simulate all loops and collect the respective Recording commands inside.
simulator = Simulator(self.cells)
simulator._simulate(self.commands)
return simulator.cell_recordings
def _build_program(
self, sample: Optional[QiSample] = None, cell_map: Optional[List[int]] = None
):
if sample is not None and cell_map is not None:
sample = sample._arrange_for_controller()
sample = [sample[m] if m < len(sample) else None for m in cell_map]
if cell_map is None:
cell_map = list(range(len(self.cells)))
# TODO Check that this works with None and right order now
self._resolve_properties(sample)
for cell in self.cells:
if len(cell._get_unresolved_properties()) > 0:
raise RuntimeError(
f"Unresolved properties {cell._get_unresolved_properties()} at cell {cell}"
)
self._run_analyses()
sim_result = self._simulate_recordings()
for cell in self.cells:
cell._result_recording_order = list(
map(
lambda x: x.result_box,
filter(lambda x: x.result_box is not None, sim_result[cell]),
)
)
prog_builder = QiProgramBuilder(
self.cells,
cell_map,
self._description._commands.copy(),
self.skip_nco_sync,
self.nco_sync_length,
)
self.cell_seq_dict = prog_builder.build_program()
self._var_reg_map = prog_builder.get_all_variables()
self._build_done = True
def _get_sequencer_codes(self):
return [
[
instr.get_riscv_instruction()
for instr in self.cell_seq_dict[cell].instruction_list
]
for cell in self.cells
]
def create_experiment(
self,
controller,
sample: Optional[QiSample] = None,
averages: int = 1,
cell_map: Optional[List[int]] = None,
data_collection=None,
use_taskrunner=False,
):
exp = QiCodeExperiment(
*self._prepare_experiment_params(
controller, sample, averages, cell_map, data_collection, use_taskrunner
)
)
if data_collection is None:
if self._custom_processing is not None:
exp._taskrunner.update(self._custom_processing)
if self._custom_data_handler is not None:
exp._data_handler_factory = DataHandler.get_custom_wrapper_factory(
self._custom_data_handler
)
# Provide a human-readable description of the execution
if cell_map is None:
cell_map = list(range(len(self.cells)))
str_map = ", ".join([f"q[{i}] -> sample[{m}]" for i, m in enumerate(cell_map)])
exp._job_representation = f"{self}\n\nmapped as {str_map} to\n\n{sample}"
return exp
def _prepare_experiment_params(
self,
controller,
sample: Optional[QiSample] = None,
averages: int = 1,
cell_map: Optional[List[int]] = None,
data_collection=None,
use_taskrunner=False,
):
if len(self.cells) > len(controller.cell):
raise IndexError(
f"This job requires {len(self.cells)} cells but only "
f"{len(controller.cell)} are available in the QiController."
)
if data_collection is None:
if self._custom_processing is None:
data_collection = "average"
else:
data_collection = "custom"
# If float, convert averages to int
averages = int(averages)
if sample is None:
sample = QiSample(len(controller.cell))
elif len(sample) < len(self.cells):
raise ValueError(
"Need to submit a QiSample with at least as many cells as the job "
f"has ({len(self.cells)}), but only {len(sample)} provided."
)
if cell_map is None:
# Use the first cells of the sample
cell_map = list(range(len(self.cells)))
else:
if len(cell_map) != len(self.cells):
raise ValueError(
"cell_map needs to have as many entries as the job has cells, but "
f"{len(cell_map)} entries given and {len(self.cells)} required!"
)
if len(set(cell_map)) != len(cell_map):
raise ValueError("Duplicate values not allowed in cell_map!")
if any(m < 0 or m >= len(sample) for m in cell_map):
raise IndexError(
"cell_map values can only point to valid indices within the passed"
f" QiSample object, i.e. values between 0 and {len(sample) - 1}."
)
# Translate cell_map from sample cells ("cells") to QiController cells
cell_map = [sample.cell_map[c] for c in cell_map]
if any(c < 0 or c >= len(controller.cell) for c in cell_map):
raise ValueError(
"The QiSample cell_map can only reference available QiController "
f"cells, i.e. between 0 and {len(controller.cell) - 1}."
)
self._build_program(sample, cell_map)
for_range_list = []
for cell in self.cells:
for_range_list.append(self.cell_seq_dict[cell]._for_range_list)
return (
controller,
self.cells,
self._get_sequencer_codes(),
averages,
for_range_list,
cell_map,
self._var_reg_map,
data_collection,
use_taskrunner,
)
def run(
self,
controller,
sample: Optional[QiSample] = None,
averages: int = 1,
cell_map: Optional[List[int]] = None,
data_collection=None,
use_taskrunner=False,
):
"""executes the job and returns the results
:param controller: the QiController on which the job should be executed
:param sample: the QiSample object used for execution of pulses and extracts parameters for the experiment
:param averages: the number of executions that should be averaged, by default 1
:param cell_map: A list containing the indices of the cells
:param data_collection: the data_collection mode for the result, by default "average"
:param use_taskrunner: if the execution should be handled by the Taskrunner
Some advanced schemes and data_collection modes are currently only supported
by the Taskrunner and not yet by a native control flow.
"""
exp = self.create_experiment(
controller, sample, averages, cell_map, data_collection, use_taskrunner
)
exp.run()
def run_with_data_callback(self, on_new_data: Callable[[dict], None]):
pass
def run_streamed(self):
pass
def set_custom_data_processing(
self,
file: str,
params: Optional[List] = None,
converter: Optional[Callable[[List], List]] = None, | mode: Union[TaskRunner.DataMode, str] = TaskRunner.DataMode.INT32, | 0 | 2023-11-10 10:26:10+00:00 | 24k |
fg320/DEASC | examples/12C_5x1_farm_dyn_tuning_wso_grouping_looping.py | [
{
"identifier": "WfModel",
"path": "deasc/wf_model.py",
"snippet": "class WfModel:\n \"\"\"\n Class for wind farm modelling (Interface setup but not limited to FLORIS\n framework).\n \"\"\"\n\n def __init__(self, input_file, path):\n \"\"\"\n Initialise wind farm object by p... | import numpy as np
from deasc import WfModel
from deasc import WSOpt
from deasc import Tuning
from deasc import GPWrap
from deasc import TuningDyn_Grouping
from deasc import TuningDyn_Looping_Turbine
from deasc.utils_floris import (
floris_extract_object_dict,
floris_extract_parameter,
floris_param_change_object_dict,
floris_param_change_object
) | 15,170 |
"""
This example shows wake steering optimisation on a 5x1 wind farm of NREL 5 MW turbines.
Dynamic parameter tuning with the looping approach is implemented to refine the results
achieved with grouping. Tuning is introduced in the optimisation for the wake expansion
parameter k of the Jensen wake model. The tuning variables are the yaw angles of all wind
turbines in the farm, excluding the most downstream one.
"""
# %% Initial wake steering optimisation - Grouping approach for dynamic parameter tuning
# Initialise and set layout for wind farm model
path = "./inputs/"
input_file = "jensen.yaml"
wf_model = WfModel(input_file, path)
wf_model.set_aligned_layout(5, 1, 7, 5)
# Set kd deflection parameter
wf_model_dict = floris_extract_object_dict(wf_model)
|
"""
This example shows wake steering optimisation on a 5x1 wind farm of NREL 5 MW turbines.
Dynamic parameter tuning with the looping approach is implemented to refine the results
achieved with grouping. Tuning is introduced in the optimisation for the wake expansion
parameter k of the Jensen wake model. The tuning variables are the yaw angles of all wind
turbines in the farm, excluding the most downstream one.
"""
# %% Initial wake steering optimisation - Grouping approach for dynamic parameter tuning
# Initialise and set layout for wind farm model
path = "./inputs/"
input_file = "jensen.yaml"
wf_model = WfModel(input_file, path)
wf_model.set_aligned_layout(5, 1, 7, 5)
# Set kd deflection parameter
wf_model_dict = floris_extract_object_dict(wf_model) | wf_model_dict = floris_param_change_object_dict(wf_model_dict, | 8 | 2023-11-10 18:13:27+00:00 | 24k |
PlaxtonFlarion/NexaFlow | nexaflow/skills/alynex.py | [
{
"identifier": "toolbox",
"path": "nexaflow/toolbox.py",
"snippet": "def video_capture(video_path: str):\ndef video_jump(video_cap: cv2.VideoCapture, frame_id: int):\ndef compare_ssim(pic1: np.ndarray, pic2: np.ndarray) -> float:\ndef multi_compare_ssim(\n pic1_list: typing.List, pic2_list: typing.L... | import os
import cv2
import time
import random
import asyncio
from loguru import logger
from typing import List, Union, Optional
from concurrent.futures import ThreadPoolExecutor
from nexaflow import toolbox
from nexaflow.skills.report import Report
from nexaflow.skills.record import Record
from nexaflow.skills.player import Player
from nexaflow.skills.switch import Switch
from nexaflow.cutter.cutter import VideoCutter
from nexaflow.video import VideoObject, Frame
from nexaflow.classifier.keras_classifier import KerasClassifier
from nexaflow.hook import BaseHook, CropHook, OmitHook, FrameSaveHook
from nexaflow.classifier.base import ClassifierResult, SingleClassifierResult | 16,763 |
class Alynex(object):
target_size: tuple = (350, 700)
fps: int = 60
step: int = 1
block: int = 6
threshold: Union[int | float] = 0.97
offset: int = 3
compress_rate: float = 0.5
window_size: int = 1
window_coefficient: int = 2
kc: KerasClassifier = KerasClassifier(
target_size=target_size, data_size=target_size
)
def __init__(self):
self.__report: Optional[Report] = None
self.__record: Optional[Record] = Record()
self.__player: Optional[Player] = Player()
self.__ffmpeg: Optional[Switch] = Switch()
self.__filmer: Optional[Alynex._Filmer] = Alynex._Filmer()
self.__framix: Optional[Alynex._Framix] = None
def __str__(self):
return (f"""
<Alynex for NexaFlow
Target Size: {self.target_size}
Fps: {self.fps}
Step: {self.step}
Block: {self.block}
Threshold: {self.threshold}
Offset: {self.offset}
Compress Rate: {self.compress_rate}
Window Size: {self.window_size}
Window Coefficient: {self.window_coefficient}
>
""")
__repr__ = __str__
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
@property
def report(self) -> "Report":
assert self.__report, f"{self.activate.__name__} first ..."
return self.__report
@property
def record(self) -> "Record":
return self.__record
@property
def player(self) -> "Player":
return self.__player
@property
def ffmpeg(self) -> "Switch":
return self.__ffmpeg
@property
def filmer(self) -> "Alynex._Filmer":
return self.__filmer
@property
def framix(self) -> "Alynex._Framix":
assert self.__framix, f"{self.activate.__name__} first ..."
return self.__framix
@staticmethod
def only_video(folder: str) -> List:
class Entry(object):
def __init__(self, title: str, place: str, sheet: list):
self.title = title
self.place = place
self.sheet = sheet
return [
Entry(
os.path.basename(root), root,
[os.path.join(root, f) for f in sorted(file)]
)
for root, _, file in os.walk(folder) if file
]
def activate(self, models: str, total_path: str):
if not self.__report:
self.__report = Report(total_path)
self.__framix = Alynex._Framix(self.report)
Alynex.kc.load_model(models)
class _Filmer(object):
@staticmethod
def train_model(video_file: str) -> None:
model_path = os.path.join(
os.path.dirname(video_file),
f"Model_{time.strftime('%Y%m%d%H%M%S')}_{os.getpid()}"
)
if not os.path.exists(model_path):
os.makedirs(model_path, exist_ok=True)
# 将视频切分成帧
|
class Alynex(object):
target_size: tuple = (350, 700)
fps: int = 60
step: int = 1
block: int = 6
threshold: Union[int | float] = 0.97
offset: int = 3
compress_rate: float = 0.5
window_size: int = 1
window_coefficient: int = 2
kc: KerasClassifier = KerasClassifier(
target_size=target_size, data_size=target_size
)
def __init__(self):
self.__report: Optional[Report] = None
self.__record: Optional[Record] = Record()
self.__player: Optional[Player] = Player()
self.__ffmpeg: Optional[Switch] = Switch()
self.__filmer: Optional[Alynex._Filmer] = Alynex._Filmer()
self.__framix: Optional[Alynex._Framix] = None
def __str__(self):
return (f"""
<Alynex for NexaFlow
Target Size: {self.target_size}
Fps: {self.fps}
Step: {self.step}
Block: {self.block}
Threshold: {self.threshold}
Offset: {self.offset}
Compress Rate: {self.compress_rate}
Window Size: {self.window_size}
Window Coefficient: {self.window_coefficient}
>
""")
__repr__ = __str__
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
pass
@property
def report(self) -> "Report":
assert self.__report, f"{self.activate.__name__} first ..."
return self.__report
@property
def record(self) -> "Record":
return self.__record
@property
def player(self) -> "Player":
return self.__player
@property
def ffmpeg(self) -> "Switch":
return self.__ffmpeg
@property
def filmer(self) -> "Alynex._Filmer":
return self.__filmer
@property
def framix(self) -> "Alynex._Framix":
assert self.__framix, f"{self.activate.__name__} first ..."
return self.__framix
@staticmethod
def only_video(folder: str) -> List:
class Entry(object):
def __init__(self, title: str, place: str, sheet: list):
self.title = title
self.place = place
self.sheet = sheet
return [
Entry(
os.path.basename(root), root,
[os.path.join(root, f) for f in sorted(file)]
)
for root, _, file in os.walk(folder) if file
]
def activate(self, models: str, total_path: str):
if not self.__report:
self.__report = Report(total_path)
self.__framix = Alynex._Framix(self.report)
Alynex.kc.load_model(models)
class _Filmer(object):
@staticmethod
def train_model(video_file: str) -> None:
model_path = os.path.join(
os.path.dirname(video_file),
f"Model_{time.strftime('%Y%m%d%H%M%S')}_{os.getpid()}"
)
if not os.path.exists(model_path):
os.makedirs(model_path, exist_ok=True)
# 将视频切分成帧 | video = VideoObject(video_file, fps=Alynex.fps) | 6 | 2023-11-13 05:27:34+00:00 | 24k |
microsoft/SoM | task_adapter/semantic_sam/tasks/inference_semsam_m2m_auto.py | [
{
"identifier": "Visualizer",
"path": "task_adapter/utils/visualizer.py",
"snippet": "class Visualizer:\n \"\"\"\n Visualizer that draws data about detection/segmentation on images.\n\n It contains methods like `draw_{text,box,circle,line,binary_mask,polygon}`\n that draw primitive objects t... | import torch
import numpy as np
import matplotlib.pyplot as plt
import cv2
import io
import cv2 # type: ignore
from torchvision import transforms
from task_adapter.utils.visualizer import Visualizer
from typing import Tuple
from PIL import Image
from detectron2.data import MetadataCatalog
from .automatic_mask_generator import SemanticSamAutomaticMaskGenerator
from task_adapter.utils.visualizer import Visualizer | 15,586 | # --------------------------------------------------------
# Semantic-SAM: Segment and Recognize Anything at Any Granularity
# Copyright (c) 2023 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by Hao Zhang (hzhangcx@connect.ust.hk)
# --------------------------------------------------------
metadata = MetadataCatalog.get('coco_2017_train_panoptic')
def inference_semsam_m2m_auto(model, image, level, all_classes, all_parts, thresh, text_size, hole_scale, island_scale, semantic, refimg=None, reftxt=None, audio_pth=None, video_pth=None, label_mode='1', alpha=0.1, anno_mode=['Mask']):
t = []
t.append(transforms.Resize(int(text_size), interpolation=Image.BICUBIC))
transform1 = transforms.Compose(t)
image_ori = transform1(image)
image_ori = np.asarray(image_ori)
images = torch.from_numpy(image_ori.copy()).permute(2,0,1).cuda()
mask_generator = SemanticSamAutomaticMaskGenerator(model,points_per_side=32,
pred_iou_thresh=0.88,
stability_score_thresh=0.92,
min_mask_region_area=10,
level=level,
)
outputs = mask_generator.generate(images)
| # --------------------------------------------------------
# Semantic-SAM: Segment and Recognize Anything at Any Granularity
# Copyright (c) 2023 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by Hao Zhang (hzhangcx@connect.ust.hk)
# --------------------------------------------------------
metadata = MetadataCatalog.get('coco_2017_train_panoptic')
def inference_semsam_m2m_auto(model, image, level, all_classes, all_parts, thresh, text_size, hole_scale, island_scale, semantic, refimg=None, reftxt=None, audio_pth=None, video_pth=None, label_mode='1', alpha=0.1, anno_mode=['Mask']):
t = []
t.append(transforms.Resize(int(text_size), interpolation=Image.BICUBIC))
transform1 = transforms.Compose(t)
image_ori = transform1(image)
image_ori = np.asarray(image_ori)
images = torch.from_numpy(image_ori.copy()).permute(2,0,1).cuda()
mask_generator = SemanticSamAutomaticMaskGenerator(model,points_per_side=32,
pred_iou_thresh=0.88,
stability_score_thresh=0.92,
min_mask_region_area=10,
level=level,
)
outputs = mask_generator.generate(images)
| visual = Visualizer(image_ori, metadata=metadata) | 0 | 2023-10-16 03:39:26+00:00 | 24k |
hkchengrex/Cutie | gui/main_controller.py | [
{
"identifier": "CUTIE",
"path": "cutie/model/cutie.py",
"snippet": "class CUTIE(nn.Module):\n def __init__(self, cfg: DictConfig, *, single_object=False):\n super().__init__()\n model_cfg = cfg.model\n self.ms_dims = model_cfg.pixel_encoder.ms_dims\n self.key_dim = model_... | import os
import logging
import cv2
import torch
import numpy as np
from os import path
from typing import Literal
from torch import mps
from torch import autocast
from torchvision.transforms.functional import to_tensor
from omegaconf import DictConfig, open_dict
from cutie.model.cutie import CUTIE
from cutie.inference.inference_core import InferenceCore
from gui.interaction import *
from gui.interactive_utils import *
from gui.resource_manager import ResourceManager
from gui.gui import GUI
from gui.click_controller import ClickController
from gui.reader import PropagationReader, get_data_loader
from gui.exporter import convert_frames_to_video, convert_mask_to_binary
from scripts.download_models import download_models_if_needed | 15,849 |
# fix conflicts between qt5 and cv2
os.environ.pop("QT_QPA_PLATFORM_PLUGIN_PATH")
try:
except:
print('torch.MPS not available.')
log = logging.getLogger()
class MainController():
def __init__(self, cfg: DictConfig) -> None:
super().__init__()
self.initialized = False
# setting up the workspace
if cfg["workspace"] is None:
if cfg["images"] is not None:
basename = path.basename(cfg["images"])
elif cfg["video"] is not None:
basename = path.basename(cfg["video"])[:-4]
else:
raise NotImplementedError('Either images, video, or workspace has to be specified')
cfg["workspace"] = path.join(cfg['workspace_root'], basename)
# reading arguments
self.cfg = cfg
self.num_objects = cfg['num_objects']
self.device = cfg['device']
self.amp = cfg['amp']
# initializing the network(s)
self.initialize_networks()
# main components
self.res_man = ResourceManager(cfg)
self.processor = InferenceCore(self.cutie, self.cfg)
self.gui = GUI(self, self.cfg)
# initialize control info
self.length: int = self.res_man.length
self.interaction: Interaction = None
self.interaction_type: str = 'Click'
self.curr_ti: int = 0
self.curr_object: int = 1
self.propagating: bool = False
self.propagate_direction: Literal['forward', 'backward', 'none'] = 'none'
self.last_ex = self.last_ey = 0
# current frame info
self.curr_frame_dirty: bool = False
self.curr_image_np: np.ndarray = np.zeros((self.h, self.w, 3), dtype=np.uint8)
self.curr_image_torch: torch.Tensor = None
self.curr_mask: np.ndarray = np.zeros((self.h, self.w), dtype=np.uint8)
self.curr_prob: torch.Tensor = torch.zeros((self.num_objects + 1, self.h, self.w),
dtype=torch.float).to(self.device)
self.curr_prob[0] = 1
# visualization info
self.vis_mode: str = 'davis'
self.vis_image: np.ndarray = None
self.save_visualization: bool = False
self.save_soft_mask: bool = False
self.interacted_prob: torch.Tensor = None
self.overlay_layer: np.ndarray = None
self.overlay_layer_torch: torch.Tensor = None
# the object id used for popup/layer overlay
self.vis_target_objects = list(range(1, self.num_objects + 1))
self.load_current_image_mask()
self.show_current_frame()
# initialize stuff
self.update_memory_gauges()
self.update_gpu_gauges()
self.gui.work_mem_min.setValue(self.processor.memory.min_mem_frames)
self.gui.work_mem_max.setValue(self.processor.memory.max_mem_frames)
self.gui.long_mem_max.setValue(self.processor.memory.max_long_tokens)
self.gui.mem_every_box.setValue(self.processor.mem_every)
# for exporting videos
self.output_fps = cfg['output_fps']
self.output_bitrate = cfg['output_bitrate']
# set callbacks
self.gui.on_mouse_motion_xy = self.on_mouse_motion_xy
self.gui.click_fn = self.click_fn
self.gui.show()
self.gui.text('Initialized.')
self.initialized = True
# try to load the default overlay
self._try_load_layer('./docs/uiuc.png')
self.gui.set_object_color(self.curr_object)
self.update_config()
def initialize_networks(self) -> None:
download_models_if_needed()
self.cutie = CUTIE(self.cfg).eval().to(self.device)
model_weights = torch.load(self.cfg.weights, map_location=self.device)
self.cutie.load_weights(model_weights)
|
# fix conflicts between qt5 and cv2
os.environ.pop("QT_QPA_PLATFORM_PLUGIN_PATH")
try:
except:
print('torch.MPS not available.')
log = logging.getLogger()
class MainController():
def __init__(self, cfg: DictConfig) -> None:
super().__init__()
self.initialized = False
# setting up the workspace
if cfg["workspace"] is None:
if cfg["images"] is not None:
basename = path.basename(cfg["images"])
elif cfg["video"] is not None:
basename = path.basename(cfg["video"])[:-4]
else:
raise NotImplementedError('Either images, video, or workspace has to be specified')
cfg["workspace"] = path.join(cfg['workspace_root'], basename)
# reading arguments
self.cfg = cfg
self.num_objects = cfg['num_objects']
self.device = cfg['device']
self.amp = cfg['amp']
# initializing the network(s)
self.initialize_networks()
# main components
self.res_man = ResourceManager(cfg)
self.processor = InferenceCore(self.cutie, self.cfg)
self.gui = GUI(self, self.cfg)
# initialize control info
self.length: int = self.res_man.length
self.interaction: Interaction = None
self.interaction_type: str = 'Click'
self.curr_ti: int = 0
self.curr_object: int = 1
self.propagating: bool = False
self.propagate_direction: Literal['forward', 'backward', 'none'] = 'none'
self.last_ex = self.last_ey = 0
# current frame info
self.curr_frame_dirty: bool = False
self.curr_image_np: np.ndarray = np.zeros((self.h, self.w, 3), dtype=np.uint8)
self.curr_image_torch: torch.Tensor = None
self.curr_mask: np.ndarray = np.zeros((self.h, self.w), dtype=np.uint8)
self.curr_prob: torch.Tensor = torch.zeros((self.num_objects + 1, self.h, self.w),
dtype=torch.float).to(self.device)
self.curr_prob[0] = 1
# visualization info
self.vis_mode: str = 'davis'
self.vis_image: np.ndarray = None
self.save_visualization: bool = False
self.save_soft_mask: bool = False
self.interacted_prob: torch.Tensor = None
self.overlay_layer: np.ndarray = None
self.overlay_layer_torch: torch.Tensor = None
# the object id used for popup/layer overlay
self.vis_target_objects = list(range(1, self.num_objects + 1))
self.load_current_image_mask()
self.show_current_frame()
# initialize stuff
self.update_memory_gauges()
self.update_gpu_gauges()
self.gui.work_mem_min.setValue(self.processor.memory.min_mem_frames)
self.gui.work_mem_max.setValue(self.processor.memory.max_mem_frames)
self.gui.long_mem_max.setValue(self.processor.memory.max_long_tokens)
self.gui.mem_every_box.setValue(self.processor.mem_every)
# for exporting videos
self.output_fps = cfg['output_fps']
self.output_bitrate = cfg['output_bitrate']
# set callbacks
self.gui.on_mouse_motion_xy = self.on_mouse_motion_xy
self.gui.click_fn = self.click_fn
self.gui.show()
self.gui.text('Initialized.')
self.initialized = True
# try to load the default overlay
self._try_load_layer('./docs/uiuc.png')
self.gui.set_object_color(self.curr_object)
self.update_config()
def initialize_networks(self) -> None:
download_models_if_needed()
self.cutie = CUTIE(self.cfg).eval().to(self.device)
model_weights = torch.load(self.cfg.weights, map_location=self.device)
self.cutie.load_weights(model_weights)
| self.click_ctrl = ClickController(self.cfg.ritm_weights, device=self.device) | 4 | 2023-10-19 17:49:24+00:00 | 24k |
ZhengyiLuo/PerpetualHumanoidControl | poselib/poselib/skeleton/tests/test_skeleton.py | [
{
"identifier": "SkeletonTree",
"path": "poselib/poselib/skeleton/skeleton3d.py",
"snippet": "class SkeletonTree(Serializable):\n \"\"\"\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\n over a list of nodes with their names indicated by strings... | from ...core import *
from ..skeleton3d import SkeletonTree, SkeletonState, SkeletonMotion
from ...visualization.common import (
plot_skeleton_state,
plot_skeleton_motion_interactive,
)
from ...visualization.plt_plotter import Matplotlib3DPlotter
from ...visualization.skeleton_plotter_tasks import (
Draw3DSkeletonMotion,
Draw3DSkeletonState,
)
import numpy as np
import torch | 18,285 | # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
def test_skel_tree():
skel_tree = SkeletonTree.from_mjcf(
"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml",
backend="pytorch",
)
skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend="pytorch")
# assert skel_tree.to_str() == skel_tree_rec.to_str()
print(skel_tree.node_names)
print(skel_tree.local_translation)
print(skel_tree.parent_indices)
skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
skel_state = skel_state.drop_nodes_by_names(["right_hip", "left_hip"])
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
def test_skel_motion():
skel_motion = SkeletonMotion.from_file(
"/tmp/tmp.npy", backend="pytorch", load_context=True
)
plot_skeleton_motion_interactive(skel_motion)
def test_grad():
source_motion = SkeletonMotion.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\motions\\JogFlatTerrain_01_ase.npy",
backend="pytorch",
device="cuda:0",
)
source_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\fox_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\flex_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_skeleton_tree = target_tpose.skeleton_tree
joint_mapping = {
"upArm_r": "right_shoulder",
"upArm_l": "left_shoulder",
"loArm_r": "right_elbow",
"loArm_l": "left_elbow",
"upLeg_r": "right_hip",
"upLeg_l": "left_hip",
"loLeg_r": "right_knee",
"loLeg_l": "left_knee",
"foot_r": "right_ankle",
"foot_l": "left_ankle",
"hips": "pelvis",
"neckA": "neck",
"spineA": "abdomen",
}
rotation_to_target_skeleton = quat_from_angle_axis(
angle=torch.tensor(90.0).float(),
axis=torch.tensor([1, 0, 0]).float(),
degree=True,
)
target_motion = source_motion.retarget_to(
joint_mapping=joint_mapping,
source_tpose_local_rotation=source_tpose.local_rotation,
source_tpose_root_translation=source_tpose.root_translation,
target_skeleton_tree=target_skeleton_tree,
target_tpose_local_rotation=target_tpose.local_rotation,
target_tpose_root_translation=target_tpose.root_translation,
rotation_to_target_skeleton=rotation_to_target_skeleton,
scale_to_target_skeleton=0.01,
)
target_state = SkeletonState(
target_motion.tensor[800, :],
target_motion.skeleton_tree,
target_motion.is_local,
)
skeleton_tree = target_state.skeleton_tree
root_translation = target_state.root_translation
global_translation = target_state.global_translation
q = np.zeros((len(skeleton_tree), 4), dtype=np.float32)
q[..., 3] = 1.0
q = torch.from_numpy(q)
max_its = 10000
task = Draw3DSkeletonState(task_name="", skeleton_state=target_state)
| # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
def test_skel_tree():
skel_tree = SkeletonTree.from_mjcf(
"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml",
backend="pytorch",
)
skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend="pytorch")
# assert skel_tree.to_str() == skel_tree_rec.to_str()
print(skel_tree.node_names)
print(skel_tree.local_translation)
print(skel_tree.parent_indices)
skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
skel_state = skel_state.drop_nodes_by_names(["right_hip", "left_hip"])
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
def test_skel_motion():
skel_motion = SkeletonMotion.from_file(
"/tmp/tmp.npy", backend="pytorch", load_context=True
)
plot_skeleton_motion_interactive(skel_motion)
def test_grad():
source_motion = SkeletonMotion.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\motions\\JogFlatTerrain_01_ase.npy",
backend="pytorch",
device="cuda:0",
)
source_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\fox_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\flex_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_skeleton_tree = target_tpose.skeleton_tree
joint_mapping = {
"upArm_r": "right_shoulder",
"upArm_l": "left_shoulder",
"loArm_r": "right_elbow",
"loArm_l": "left_elbow",
"upLeg_r": "right_hip",
"upLeg_l": "left_hip",
"loLeg_r": "right_knee",
"loLeg_l": "left_knee",
"foot_r": "right_ankle",
"foot_l": "left_ankle",
"hips": "pelvis",
"neckA": "neck",
"spineA": "abdomen",
}
rotation_to_target_skeleton = quat_from_angle_axis(
angle=torch.tensor(90.0).float(),
axis=torch.tensor([1, 0, 0]).float(),
degree=True,
)
target_motion = source_motion.retarget_to(
joint_mapping=joint_mapping,
source_tpose_local_rotation=source_tpose.local_rotation,
source_tpose_root_translation=source_tpose.root_translation,
target_skeleton_tree=target_skeleton_tree,
target_tpose_local_rotation=target_tpose.local_rotation,
target_tpose_root_translation=target_tpose.root_translation,
rotation_to_target_skeleton=rotation_to_target_skeleton,
scale_to_target_skeleton=0.01,
)
target_state = SkeletonState(
target_motion.tensor[800, :],
target_motion.skeleton_tree,
target_motion.is_local,
)
skeleton_tree = target_state.skeleton_tree
root_translation = target_state.root_translation
global_translation = target_state.global_translation
q = np.zeros((len(skeleton_tree), 4), dtype=np.float32)
q[..., 3] = 1.0
q = torch.from_numpy(q)
max_its = 10000
task = Draw3DSkeletonState(task_name="", skeleton_state=target_state) | plotter = Matplotlib3DPlotter(task) | 5 | 2023-10-15 19:05:47+00:00 | 24k |
e4s2023/E4S2023 | our_swap_face_video_pipeline2.py | [
{
"identifier": "Net3",
"path": "models/networks.py",
"snippet": "class Net3(nn.Module):\n \"\"\" FSEncoder + styleGAN2 \"\"\"\n\n def __init__(self,opts,):\n super(Net3, self).__init__()\n self.opts=opts\n assert self.opts.fsencoder_type in [\"psp\",\"sean\"]\n if self... | import copy
import cv2
import torch
import numpy as np
import torchvision.transforms as transforms
import os
import glob
import torch.nn as nn
from PIL import Image
from models.networks import Net3
from datasets.dataset import get_transforms, TO_TENSOR, NORMALIZE
from utils import torch_utils
from tqdm import tqdm
from torch.nn import functional as F
from training.video_swap_ft_coach import VideoSwapPTICoach
from tqdm import trange
from options.our_swap_face_pipeline_options import OurSwapFacePipelineOptions
from swap_face_fine.swap_face_mask import swap_head_mask_revisit, swap_head_mask_hole_first
from utils.morphology import dilation, erosion
from training.video_swap_ft_coach import dialate_mask, erode_mask
from swap_face_fine.multi_band_blending import blending
from utils.alignment import crop_faces, calc_alignment_coefficients # 这一句有 import的 bug，大概率 dlib的问题
from skimage.transform import resize # 这一句有点问题
from swap_face_fine.face_vid2vid.drive_demo import init_facevid2vid_pretrained_model, drive_source_demo # 这一行有点问题
from swap_face_fine.gpen.gpen_demo import init_gpen_pretrained_model, GPEN_demo
from swap_face_fine.face_parsing.face_parsing_demo import init_faceParsing_pretrained_model, faceParsing_demo, vis_parsing_maps | 14,816 | # from training.video_swap_st_constraint import VideoSwapPTICoach
# from training.video_swap_stich_coach import VideoSwapStichingCoach
def create_masks(mask, operation='dilation', radius=0):
temp = copy.deepcopy(mask)
if operation == 'dilation':
full_mask = dilation(temp, torch.ones(2 * radius + 1, 2 * radius + 1, device=mask.device), engine='convolution')
border_mask = full_mask - temp
elif operation == 'erosion':
| # from training.video_swap_st_constraint import VideoSwapPTICoach
# from training.video_swap_stich_coach import VideoSwapStichingCoach
def create_masks(mask, operation='dilation', radius=0):
temp = copy.deepcopy(mask)
if operation == 'dilation':
full_mask = dilation(temp, torch.ones(2 * radius + 1, 2 * radius + 1, device=mask.device), engine='convolution')
border_mask = full_mask - temp
elif operation == 'erosion': | full_mask = erosion(temp, torch.ones(2 * radius + 1, 2 * radius + 1, device=mask.device), engine='convolution') | 10 | 2023-10-15 12:15:01+00:00 | 24k |
sotopia-lab/sotopia | sotopia/server.py | [
{
"identifier": "Agents",
"path": "sotopia/agents/llm_agent.py",
"snippet": "class Agents(dict[str, BaseAgent[Observation, AgentAction]]):\n def reset(self) -> None:\n for agent in self.values():\n agent.reset()\n\n def act(self, obs: dict[str, Observation]) -> dict[str, AgentAct... | import asyncio
import functools
import itertools
import logging
import gin
import rich
from typing import Callable, Literal, Sequence, Type, cast
from beartype import beartype
from tqdm.asyncio import tqdm_asyncio
from sotopia.agents import (
Agents,
HumanAgent,
LLMAgent,
RedisAgent,
ScriptWritingAgent,
SpeakAgent,
)
from sotopia.agents.base_agent import BaseAgent
from sotopia.database import EpisodeLog
from sotopia.database.persistent_profile import (
AgentProfile,
EnvironmentProfile,
)
from sotopia.envs import ParallelSotopiaEnv
from sotopia.envs.evaluators import (
ReachGoalLLMEvaluator,
RuleBasedTerminatedEvaluator,
unweighted_aggregate_evaluate,
)
from sotopia.generation_utils.generate import LLM_Name, agenerate_script
from sotopia.messages import AgentAction, Message, Observation
from sotopia.messages.message_classes import (
ScriptBackground,
ScriptEnvironmentResponse,
ScriptInteraction,
)
from sotopia.samplers import (
BaseSampler,
ConstraintBasedSampler,
EnvAgentCombo,
UniformSampler,
) | 18,296 |
@beartype
def run_sync_server(
model_name_dict: dict[str, LLM_Name],
action_order: Literal["simutaneous", "round-robin", "random"],
agents_info: dict[str, dict[str, str]] | None = None,
partial_background_file: str | None = None,
full_background_file: str | None = None,
mode: str | None = None,
) -> list[tuple[str, str, Message]]:
# Create Environment and agents
# This step will be moved to outside this function
env = ParallelSotopiaEnv(
model_name=model_name_dict["env"],
action_order=action_order,
evaluators=[
RuleBasedTerminatedEvaluator(),
],
)
if partial_background_file:
environment_messages = env.reset(
options={"partial_background_file": partial_background_file}
)
elif full_background_file:
environment_messages = env.reset(
options={"full_background_file": full_background_file}
)
else:
environment_messages = env.reset()
agents = Agents()
agents_model_names = [model_name_dict["agent1"], model_name_dict["agent2"]]
for agent_name, agent_model in zip(env.agents, agents_model_names):
if agent_model == "human":
agents[agent_name] = HumanAgent(agent_name)
elif mode == "speak":
agents[agent_name] = SpeakAgent(agent_name, model_name=agent_model)
else:
|
@beartype
def run_sync_server(
model_name_dict: dict[str, LLM_Name],
action_order: Literal["simutaneous", "round-robin", "random"],
agents_info: dict[str, dict[str, str]] | None = None,
partial_background_file: str | None = None,
full_background_file: str | None = None,
mode: str | None = None,
) -> list[tuple[str, str, Message]]:
# Create Environment and agents
# This step will be moved to outside this function
env = ParallelSotopiaEnv(
model_name=model_name_dict["env"],
action_order=action_order,
evaluators=[
RuleBasedTerminatedEvaluator(),
],
)
if partial_background_file:
environment_messages = env.reset(
options={"partial_background_file": partial_background_file}
)
elif full_background_file:
environment_messages = env.reset(
options={"full_background_file": full_background_file}
)
else:
environment_messages = env.reset()
agents = Agents()
agents_model_names = [model_name_dict["agent1"], model_name_dict["agent2"]]
for agent_name, agent_model in zip(env.agents, agents_model_names):
if agent_model == "human":
agents[agent_name] = HumanAgent(agent_name)
elif mode == "speak":
agents[agent_name] = SpeakAgent(agent_name, model_name=agent_model)
else: | agents[agent_name] = LLMAgent(agent_name, model_name=agent_model) | 2 | 2023-10-23 19:47:26+00:00 | 24k |
f0uriest/interpax | tests/test_interpolate.py | [
{
"identifier": "fft_interp1d",
"path": "interpax/_fourier.py",
"snippet": "@partial(jit, static_argnames=\"n\")\ndef fft_interp1d(f: jax.Array, n: int, sx: jax.Array = None, dx: float = 1.0):\n \"\"\"Interpolation of a 1d periodic function via FFT.\n\n Parameters\n ----------\n f : ndarray,... | import jax
import jax.numpy as jnp
import numpy as np
import pytest
from jax import config as jax_config
from interpax import (
Interpolator1D,
Interpolator2D,
Interpolator3D,
fft_interp1d,
fft_interp2d,
interp1d,
interp2d,
interp3d,
) | 16,854 | y = np.linspace(0, 2 * np.pi, 200)
xxp, yyp = np.meshgrid(xp, yp, indexing="ij")
f = lambda x, y: np.array([np.sin(x) * np.cos(y), np.sin(x) + np.cos(y)])
fp = f(xxp.T, yyp.T).T
fq = interp2d(x, y, xp, yp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x, y).T, rtol=1e-2, atol=1.2e-1)
fq = interp2d(x, y, xp, yp, fp, method="linear")
np.testing.assert_allclose(fq, f(x, y).T, rtol=1e-3, atol=1e-2)
fq = interp2d(x, y, xp, yp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x, y).T, rtol=1e-5, atol=2e-3)
class TestInterp3D:
"""Tests for interp3d function."""
@pytest.mark.unit
@pytest.mark.parametrize(
"x, y, z",
[
(
np.linspace(0, np.pi, 1000),
np.linspace(0, 2 * np.pi, 1000),
np.linspace(0, 3, 1000),
),
(0.0, 0.0, 0.0),
],
)
def test_interp3d(self, x, y, z):
"""Test accuracy of different 3d interpolation methods."""
xp = np.linspace(0, np.pi, 20)
yp = np.linspace(0, 2 * np.pi, 30)
zp = np.linspace(0, 3, 25)
xxp, yyp, zzp = np.meshgrid(xp, yp, zp, indexing="ij")
f = lambda x, y, z: np.sin(x) * np.cos(y) * z**2
fp = f(xxp, yyp, zzp)
interp1 = lambda xq, yq, zq, *args, **kwargs: interp3d(
xq, yq, zq, *args, **kwargs
)
interp2 = lambda xq, yq, zq, *args, **kwargs: Interpolator3D(*args, **kwargs)(
xq, yq, zq
)
for interp in [interp1, interp2]:
fq = interp(x, y, z, xp, yp, zp, fp)
np.testing.assert_allclose(fq, f(x, y, z), rtol=1e-5, atol=1e-2)
fq = interp(x, y, z, xp, yp, zp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x, y, z), rtol=1e-2, atol=1)
fq = interp(x, y, z, xp, yp, zp, fp, method="linear")
np.testing.assert_allclose(fq, f(x, y, z), rtol=1e-3, atol=1e-1)
atol = 5.5e-3
rtol = 1e-5
fq = interp(x, y, z, xp, yp, zp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
fq = interp(x, y, z, xp, yp, zp, fp, method="cubic2")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
fq = interp(x, y, z, xp, yp, zp, fp, method="catmull-rom")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
fq = interp(x, y, z, xp, yp, zp, fp, method="cardinal")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
@pytest.mark.unit
def test_interp3d_vector_valued(self):
"""Test for interpolating vector valued function."""
x = np.linspace(0, np.pi, 1000)
y = np.linspace(0, 2 * np.pi, 1000)
z = np.linspace(0, 3, 1000)
xp = np.linspace(0, np.pi, 20)
yp = np.linspace(0, 2 * np.pi, 30)
zp = np.linspace(0, 3, 25)
xxp, yyp, zzp = np.meshgrid(xp, yp, zp, indexing="ij")
f = lambda x, y, z: np.array(
[np.sin(x) * np.cos(y) * z**2, 0.1 * (x + y - z)]
)
fp = f(xxp.T, yyp.T, zzp.T).T
fq = interp3d(x, y, z, xp, yp, zp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x, y, z).T, rtol=1e-2, atol=1)
fq = interp3d(x, y, z, xp, yp, zp, fp, method="linear")
np.testing.assert_allclose(fq, f(x, y, z).T, rtol=1e-3, atol=1e-1)
fq = interp3d(x, y, z, xp, yp, zp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x, y, z).T, rtol=1e-5, atol=5e-3)
@pytest.mark.unit
def test_fft_interp1d():
"""Test for 1d Fourier interpolation."""
def fun(x):
return 2 * np.sin(1 * x) + 4 * np.cos(3 * x) + 1
x = {"o": {}, "e": {}}
x["o"][1] = np.linspace(0, 2 * np.pi, 33, endpoint=False)
x["e"][1] = np.linspace(0, 2 * np.pi, 32, endpoint=False)
x["o"][2] = np.linspace(0, 2 * np.pi, 133, endpoint=False)
x["e"][2] = np.linspace(0, 2 * np.pi, 132, endpoint=False)
f1 = {}
for p in ["o", "e"]:
f1[p] = {}
for i in [1, 2]:
f1[p][i] = fun(x[p][i])
for sp in ["o", "e"]: # source parity
fi = f1[sp][1]
fs = fun(x[sp][1] + 0.2)
np.testing.assert_allclose(
| """Tests for interpolation functions."""
jax_config.update("jax_enable_x64", True)
class TestInterp1D:
"""Tests for interp1d function."""
@pytest.mark.unit
@pytest.mark.parametrize(
"x",
[
np.linspace(0, 2 * np.pi, 10000),
0.0,
],
)
def test_interp1d(self, x):
"""Test accuracy of different 1d interpolation methods."""
xp = np.linspace(0, 2 * np.pi, 100)
f = lambda x: np.sin(x)
fp = f(xp)
interp1 = lambda xq, *args, **kwargs: interp1d(xq, *args, **kwargs)
interp2 = lambda xq, *args, **kwargs: Interpolator1D(*args, **kwargs)(xq)
for interp in [interp1, interp2]:
fq = interp(x, xp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x), rtol=1e-2, atol=1e-1)
fq = interp(x, xp, fp, method="linear")
np.testing.assert_allclose(fq, f(x), rtol=1e-4, atol=1e-3)
fq = interp(x, xp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x), rtol=1e-6, atol=1e-5)
fq = interp(x, xp, fp, method="cubic2")
np.testing.assert_allclose(fq, f(x), rtol=1e-6, atol=1e-5)
fq = interp(x, xp, fp, method="cardinal")
np.testing.assert_allclose(fq, f(x), rtol=1e-6, atol=1e-5)
fq = interp(x, xp, fp, method="catmull-rom")
np.testing.assert_allclose(fq, f(x), rtol=1e-6, atol=1e-5)
fq = interp(x, xp, fp, method="monotonic")
np.testing.assert_allclose(fq, f(x), rtol=1e-4, atol=1e-3)
fq = interp(x, xp, fp, method="monotonic-0")
np.testing.assert_allclose(fq, f(x), rtol=1e-4, atol=1e-2)
@pytest.mark.unit
def test_interp1d_vector_valued(self):
"""Test for interpolating vector valued function."""
xp = np.linspace(0, 2 * np.pi, 100)
x = np.linspace(0, 2 * np.pi, 300)[10:-10]
f = lambda x: np.array([np.sin(x), np.cos(x)])
fp = f(xp).T
fq = interp1d(x, xp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-2, atol=1e-1)
fq = interp1d(x, xp, fp, method="linear")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-4, atol=1e-3)
fq = interp1d(x, xp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-6, atol=1e-5)
fq = interp1d(x, xp, fp, method="cubic2")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-6, atol=1e-5)
fq = interp1d(x, xp, fp, method="cardinal")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-6, atol=1e-5)
fq = interp1d(x, xp, fp, method="catmull-rom")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-6, atol=1e-5)
fq = interp1d(x, xp, fp, method="monotonic")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-4, atol=1e-3)
fq = interp1d(x, xp, fp, method="monotonic-0")
np.testing.assert_allclose(fq, f(x).T, rtol=1e-4, atol=1e-2)
@pytest.mark.unit
def test_interp1d_extrap_periodic(self):
"""Test extrapolation and periodic BC of 1d interpolation."""
xp = np.linspace(0, 2 * np.pi, 200)
x = np.linspace(-1, 2 * np.pi + 1, 10000)
f = lambda x: np.sin(x)
fp = f(xp)
fq = interp1d(x, xp, fp, method="cubic", extrap=False)
assert np.isnan(fq[0])
assert np.isnan(fq[-1])
fq = interp1d(x, xp, fp, method="cubic", extrap=True)
assert not np.isnan(fq[0])
assert not np.isnan(fq[-1])
fq = interp1d(x, xp, fp, method="cubic", period=2 * np.pi)
np.testing.assert_allclose(fq, f(x), rtol=1e-6, atol=1e-2)
@pytest.mark.unit
def test_interp1d_monotonic(self):
"""Ensure monotonic interpolation is actually monotonic."""
# true function is just linear with a jump discontinuity at x=1.5
x = np.linspace(-4, 5, 10)
f = np.heaviside(x - 1.5, 0) + 0.1 * x
xq = np.linspace(-4, 5, 1000)
dfc = interp1d(xq, x, f, derivative=1, method="cubic")
dfm = interp1d(xq, x, f, derivative=1, method="monotonic")
dfm0 = interp1d(xq, x, f, derivative=1, method="monotonic-0")
assert dfc.min() < 0 # cubic interpolation undershoots, giving negative slope
assert dfm.min() > 0 # monotonic interpolation doesn't
assert dfm0.min() >= 0 # monotonic-0 doesn't overshoot either
# ensure monotonic-0 has 0 slope at end points
np.testing.assert_allclose(dfm0[np.array([0, -1])], 0, atol=1e-12)
class TestInterp2D:
"""Tests for interp2d function."""
@pytest.mark.unit
@pytest.mark.parametrize(
"x, y",
[
(np.linspace(0, 3 * np.pi, 1000), np.linspace(0, 2 * np.pi, 1000)),
(0.0, 0.0),
],
)
def test_interp2d(self, x, y):
"""Test accuracy of different 2d interpolation methods."""
xp = np.linspace(0, 3 * np.pi, 99)
yp = np.linspace(0, 2 * np.pi, 40)
xxp, yyp = np.meshgrid(xp, yp, indexing="ij")
f = lambda x, y: np.sin(x) * np.cos(y)
fp = f(xxp, yyp)
interp1 = lambda xq, yq, *args, **kwargs: interp2d(xq, yq, *args, **kwargs)
interp2 = lambda xq, yq, *args, **kwargs: Interpolator2D(*args, **kwargs)(
xq, yq
)
for interp in [interp1, interp2]:
fq = interp(
x, y, xp, yp, fp, method="nearest", period=(2 * np.pi, 2 * np.pi)
)
np.testing.assert_allclose(fq, f(x, y), rtol=1e-2, atol=1)
fq = interp(
x, y, xp, yp, fp, method="linear", period=(2 * np.pi, 2 * np.pi)
)
np.testing.assert_allclose(fq, f(x, y), rtol=1e-4, atol=1e-2)
atol = 2e-3
rtol = 1e-5
fq = interp(x, y, xp, yp, fp, method="cubic", period=(2 * np.pi, 2 * np.pi))
np.testing.assert_allclose(fq, f(x, y), rtol=rtol, atol=atol)
fq = interp(
x, y, xp, yp, fp, method="cubic2", period=(2 * np.pi, 2 * np.pi)
)
np.testing.assert_allclose(fq, f(x, y), rtol=rtol, atol=atol)
fq = interp(
x, y, xp, yp, fp, method="catmull-rom", period=(2 * np.pi, 2 * np.pi)
)
np.testing.assert_allclose(fq, f(x, y), rtol=rtol, atol=atol)
fq = interp(
x, y, xp, yp, fp, method="cardinal", period=(2 * np.pi, 2 * np.pi)
)
np.testing.assert_allclose(fq, f(x, y), rtol=rtol, atol=atol)
@pytest.mark.unit
def test_interp2d_vector_valued(self):
"""Test for interpolating vector valued function."""
xp = np.linspace(0, 3 * np.pi, 99)
yp = np.linspace(0, 2 * np.pi, 40)
x = np.linspace(0, 3 * np.pi, 200)
y = np.linspace(0, 2 * np.pi, 200)
xxp, yyp = np.meshgrid(xp, yp, indexing="ij")
f = lambda x, y: np.array([np.sin(x) * np.cos(y), np.sin(x) + np.cos(y)])
fp = f(xxp.T, yyp.T).T
fq = interp2d(x, y, xp, yp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x, y).T, rtol=1e-2, atol=1.2e-1)
fq = interp2d(x, y, xp, yp, fp, method="linear")
np.testing.assert_allclose(fq, f(x, y).T, rtol=1e-3, atol=1e-2)
fq = interp2d(x, y, xp, yp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x, y).T, rtol=1e-5, atol=2e-3)
class TestInterp3D:
"""Tests for interp3d function."""
@pytest.mark.unit
@pytest.mark.parametrize(
"x, y, z",
[
(
np.linspace(0, np.pi, 1000),
np.linspace(0, 2 * np.pi, 1000),
np.linspace(0, 3, 1000),
),
(0.0, 0.0, 0.0),
],
)
def test_interp3d(self, x, y, z):
"""Test accuracy of different 3d interpolation methods."""
xp = np.linspace(0, np.pi, 20)
yp = np.linspace(0, 2 * np.pi, 30)
zp = np.linspace(0, 3, 25)
xxp, yyp, zzp = np.meshgrid(xp, yp, zp, indexing="ij")
f = lambda x, y, z: np.sin(x) * np.cos(y) * z**2
fp = f(xxp, yyp, zzp)
interp1 = lambda xq, yq, zq, *args, **kwargs: interp3d(
xq, yq, zq, *args, **kwargs
)
interp2 = lambda xq, yq, zq, *args, **kwargs: Interpolator3D(*args, **kwargs)(
xq, yq, zq
)
for interp in [interp1, interp2]:
fq = interp(x, y, z, xp, yp, zp, fp)
np.testing.assert_allclose(fq, f(x, y, z), rtol=1e-5, atol=1e-2)
fq = interp(x, y, z, xp, yp, zp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x, y, z), rtol=1e-2, atol=1)
fq = interp(x, y, z, xp, yp, zp, fp, method="linear")
np.testing.assert_allclose(fq, f(x, y, z), rtol=1e-3, atol=1e-1)
atol = 5.5e-3
rtol = 1e-5
fq = interp(x, y, z, xp, yp, zp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
fq = interp(x, y, z, xp, yp, zp, fp, method="cubic2")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
fq = interp(x, y, z, xp, yp, zp, fp, method="catmull-rom")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
fq = interp(x, y, z, xp, yp, zp, fp, method="cardinal")
np.testing.assert_allclose(fq, f(x, y, z), rtol=rtol, atol=atol)
@pytest.mark.unit
def test_interp3d_vector_valued(self):
"""Test for interpolating vector valued function."""
x = np.linspace(0, np.pi, 1000)
y = np.linspace(0, 2 * np.pi, 1000)
z = np.linspace(0, 3, 1000)
xp = np.linspace(0, np.pi, 20)
yp = np.linspace(0, 2 * np.pi, 30)
zp = np.linspace(0, 3, 25)
xxp, yyp, zzp = np.meshgrid(xp, yp, zp, indexing="ij")
f = lambda x, y, z: np.array(
[np.sin(x) * np.cos(y) * z**2, 0.1 * (x + y - z)]
)
fp = f(xxp.T, yyp.T, zzp.T).T
fq = interp3d(x, y, z, xp, yp, zp, fp, method="nearest")
np.testing.assert_allclose(fq, f(x, y, z).T, rtol=1e-2, atol=1)
fq = interp3d(x, y, z, xp, yp, zp, fp, method="linear")
np.testing.assert_allclose(fq, f(x, y, z).T, rtol=1e-3, atol=1e-1)
fq = interp3d(x, y, z, xp, yp, zp, fp, method="cubic")
np.testing.assert_allclose(fq, f(x, y, z).T, rtol=1e-5, atol=5e-3)
@pytest.mark.unit
def test_fft_interp1d():
"""Test for 1d Fourier interpolation."""
def fun(x):
return 2 * np.sin(1 * x) + 4 * np.cos(3 * x) + 1
x = {"o": {}, "e": {}}
x["o"][1] = np.linspace(0, 2 * np.pi, 33, endpoint=False)
x["e"][1] = np.linspace(0, 2 * np.pi, 32, endpoint=False)
x["o"][2] = np.linspace(0, 2 * np.pi, 133, endpoint=False)
x["e"][2] = np.linspace(0, 2 * np.pi, 132, endpoint=False)
f1 = {}
for p in ["o", "e"]:
f1[p] = {}
for i in [1, 2]:
f1[p][i] = fun(x[p][i])
for sp in ["o", "e"]: # source parity
fi = f1[sp][1]
fs = fun(x[sp][1] + 0.2)
np.testing.assert_allclose( | fs, fft_interp1d(fi, *fi.shape, sx=0.2, dx=np.diff(x[sp][1])[0]).squeeze() | 0 | 2023-10-18 13:12:20+00:00 | 24k |
city96/ComfyUI_ExtraModels | PixArt/sampler.py | [
{
"identifier": "gaussian_diffusion",
"path": "PixArt/sampling/gaussian_diffusion.py",
"snippet": "def mean_flat(tensor):\n def is_vb(self):\ndef _warmup_beta(beta_start, beta_end, num_diffusion_timesteps, warmup_frac):\ndef get_beta_schedule(beta_schedule, *, beta_start, beta_end, num_diffusion_time... | import torch
import comfy.utils
import latent_preview
from .sampling import gaussian_diffusion as gd
from .sampling.dpm_solver import model_wrapper, DPM_Solver, NoiseScheduleVP
from comfy.sample import prepare_sampling, prepare_noise, cleanup_additional_models, get_models_from_cond
| 20,027 |
def sample_pixart(model, seed, steps, cfg, noise_schedule, noise_schedule_vp, positive, negative, latent_image):
"""
Mostly just a wrapper around the reference code.
"""
# prepare model
noise = prepare_noise(latent_image, seed)
real_model, _, _, _, models = prepare_sampling(model, noise.shape, positive, negative, noise_mask=None)
# negative cond
cond = positive[0][0]
raw_uncond = negative[0][0]
# Sampler seems to want the same dim for cond and uncond
# truncate uncond to the length of cond
# if shorter, pad uncond with y_null
null_y = real_model.diffusion_model.y_embedder.y_embedding[None].repeat(latent_image.shape[0], 1, 1)
uncond = null_y[:, :cond.shape[1], :]
uncond[:, :raw_uncond.shape[1], :] = raw_uncond[:, :cond.shape[1], :]
if raw_uncond.shape[1] > cond.shape[1]:
print("PixArt: Warning. Your negative prompt is too long.")
uncond[:, -1, :] = raw_uncond[:, -1, :] # add back EOS token
# Move inputs
cond = cond.to(model.load_device).to(real_model.diffusion_model.dtype)
uncond = uncond.to(model.load_device).to(real_model.diffusion_model.dtype)
noise = noise.to(model.load_device).to(real_model.diffusion_model.dtype)
# preview
pbar = comfy.utils.ProgressBar(steps)
previewer = latent_preview.get_previewer(model.load_device, model.model.latent_format)
## Noise schedule.
|
def sample_pixart(model, seed, steps, cfg, noise_schedule, noise_schedule_vp, positive, negative, latent_image):
"""
Mostly just a wrapper around the reference code.
"""
# prepare model
noise = prepare_noise(latent_image, seed)
real_model, _, _, _, models = prepare_sampling(model, noise.shape, positive, negative, noise_mask=None)
# negative cond
cond = positive[0][0]
raw_uncond = negative[0][0]
# Sampler seems to want the same dim for cond and uncond
# truncate uncond to the length of cond
# if shorter, pad uncond with y_null
null_y = real_model.diffusion_model.y_embedder.y_embedding[None].repeat(latent_image.shape[0], 1, 1)
uncond = null_y[:, :cond.shape[1], :]
uncond[:, :raw_uncond.shape[1], :] = raw_uncond[:, :cond.shape[1], :]
if raw_uncond.shape[1] > cond.shape[1]:
print("PixArt: Warning. Your negative prompt is too long.")
uncond[:, -1, :] = raw_uncond[:, -1, :] # add back EOS token
# Move inputs
cond = cond.to(model.load_device).to(real_model.diffusion_model.dtype)
uncond = uncond.to(model.load_device).to(real_model.diffusion_model.dtype)
noise = noise.to(model.load_device).to(real_model.diffusion_model.dtype)
# preview
pbar = comfy.utils.ProgressBar(steps)
previewer = latent_preview.get_previewer(model.load_device, model.model.latent_format)
## Noise schedule.
| betas = torch.tensor(gd.get_named_beta_schedule(noise_schedule, 1000))
| 3 | 2023-10-20 21:19:44+00:00 | 24k |
amitfin/oref_alert | custom_components/oref_alert/area_utils.py | [
{
"identifier": "CITY_ALL_AREAS",
"path": "custom_components/oref_alert/metadata/city_all_areas.py",
"snippet": "CITY_ALL_AREAS = {\n \"אשדוד - כל האזורים\": [\n \"אשדוד - א,ב,ד,ה\",\n \"אשדוד - איזור תעשייה צפוני\",\n \"אשדוד - ג,ו,ז\",\n \"אשדוד - ח,ט,י,יג,יד,טז\",\n ... | from .metadata.city_all_areas import CITY_ALL_AREAS
from .metadata.district_to_areas import DISTRICT_AREAS | 18,992 | """Utilities for metadata information."""
def expand_areas_and_groups(areas_and_groups: list[str]) -> list[str]:
"""Expand groups (if exists) to areas."""
areas = []
for area_or_group in areas_and_groups:
if area_or_group in CITY_ALL_AREAS:
areas.extend(CITY_ALL_AREAS[area_or_group])
| """Utilities for metadata information."""
def expand_areas_and_groups(areas_and_groups: list[str]) -> list[str]:
"""Expand groups (if exists) to areas."""
areas = []
for area_or_group in areas_and_groups:
if area_or_group in CITY_ALL_AREAS:
areas.extend(CITY_ALL_AREAS[area_or_group]) | elif area_or_group in DISTRICT_AREAS: | 1 | 2023-10-18 11:16:41+00:00 | 24k |
RobertCsordas/moe | tasks/simple/language_model/transformer_lm_mixin.py | [
{
"identifier": "TransformerLanguageModel",
"path": "models/transformer_language_model.py",
"snippet": "class TransformerLanguageModel(LoggingLayer, torch.nn.Module):\n def __init__(self, voc_size: int, embedding_size: Optional[int], state_size: int, dropout: float,\n tied_embedding: ... | import framework
import torch
import torch.nn
import torch.nn.functional as F
import torch.utils.data
import math
from typing import List, Tuple, Dict, Any
from models import TransformerLanguageModel
from ... import task, args
from layers.transformer import RelativeTransformerEncoderLayer, PrelnRelativeTransformerEncoderLayer
from layers.transformer.relative_preln_kvmem_transformer import PrelnRelativeKVMemTransformerEncoderLayer
from layers.transformer.relative_moe_transformer import RelativeMoeTransformerEncoderLayer
from layers.transformer.topk_transformer import TopkTransformer
from layers.moe_layer import MoE
from interfaces import Result | 18,710 | parser.add_argument("-moe.perplexity_reg_mode", default="step", choice=["step", "global", "time", "global_time"])
parser.add_argument("-moe.reg_type", default="entropy", choice=["perplexity", "variance", "entropy", "l2", "switch", "normal"])
parser.add_argument("-moe.key_mode", default="moe", choice=["moe", "both", "shared"])
parser.add_argument("-moe.half_key", default=False)
parser.add_argument("-moe.norm_keys", default=False)
parser.add_argument("-moe.kmeans_distance", default='cosine', choice=['cosine', 'euclidean'])
parser.add_argument("-moe.n_random", default=0)
parser.add_argument("-moe.std_correction", default=False)
parser.add_argument("-moe.topk_mode", default="full", choice=["full", "l1_approx", "approx"])
parser.add_argument("-moe.activation_after_topk", default=False)
parser.add_argument("-moe.weight_grouping", default="none", choice=["none", "keys_only", "keys_and_experts"])
parser.add_argument("-moe.drop_parallel", default=True)
parser.add_argument("-moe.mlp_selection", default=False)
parser.add_argument("-moe.block_expert_sel_in_grad", default=False)
parser.add_argument("-moe.classification_target", default="sum", choice=["sum", "max"])
parser.add_argument("-moe.recluster_steps", default="", parser=parser.int_list_parser)
parser.add_argument("-moe.norm_key_init", default=False)
parser.add_argument("-moe.norm_value_init", default=False)
parser.add_argument("-moe.norm_expert_sel_init", default=False)
parser.add_argument("-moe.norm_standard_parallel_values", default=False)
parser.add_argument("-moe.identical_init", default=False)
parser.add_argument("-moe.topological_sel_reg", default=0.0)
parser.add_argument("-moe.topological_expert_reg", default=0.0)
parser.add_argument("-moe.sel_lr_multipler", default=1.0)
parser.add_argument("-moe.expert_lr_multipler", default=1.0)
parser.add_argument("-moe.gumbel_select_only", default=False)
parser.add_argument("-moe.topk_value_norm_compensation", default=False)
parser.add_argument("-moe.norm_expert_scores", default=False)
parser.add_argument("-moe.sel_input_cluster_init", default=False)
parser.add_argument("-moe.init_norm_mode", default="full")
parser.add_argument("-moe.bias", default=False)
parser.add_argument("-moe.sel_bias", default=False)
parser.add_argument("-moe.rescale_normed", default=False)
parser.add_argument("-moe.sel_norm", default="none", choice=["none", "cos", "input", "weights"])
parser.add_argument("-moe.rescale_grads", default=False)
parser.add_argument("-moe.gumbel_decay", default=0)
parser.add_argument("-moe.sinkhorn_local", default=False)
parser.add_argument("-moe.sinkhron_n_iters", default=3)
parser.add_argument("-moe.dropout_factor", default=1.0)
parser.add_argument("-moe.drop_expert", default=0.0)
parser.add_argument("-moe.expert_size_init", default=False)
parser.add_argument("-moe.sync_distributed", default=True)
parser.add_argument("-moe.modulation_amplitude", default=0.5)
parser.add_argument("-moe.invisible_selection", default=False)
parser.add_argument("-moe.slope_multiplier", default=1.0)
parser.add_argument("-moe.init_scale", default=1.0)
parser.add_argument("-kvmem.linproj", default=False)
parser.add_argument("-kvmem.head_merge_topk", default=False)
parser.add_argument("-kvmem.load_balance", default=False)
parser.add_argument("-kvmem.dropout", default="none", choice=["none", "early", "late", "weight", "score"])
parser.add_argument("-kvmem.randomize_indices", default=False)
parser.add_argument("-kvmem.standard_parallel", default=False)
parser.add_argument("-kvmem.query_bias", default=False)
parser.add_argument("-kvmem.approx_topk", default=False)
parser.add_argument("-kvmem.norm_values", default=False)
parser.add_argument("-kvmem.factorize", default=False)
parser.add_argument("-kvmem.full_key", default=False)
parser.add_argument("-kvmem.key_redundancy_factor", default=1)
parser.add_argument("-kvmem.two_stage", default=False)
parser.add_argument("-kvmem.head_exclusive", default=False)
parser.add_argument("-transformer.topk_value", default=32)
parser.add_argument("-transformer.universal.nonshared", default=0)
parser.add_argument("-transformer.topk_use_norm", default=True)
parser.add_argument("-transformer.activation", default="relu", choice=["relu", "topk", "gelu", "identity", "sigmoid", "softmax"])
parser.add_argument("-transformer.p_drop_layer", default=0.0)
parser.add_argument("-transformer.head_projection_size", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-transformer.ln_affine", default=True)
parser.add_argument("-transformer.ln_after_attention", default=True)
parser.add_argument("-transformer.output_mode", default="normal", choice=["normal", "sum", "geometric", "sigmoid"])
@task()
class TransformerLMMixin:
helper: framework.helpers.TrainingHelper
def is_preln(self) -> bool:
return "preln" in self.helper.args.transformer.variant
def topk_activation(self, x: torch.Tensor) -> torch.Tensor:
nx = -x
return torch.masked_fill(x, nx <= nx.kthvalue(self.helper.args.transformer.topk_value, keepdim=True)[0], 0)
def get_layers(self) -> List[torch.nn.Module]:
# pyright: reportOptionalMemberAccess=false
if self.helper.args.transformer.activation == "relu":
activation = F.relu
elif self.helper.args.transformer.activation == "topk":
activation = self.topk_activation
elif self.helper.args.transformer.activation == "identity":
activation = lambda x: x
elif self.helper.args.transformer.activation == "sigmoid":
activation = torch.sigmoid
elif self.helper.args.transformer.activation == "gelu":
activation = F.gelu
elif self.helper.args.transformer.activation == "softmax":
activation = lambda x: F.softmax(x, dim=-1)
else:
raise ValueError(f"Invalid activation: {self.helper.args.transformer.activation}")
base_args = dict(
d_model=self.helper.args.state_size,
nhead=self.helper.args.transformer.n_heads,
dim_feedforward=int(self.helper.args.state_size * self.helper.args.transformer.ff_multiplier),
dropout=self.helper.args.dropout,
activation=activation
)
extra_args = {} if not self.helper.args.transformer.variant.endswith("_gelu") else {
"activation": F.gelu,
"drop_expand": False
}
if self.helper.args.transformer.variant in {"preln_relative"}:
mklayer = lambda: PrelnRelativeTransformerEncoderLayer(
**base_args, **extra_args, test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers,
head_projection_size=self.helper.args.transformer.head_projection_size,)
elif self.helper.args.transformer.variant in {"preln_topk"}:
|
@args
def a(parser: framework.helpers.ArgumentParser):
parser.add_argument("-lm.trafo.context_blocks", default=1)
parser.add_argument("-lm.trafo.test_context_blocks", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-lm.trafo.test_pos_clamp", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-lm.trafo.same_length_eval", default=False)
parser.add_argument("-lm.trafo.same_length", default=False)
parser.add_argument("-lm.trafo.last_layer_context", default=False)
parser.add_argument("-lm.trafo.xl_init", default=False)
parser.add_argument("-lm.trafo.embedding_mode_init", default="default", choice=["default", "scale_to_sqrt_dmodel", "init_to_sqrt_dmodel", "one_and_scale_to_sqrt_dmodel", "like_preln"])
parser.add_argument("-pkm.n_keys", default="128", parser=parser.int_list_parser)
parser.add_argument("-pkm.n_heads", default=1)
parser.add_argument("-pkm.knn", default=32)
parser.add_argument("-pkm.stochastic", default=False)
parser.add_argument("-pkm.query_batchnorm", default=False)
parser.add_argument("-pkm.custom_init", default=0)
parser.add_argument("-pkm.slice_values", default=False)
parser.add_argument("-pkm.slice_proj", default=False)
parser.add_argument("-pkm.sample_smallest", default=False)
parser.add_argument("-moe.n_experts", default=128)
parser.add_argument("-moe.expert_size", default=128)
parser.add_argument("-moe.selection_mode", default="add", choice=["add", "gate", "sigmoid", "gumbel", "hard_gumbel", "predict", "predict_mlp", "classify", "gumbel_sigmoid", "sinkhorn", "sinkhorn2", "sinkmoid", "sinkmax", "moe", "mul", "random", "sinkmoid2", "sinkmax2", "modulate"])
parser.add_argument("-moe.perplexity_reg", default=0.0)
parser.add_argument("-moe.perplexity_reg_mode", default="step", choice=["step", "global", "time", "global_time"])
parser.add_argument("-moe.reg_type", default="entropy", choice=["perplexity", "variance", "entropy", "l2", "switch", "normal"])
parser.add_argument("-moe.key_mode", default="moe", choice=["moe", "both", "shared"])
parser.add_argument("-moe.half_key", default=False)
parser.add_argument("-moe.norm_keys", default=False)
parser.add_argument("-moe.kmeans_distance", default='cosine', choice=['cosine', 'euclidean'])
parser.add_argument("-moe.n_random", default=0)
parser.add_argument("-moe.std_correction", default=False)
parser.add_argument("-moe.topk_mode", default="full", choice=["full", "l1_approx", "approx"])
parser.add_argument("-moe.activation_after_topk", default=False)
parser.add_argument("-moe.weight_grouping", default="none", choice=["none", "keys_only", "keys_and_experts"])
parser.add_argument("-moe.drop_parallel", default=True)
parser.add_argument("-moe.mlp_selection", default=False)
parser.add_argument("-moe.block_expert_sel_in_grad", default=False)
parser.add_argument("-moe.classification_target", default="sum", choice=["sum", "max"])
parser.add_argument("-moe.recluster_steps", default="", parser=parser.int_list_parser)
parser.add_argument("-moe.norm_key_init", default=False)
parser.add_argument("-moe.norm_value_init", default=False)
parser.add_argument("-moe.norm_expert_sel_init", default=False)
parser.add_argument("-moe.norm_standard_parallel_values", default=False)
parser.add_argument("-moe.identical_init", default=False)
parser.add_argument("-moe.topological_sel_reg", default=0.0)
parser.add_argument("-moe.topological_expert_reg", default=0.0)
parser.add_argument("-moe.sel_lr_multipler", default=1.0)
parser.add_argument("-moe.expert_lr_multipler", default=1.0)
parser.add_argument("-moe.gumbel_select_only", default=False)
parser.add_argument("-moe.topk_value_norm_compensation", default=False)
parser.add_argument("-moe.norm_expert_scores", default=False)
parser.add_argument("-moe.sel_input_cluster_init", default=False)
parser.add_argument("-moe.init_norm_mode", default="full")
parser.add_argument("-moe.bias", default=False)
parser.add_argument("-moe.sel_bias", default=False)
parser.add_argument("-moe.rescale_normed", default=False)
parser.add_argument("-moe.sel_norm", default="none", choice=["none", "cos", "input", "weights"])
parser.add_argument("-moe.rescale_grads", default=False)
parser.add_argument("-moe.gumbel_decay", default=0)
parser.add_argument("-moe.sinkhorn_local", default=False)
parser.add_argument("-moe.sinkhron_n_iters", default=3)
parser.add_argument("-moe.dropout_factor", default=1.0)
parser.add_argument("-moe.drop_expert", default=0.0)
parser.add_argument("-moe.expert_size_init", default=False)
parser.add_argument("-moe.sync_distributed", default=True)
parser.add_argument("-moe.modulation_amplitude", default=0.5)
parser.add_argument("-moe.invisible_selection", default=False)
parser.add_argument("-moe.slope_multiplier", default=1.0)
parser.add_argument("-moe.init_scale", default=1.0)
parser.add_argument("-kvmem.linproj", default=False)
parser.add_argument("-kvmem.head_merge_topk", default=False)
parser.add_argument("-kvmem.load_balance", default=False)
parser.add_argument("-kvmem.dropout", default="none", choice=["none", "early", "late", "weight", "score"])
parser.add_argument("-kvmem.randomize_indices", default=False)
parser.add_argument("-kvmem.standard_parallel", default=False)
parser.add_argument("-kvmem.query_bias", default=False)
parser.add_argument("-kvmem.approx_topk", default=False)
parser.add_argument("-kvmem.norm_values", default=False)
parser.add_argument("-kvmem.factorize", default=False)
parser.add_argument("-kvmem.full_key", default=False)
parser.add_argument("-kvmem.key_redundancy_factor", default=1)
parser.add_argument("-kvmem.two_stage", default=False)
parser.add_argument("-kvmem.head_exclusive", default=False)
parser.add_argument("-transformer.topk_value", default=32)
parser.add_argument("-transformer.universal.nonshared", default=0)
parser.add_argument("-transformer.topk_use_norm", default=True)
parser.add_argument("-transformer.activation", default="relu", choice=["relu", "topk", "gelu", "identity", "sigmoid", "softmax"])
parser.add_argument("-transformer.p_drop_layer", default=0.0)
parser.add_argument("-transformer.head_projection_size", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-transformer.ln_affine", default=True)
parser.add_argument("-transformer.ln_after_attention", default=True)
parser.add_argument("-transformer.output_mode", default="normal", choice=["normal", "sum", "geometric", "sigmoid"])
@task()
class TransformerLMMixin:
helper: framework.helpers.TrainingHelper
def is_preln(self) -> bool:
return "preln" in self.helper.args.transformer.variant
def topk_activation(self, x: torch.Tensor) -> torch.Tensor:
nx = -x
return torch.masked_fill(x, nx <= nx.kthvalue(self.helper.args.transformer.topk_value, keepdim=True)[0], 0)
def get_layers(self) -> List[torch.nn.Module]:
# pyright: reportOptionalMemberAccess=false
if self.helper.args.transformer.activation == "relu":
activation = F.relu
elif self.helper.args.transformer.activation == "topk":
activation = self.topk_activation
elif self.helper.args.transformer.activation == "identity":
activation = lambda x: x
elif self.helper.args.transformer.activation == "sigmoid":
activation = torch.sigmoid
elif self.helper.args.transformer.activation == "gelu":
activation = F.gelu
elif self.helper.args.transformer.activation == "softmax":
activation = lambda x: F.softmax(x, dim=-1)
else:
raise ValueError(f"Invalid activation: {self.helper.args.transformer.activation}")
base_args = dict(
d_model=self.helper.args.state_size,
nhead=self.helper.args.transformer.n_heads,
dim_feedforward=int(self.helper.args.state_size * self.helper.args.transformer.ff_multiplier),
dropout=self.helper.args.dropout,
activation=activation
)
extra_args = {} if not self.helper.args.transformer.variant.endswith("_gelu") else {
"activation": F.gelu,
"drop_expand": False
}
if self.helper.args.transformer.variant in {"preln_relative"}:
mklayer = lambda: PrelnRelativeTransformerEncoderLayer(
**base_args, **extra_args, test_pos_clamp=self.helper.args.lm.trafo.test_pos_clamp,
n_layers=self.helper.args.transformer.encoder_n_layers,
head_projection_size=self.helper.args.transformer.head_projection_size,)
elif self.helper.args.transformer.variant in {"preln_topk"}: | mklayer = lambda: TopkTransformer( | 7 | 2023-10-16 11:26:45+00:00 | 24k |
boppreh/hello_tls | src/hello_tls/scan.py | [
{
"identifier": "ClientHello",
"path": "src/hello_tls/protocol.py",
"snippet": "class ScanError(Exception):\nclass ServerAlertError(ScanError):\nclass BadServerResponse(ScanError):\nclass ServerHello:\nclass ClientHello:\n def __init__(self, level: AlertLevel, description: AlertDescription):\ndef _ma... | from enum import Enum
from multiprocessing.pool import ThreadPool
from typing import Iterable, Union, List, Optional, Iterator, Callable, Any
from urllib.parse import urlparse
from datetime import datetime, timezone
from .protocol import ClientHello, ScanError, make_client_hello, parse_server_hello, ServerAlertError, BadServerResponse, ServerHello, logger
from .names_and_numbers import AlertDescription, CipherSuite, Group, Protocol, CompressionMethod
from OpenSSL import SSL, crypto
import socket
import re
import dataclasses
import ssl, select | 14,595 |
# Default number of workers/threads/concurrent connections to use.
DEFAULT_MAX_WORKERS: int = 6
# Default socket connection timeout, in seconds.
DEFAULT_TIMEOUT: float = 2
class DowngradeError(ScanError):
""" Error for servers that attempt to downgrade beyond supported versions. """
pass
class ConnectionError(ScanError):
""" Class for error in resolving or connecting to a server. """
pass
class ProxyError(ConnectionError):
""" Class for errors in connecting through a proxy. """
pass
@dataclasses.dataclass
class ConnectionSettings:
"""
Settings for a connection to a server, including the host, port, and proxy.
"""
host: str
port: int = 443
proxy: Optional[str] = None
timeout_in_seconds: Optional[float] = DEFAULT_TIMEOUT
date: datetime = dataclasses.field(default_factory=lambda: datetime.now(tz=timezone.utc).replace(microsecond=0))
def make_socket(settings: ConnectionSettings) -> socket.socket:
"""
Creates and connects a socket to the target server, through the chosen proxy if any.
"""
socket_host, socket_port = None, None # To appease the type checker.
try:
if not settings.proxy:
socket_host, socket_port = settings.host, settings.port
return socket.create_connection((socket_host, socket_port), timeout=settings.timeout_in_seconds)
if not settings.proxy.startswith('http://'):
raise ProxyError("Only HTTP proxies are supported at the moment.", settings.proxy)
socket_host, socket_port = parse_target(settings.proxy, 80)
sock = socket.create_connection((socket_host, socket_port), timeout=settings.timeout_in_seconds)
sock.send(f"CONNECT {settings.host}:{settings.port} HTTP/1.1\r\nhost:{socket_host}\r\n\r\n".encode('utf-8'))
sock_file = sock.makefile('r', newline='\r\n')
line = sock_file.readline()
if not re.fullmatch(r'HTTP/1\.[01] 200 Connection [Ee]stablished\r\n', line):
sock_file.close()
sock.close()
raise ProxyError("Proxy refused the connection: ", line)
while True:
if sock_file.readline() == '\r\n':
break
return sock
except TimeoutError as e:
raise ConnectionError(f"Connection to {socket_host}:{socket_port} timed out after {settings.timeout_in_seconds} seconds") from e
except socket.gaierror as e:
raise ConnectionError(f"Could not resolve host {socket_host}") from e
except socket.error as e:
raise ConnectionError(f"Could not connect to {socket_host}:{socket_port}") from e
def send_hello(connection_settings: ConnectionSettings, client_hello: ClientHello) -> ServerHello:
"""
Sends a Client Hello to the server, and returns the parsed ServerHello.
Raises exceptions for the different alert messages the server can send.
"""
sock = make_socket(connection_settings)
sock.send(make_client_hello(client_hello))
packet_stream = iter(lambda: sock.recv(4096), b'')
server_hello = parse_server_hello(packet_stream)
if server_hello.version not in client_hello.protocols:
# Server picked a protocol we didn't ask for.
logger.info(f"Server attempted to downgrade protocol to unsupported version {server_hello.version}")
raise DowngradeError(f"Server attempted to downgrade from {client_hello.protocols} to {server_hello.version}")
return server_hello
def _iterate_server_option(connection_settings: ConnectionSettings, client_hello: ClientHello, request_option: str, response_option: str, on_response: Callable[[ServerHello], None] = lambda s: None) -> Iterator[Any]:
"""
Continually sends Client Hello packets to the server, removing the `response_option` from the list of options each time,
until the server rejects the handshake.
"""
# We'll be mutating the list of options, so make a copy.
options_to_test = list(getattr(client_hello, request_option))
# TODO: figure out how to have mypy accept this line.
client_hello = dataclasses.replace(client_hello, **{request_option: options_to_test}) # type: ignore
logger.info(f"Enumerating server {response_option} with {len(options_to_test)} options and protocols {client_hello.protocols}")
while options_to_test:
try:
logger.debug(f"Offering {len(options_to_test)} {response_option} over {client_hello.protocols}: {options_to_test}")
server_hello = send_hello(connection_settings, client_hello)
on_response(server_hello)
except DowngradeError:
break
|
# Default number of workers/threads/concurrent connections to use.
DEFAULT_MAX_WORKERS: int = 6
# Default socket connection timeout, in seconds.
DEFAULT_TIMEOUT: float = 2
class DowngradeError(ScanError):
""" Error for servers that attempt to downgrade beyond supported versions. """
pass
class ConnectionError(ScanError):
""" Class for error in resolving or connecting to a server. """
pass
class ProxyError(ConnectionError):
""" Class for errors in connecting through a proxy. """
pass
@dataclasses.dataclass
class ConnectionSettings:
"""
Settings for a connection to a server, including the host, port, and proxy.
"""
host: str
port: int = 443
proxy: Optional[str] = None
timeout_in_seconds: Optional[float] = DEFAULT_TIMEOUT
date: datetime = dataclasses.field(default_factory=lambda: datetime.now(tz=timezone.utc).replace(microsecond=0))
def make_socket(settings: ConnectionSettings) -> socket.socket:
"""
Creates and connects a socket to the target server, through the chosen proxy if any.
"""
socket_host, socket_port = None, None # To appease the type checker.
try:
if not settings.proxy:
socket_host, socket_port = settings.host, settings.port
return socket.create_connection((socket_host, socket_port), timeout=settings.timeout_in_seconds)
if not settings.proxy.startswith('http://'):
raise ProxyError("Only HTTP proxies are supported at the moment.", settings.proxy)
socket_host, socket_port = parse_target(settings.proxy, 80)
sock = socket.create_connection((socket_host, socket_port), timeout=settings.timeout_in_seconds)
sock.send(f"CONNECT {settings.host}:{settings.port} HTTP/1.1\r\nhost:{socket_host}\r\n\r\n".encode('utf-8'))
sock_file = sock.makefile('r', newline='\r\n')
line = sock_file.readline()
if not re.fullmatch(r'HTTP/1\.[01] 200 Connection [Ee]stablished\r\n', line):
sock_file.close()
sock.close()
raise ProxyError("Proxy refused the connection: ", line)
while True:
if sock_file.readline() == '\r\n':
break
return sock
except TimeoutError as e:
raise ConnectionError(f"Connection to {socket_host}:{socket_port} timed out after {settings.timeout_in_seconds} seconds") from e
except socket.gaierror as e:
raise ConnectionError(f"Could not resolve host {socket_host}") from e
except socket.error as e:
raise ConnectionError(f"Could not connect to {socket_host}:{socket_port}") from e
def send_hello(connection_settings: ConnectionSettings, client_hello: ClientHello) -> ServerHello:
"""
Sends a Client Hello to the server, and returns the parsed ServerHello.
Raises exceptions for the different alert messages the server can send.
"""
sock = make_socket(connection_settings)
sock.send(make_client_hello(client_hello))
packet_stream = iter(lambda: sock.recv(4096), b'')
server_hello = parse_server_hello(packet_stream)
if server_hello.version not in client_hello.protocols:
# Server picked a protocol we didn't ask for.
logger.info(f"Server attempted to downgrade protocol to unsupported version {server_hello.version}")
raise DowngradeError(f"Server attempted to downgrade from {client_hello.protocols} to {server_hello.version}")
return server_hello
def _iterate_server_option(connection_settings: ConnectionSettings, client_hello: ClientHello, request_option: str, response_option: str, on_response: Callable[[ServerHello], None] = lambda s: None) -> Iterator[Any]:
"""
Continually sends Client Hello packets to the server, removing the `response_option` from the list of options each time,
until the server rejects the handshake.
"""
# We'll be mutating the list of options, so make a copy.
options_to_test = list(getattr(client_hello, request_option))
# TODO: figure out how to have mypy accept this line.
client_hello = dataclasses.replace(client_hello, **{request_option: options_to_test}) # type: ignore
logger.info(f"Enumerating server {response_option} with {len(options_to_test)} options and protocols {client_hello.protocols}")
while options_to_test:
try:
logger.debug(f"Offering {len(options_to_test)} {response_option} over {client_hello.protocols}: {options_to_test}")
server_hello = send_hello(connection_settings, client_hello)
on_response(server_hello)
except DowngradeError:
break | except ServerAlertError as error: | 0 | 2023-10-21 02:00:13+00:00 | 24k |
zhaojw1998/AccoMontage-3 | arrangement_utils.py | [
{
"identifier": "split_phrases",
"path": "piano_arranger/acc_utils.py",
"snippet": "def split_phrases(segmentation):\n \"\"\"Split a phrase label string into individual phrase meta info\"\"\"\n if '\\n' not in segmentation:\n segmentation += '\\n'\n phrases = []\n lengths = []\n cu... | import os
import pretty_midi as pyd
import numpy as np
import torch
import piano_arranger.format_converter as cvt
from torch.utils.data import DataLoader
from scipy.interpolate import interp1d
from tqdm import tqdm
from piano_arranger.acc_utils import split_phrases
from piano_arranger.models import DisentangleVAE
from piano_arranger.AccoMontage import find_by_length, dp_search, re_harmonization, get_texture_filter, ref_spotlight
from orchestrator import Slakh2100_Pop909_Dataset, collate_fn, compute_pr_feat, EMBED_PROGRAM_MAPPING, Prior
from orchestrator.QA_dataset import SLAKH_CLASS_PROGRAMS
from orchestrator.utils import grid2pr, pr2grid, matrix2midi, midi2matrix
from orchestrator.prior_dataset import TOTAL_LEN_BIN, ABS_POS_BIN, REL_POS_BIN | 18,914 |
SLAKH_CLASS_MAPPING = {v: k for k, v in EMBED_PROGRAM_MAPPING.items()}
def load_premise(DATA_FILE_ROOT, DEVICE):
"""Load AccoMontage Search Space"""
print('Loading AccoMontage piano texture search space. This may take 1 or 2 minutes ...')
data = np.load(os.path.join(DATA_FILE_ROOT, 'phrase_data.npz'), allow_pickle=True)
melody = data['melody']
acc = data['acc']
chord = data['chord']
vel = data['velocity']
cc = data['cc']
acc_pool = {}
for LEN in tqdm(range(2, 13)):
(mel, acc_, chord_, vel_, cc_, song_reference) = find_by_length(melody, acc, chord, vel, cc, LEN)
acc_pool[LEN] = (mel, acc_, chord_, vel_, cc_, song_reference)
texture_filter = get_texture_filter(acc_pool)
edge_weights=np.load(os.path.join(DATA_FILE_ROOT, 'edge_weights.npz'), allow_pickle=True)
"""Load Q&A Prompt Search Space"""
print('loading orchestration prompt search space ...')
slakh_dir = os.path.join(DATA_FILE_ROOT, 'Slakh2100_inference_set')
dataset = Slakh2100_Pop909_Dataset(slakh_dir=slakh_dir, pop909_dir=None, debug_mode=False, split='validation', mode='train')
loader = DataLoader(dataset, batch_size=1, shuffle=True, collate_fn=lambda b:collate_fn(b, DEVICE))
REF = []
REF_PROG = []
REF_MIX = []
for (_, prog, function, _, _, _) in loader:
prog = prog[0, :]
REF.extend([batch for batch in function])
REF_PROG.extend([prog for _ in range(len(function))])
REF_MIX.append(torch.sum(function, dim=1))
REF_MIX = torch.cat(REF_MIX, dim=0)
"""Initialize orchestration model (Prior + Q&A)"""
print('Initialize model ...')
prior_model_path = os.path.join(DATA_FILE_ROOT, 'params_prior.pt')
QaA_model_path = os.path.join(DATA_FILE_ROOT, 'params_qa.pt')
orchestrator = Prior.init_inference_model(prior_model_path, QaA_model_path, DEVICE=DEVICE)
orchestrator.to(DEVICE)
orchestrator.eval()
piano_arranger = DisentangleVAE.init_model(torch.device('cuda')).cuda()
piano_arranger.load_state_dict(torch.load(os.path.join(DATA_FILE_ROOT, 'params_reharmonizer.pt')))
print('Finished.')
return piano_arranger, orchestrator, (acc_pool, edge_weights, texture_filter), (REF, REF_PROG, REF_MIX)
def read_lead_sheet(DEMO_ROOT, SONG_NAME, SEGMENTATION, NOTE_SHIFT, melody_track_ID=0):
melody_roll, chord_roll = cvt.leadsheet2matrix(os.path.join(DEMO_ROOT, SONG_NAME, 'lead sheet.mid'), melody_track_ID)
assert(len(melody_roll == len(chord_roll)))
if NOTE_SHIFT != 0:
melody_roll = melody_roll[int(NOTE_SHIFT*4):, :]
chord_roll = chord_roll[int(NOTE_SHIFT*4):, :]
if len(melody_roll) % 16 != 0:
pad_len = (len(melody_roll)//16+1)*16-len(melody_roll)
melody_roll = np.pad(melody_roll, ((0, pad_len), (0, 0)))
melody_roll[-pad_len:, -1] = 1
chord_roll = np.pad(chord_roll, ((0, pad_len), (0, 0)))
chord_roll[-pad_len:, 0] = -1
chord_roll[-pad_len:, -1] = -1
CHORD_TABLE = np.stack([cvt.expand_chord(chord) for chord in chord_roll[::4]], axis=0)
LEADSHEET = np.concatenate((melody_roll, chord_roll[:, 1: -1]), axis=-1) #T*142, quantized at 16th
query_phrases = split_phrases(SEGMENTATION) #[('A', 8, 0), ('A', 8, 8), ('B', 8, 16), ('B', 8, 24)]
midi_len = len(LEADSHEET)//16
anno_len = sum([item[1] for item in query_phrases])
if midi_len > anno_len:
LEADSHEET = LEADSHEET[: anno_len*16]
CHORD_TABLE = CHORD_TABLE[: anno_len*4]
print(f'Mismatch warning: Detect {midi_len} bars in the lead sheet (MIDI) and {anno_len} bars in the provided phrase annotation. The lead sheet is truncated to {anno_len} bars.')
elif midi_len < anno_len:
pad_len = (anno_len - midi_len)*16
LEADSHEET = np.pad(LEADSHEET, ((0, pad_len), (0, 0)))
LEADSHEET[-pad_len:, 129] = 1
CHORD_TABLE = np.pad(CHORD_TABLE, ((0, pad_len//4), (0, 0)))
CHORD_TABLE[-pad_len//4:, 11] = -1
CHORD_TABLE[-pad_len//4:, -1] = -1
print(f'Mismatch warning: Detect {midi_len} bars in the lead sheet (MIDI) and {anno_len} bars in the provided phrase annotation. The lead sheet is padded to {anno_len} bars.')
melody_queries = []
for item in query_phrases:
start_bar = item[-1]
length = item[-2]
segment = LEADSHEET[start_bar*16: (start_bar+length)*16]
melody_queries.append(segment) #melody queries: list of T16*142, segmented by phrases
return (LEADSHEET, CHORD_TABLE, melody_queries, query_phrases)
def piano_arrangement(pianoRoll, chord_table, melody_queries, query_phrases, acc_pool, edge_weights, texture_filter, piano_arranger, PREFILTER, tempo=100):
print('Phrasal Unit selection begins:\n\t', f'{len(query_phrases)} phrases in the lead sheet;\n\t', f'set note density filter: {PREFILTER}.')
phrase_indice, chord_shift = dp_search( melody_queries,
query_phrases,
acc_pool,
edge_weights,
texture_filter,
filter_id=PREFILTER)
path = phrase_indice[0]
shift = chord_shift[0]
print('Re-harmonization begins ...')
midi_recon, acc = re_harmonization(pianoRoll, chord_table, query_phrases, path, shift, acc_pool, model=piano_arranger, get_est=True, tempo=tempo)
acc = np.array([grid2pr(matrix) for matrix in acc])
print('Piano accompaiment generated!')
return midi_recon, acc
def prompt_sampling(acc_piano, REF, REF_PROG, REF_MIX, DEVICE='cuda:0'):
|
SLAKH_CLASS_MAPPING = {v: k for k, v in EMBED_PROGRAM_MAPPING.items()}
def load_premise(DATA_FILE_ROOT, DEVICE):
"""Load AccoMontage Search Space"""
print('Loading AccoMontage piano texture search space. This may take 1 or 2 minutes ...')
data = np.load(os.path.join(DATA_FILE_ROOT, 'phrase_data.npz'), allow_pickle=True)
melody = data['melody']
acc = data['acc']
chord = data['chord']
vel = data['velocity']
cc = data['cc']
acc_pool = {}
for LEN in tqdm(range(2, 13)):
(mel, acc_, chord_, vel_, cc_, song_reference) = find_by_length(melody, acc, chord, vel, cc, LEN)
acc_pool[LEN] = (mel, acc_, chord_, vel_, cc_, song_reference)
texture_filter = get_texture_filter(acc_pool)
edge_weights=np.load(os.path.join(DATA_FILE_ROOT, 'edge_weights.npz'), allow_pickle=True)
"""Load Q&A Prompt Search Space"""
print('loading orchestration prompt search space ...')
slakh_dir = os.path.join(DATA_FILE_ROOT, 'Slakh2100_inference_set')
dataset = Slakh2100_Pop909_Dataset(slakh_dir=slakh_dir, pop909_dir=None, debug_mode=False, split='validation', mode='train')
loader = DataLoader(dataset, batch_size=1, shuffle=True, collate_fn=lambda b:collate_fn(b, DEVICE))
REF = []
REF_PROG = []
REF_MIX = []
for (_, prog, function, _, _, _) in loader:
prog = prog[0, :]
REF.extend([batch for batch in function])
REF_PROG.extend([prog for _ in range(len(function))])
REF_MIX.append(torch.sum(function, dim=1))
REF_MIX = torch.cat(REF_MIX, dim=0)
"""Initialize orchestration model (Prior + Q&A)"""
print('Initialize model ...')
prior_model_path = os.path.join(DATA_FILE_ROOT, 'params_prior.pt')
QaA_model_path = os.path.join(DATA_FILE_ROOT, 'params_qa.pt')
orchestrator = Prior.init_inference_model(prior_model_path, QaA_model_path, DEVICE=DEVICE)
orchestrator.to(DEVICE)
orchestrator.eval()
piano_arranger = DisentangleVAE.init_model(torch.device('cuda')).cuda()
piano_arranger.load_state_dict(torch.load(os.path.join(DATA_FILE_ROOT, 'params_reharmonizer.pt')))
print('Finished.')
return piano_arranger, orchestrator, (acc_pool, edge_weights, texture_filter), (REF, REF_PROG, REF_MIX)
def read_lead_sheet(DEMO_ROOT, SONG_NAME, SEGMENTATION, NOTE_SHIFT, melody_track_ID=0):
melody_roll, chord_roll = cvt.leadsheet2matrix(os.path.join(DEMO_ROOT, SONG_NAME, 'lead sheet.mid'), melody_track_ID)
assert(len(melody_roll == len(chord_roll)))
if NOTE_SHIFT != 0:
melody_roll = melody_roll[int(NOTE_SHIFT*4):, :]
chord_roll = chord_roll[int(NOTE_SHIFT*4):, :]
if len(melody_roll) % 16 != 0:
pad_len = (len(melody_roll)//16+1)*16-len(melody_roll)
melody_roll = np.pad(melody_roll, ((0, pad_len), (0, 0)))
melody_roll[-pad_len:, -1] = 1
chord_roll = np.pad(chord_roll, ((0, pad_len), (0, 0)))
chord_roll[-pad_len:, 0] = -1
chord_roll[-pad_len:, -1] = -1
CHORD_TABLE = np.stack([cvt.expand_chord(chord) for chord in chord_roll[::4]], axis=0)
LEADSHEET = np.concatenate((melody_roll, chord_roll[:, 1: -1]), axis=-1) #T*142, quantized at 16th
query_phrases = split_phrases(SEGMENTATION) #[('A', 8, 0), ('A', 8, 8), ('B', 8, 16), ('B', 8, 24)]
midi_len = len(LEADSHEET)//16
anno_len = sum([item[1] for item in query_phrases])
if midi_len > anno_len:
LEADSHEET = LEADSHEET[: anno_len*16]
CHORD_TABLE = CHORD_TABLE[: anno_len*4]
print(f'Mismatch warning: Detect {midi_len} bars in the lead sheet (MIDI) and {anno_len} bars in the provided phrase annotation. The lead sheet is truncated to {anno_len} bars.')
elif midi_len < anno_len:
pad_len = (anno_len - midi_len)*16
LEADSHEET = np.pad(LEADSHEET, ((0, pad_len), (0, 0)))
LEADSHEET[-pad_len:, 129] = 1
CHORD_TABLE = np.pad(CHORD_TABLE, ((0, pad_len//4), (0, 0)))
CHORD_TABLE[-pad_len//4:, 11] = -1
CHORD_TABLE[-pad_len//4:, -1] = -1
print(f'Mismatch warning: Detect {midi_len} bars in the lead sheet (MIDI) and {anno_len} bars in the provided phrase annotation. The lead sheet is padded to {anno_len} bars.')
melody_queries = []
for item in query_phrases:
start_bar = item[-1]
length = item[-2]
segment = LEADSHEET[start_bar*16: (start_bar+length)*16]
melody_queries.append(segment) #melody queries: list of T16*142, segmented by phrases
return (LEADSHEET, CHORD_TABLE, melody_queries, query_phrases)
def piano_arrangement(pianoRoll, chord_table, melody_queries, query_phrases, acc_pool, edge_weights, texture_filter, piano_arranger, PREFILTER, tempo=100):
print('Phrasal Unit selection begins:\n\t', f'{len(query_phrases)} phrases in the lead sheet;\n\t', f'set note density filter: {PREFILTER}.')
phrase_indice, chord_shift = dp_search( melody_queries,
query_phrases,
acc_pool,
edge_weights,
texture_filter,
filter_id=PREFILTER)
path = phrase_indice[0]
shift = chord_shift[0]
print('Re-harmonization begins ...')
midi_recon, acc = re_harmonization(pianoRoll, chord_table, query_phrases, path, shift, acc_pool, model=piano_arranger, get_est=True, tempo=tempo)
acc = np.array([grid2pr(matrix) for matrix in acc])
print('Piano accompaiment generated!')
return midi_recon, acc
def prompt_sampling(acc_piano, REF, REF_PROG, REF_MIX, DEVICE='cuda:0'): | ref_mix = torch.from_numpy(compute_pr_feat(acc_piano[0:1])[-1]).to(DEVICE) | 9 | 2023-10-23 12:36:57+00:00 | 24k |
liuqidong07/MOELoRA-peft | src/MLoRA/peft/peft_model.py | [
{
"identifier": "PeftConfig",
"path": "src/MLoRA/peft/utils/config.py",
"snippet": "class PeftConfig(PeftConfigMixin):\n \"\"\"\n This is the base configuration class to store the configuration of a [`PeftModel`].\n\n Args:\n peft_type (Union[[`~peft.utils.config.PeftType`], `str`]): The... | import inspect
import os
import warnings
import torch
import torch.nn as nn
from contextlib import contextmanager
from accelerate import dispatch_model, infer_auto_device_map
from accelerate.hooks import AlignDevicesHook, add_hook_to_module, remove_hook_from_submodules
from accelerate.utils import get_balanced_memory
from huggingface_hub import hf_hub_download
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss
from transformers import PreTrainedModel
from transformers.modeling_outputs import SequenceClassifierOutput, TokenClassifierOutput
from transformers.utils import PushToHubMixin
from .utils import PeftConfig
from .shared import Gate, GateN
from .tuners import (
AdaLoraModel,
AdaptionPromptModel,
LoraModel,
PrefixEncoder,
PromptEmbedding,
PromptEncoder,
MMOELoraModelS,
)
from .utils import (
TRANSFORMERS_MODELS_TO_PREFIX_TUNING_POSTPROCESS_MAPPING,
WEIGHTS_NAME,
PeftConfig,
PeftType,
PromptLearningConfig,
TaskType,
_set_adapter,
_set_trainable,
get_peft_model_state_dict,
set_peft_model_state_dict,
shift_tokens_right,
)
from .mapping import MODEL_TYPE_TO_PEFT_MODEL_MAPPING, PEFT_TYPE_TO_CONFIG_MAPPING
from .mapping import PEFT_TYPE_TO_CONFIG_MAPPING | 14,482 | # coding=utf-8
# Copyright 2023-present the HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
PEFT_TYPE_TO_MODEL_MAPPING = {
PeftType.LORA: LoraModel,
PeftType.PROMPT_TUNING: PromptEmbedding,
PeftType.P_TUNING: PromptEncoder,
PeftType.PREFIX_TUNING: PrefixEncoder,
| # coding=utf-8
# Copyright 2023-present the HuggingFace Inc. team.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
PEFT_TYPE_TO_MODEL_MAPPING = {
PeftType.LORA: LoraModel,
PeftType.PROMPT_TUNING: PromptEmbedding,
PeftType.P_TUNING: PromptEncoder,
PeftType.PREFIX_TUNING: PrefixEncoder, | PeftType.ADALORA: AdaLoraModel, | 5 | 2023-10-19 10:55:50+00:00 | 24k |
YuroFR/freqtrade-modded-crypto-trading-bot | tests/test_integration.py | [
{
"identifier": "ExitCheckTuple",
"path": "freqtrade/enums/exitchecktuple.py",
"snippet": "class ExitCheckTuple:\n \"\"\"\n NamedTuple for Exit type + reason\n \"\"\"\n exit_type: ExitType\n exit_reason: str = ''\n\n def __init__(self, exit_type: ExitType, exit_reason: str = ''):\n ... | from unittest.mock import MagicMock
from sqlalchemy import select
from freqtrade.enums import ExitCheckTuple, ExitType, TradingMode
from freqtrade.persistence import Trade
from freqtrade.persistence.models import Order
from freqtrade.rpc.rpc import RPC
from tests.conftest import EXMS, get_patched_freqtradebot, log_has_re, patch_get_signal
import pytest | 19,516 |
def test_may_execute_exit_stoploss_on_exchange_multi(default_conf, ticker, fee,
limit_buy_order, mocker) -> None:
"""
Tests workflow of selling stoploss_on_exchange.
Sells
* first trade as stoploss
* 2nd trade is kept
* 3rd trade is sold via sell-signal
"""
default_conf['max_open_trades'] = 3
default_conf['exchange']['name'] = 'binance'
stoploss = {
'id': 123,
'info': {}
}
stoploss_order_open = {
"id": "123",
"timestamp": 1542707426845,
"datetime": "2018-11-20T09:50:26.845Z",
"lastTradeTimestamp": None,
"symbol": "BTC/USDT",
"type": "stop_loss_limit",
"side": "sell",
"price": 1.08801,
"amount": 91.07468123,
"cost": 0.0,
"average": 0.0,
"filled": 0.0,
"remaining": 0.0,
"status": "open",
"fee": None,
"trades": None
}
stoploss_order_closed = stoploss_order_open.copy()
stoploss_order_closed['status'] = 'closed'
stoploss_order_closed['filled'] = stoploss_order_closed['amount']
# Sell first trade based on stoploss, keep 2nd and 3rd trade open
stop_orders = [stoploss_order_closed, stoploss_order_open, stoploss_order_open]
stoploss_order_mock = MagicMock(
side_effect=stop_orders)
# Sell 3rd trade (not called for the first trade)
should_sell_mock = MagicMock(side_effect=[
[],
[ExitCheckTuple(exit_type=ExitType.EXIT_SIGNAL)]]
)
cancel_order_mock = MagicMock()
mocker.patch.multiple(
EXMS,
create_stoploss=stoploss,
fetch_ticker=ticker,
get_fee=fee,
amount_to_precision=lambda s, x, y: y,
price_to_precision=lambda s, x, y: y,
fetch_stoploss_order=stoploss_order_mock,
cancel_stoploss_order_with_result=cancel_order_mock,
)
mocker.patch.multiple(
'freqtrade.freqtradebot.FreqtradeBot',
create_stoploss_order=MagicMock(return_value=True),
_notify_exit=MagicMock(),
)
mocker.patch("freqtrade.strategy.interface.IStrategy.should_exit", should_sell_mock)
wallets_mock = mocker.patch("freqtrade.wallets.Wallets.update")
mocker.patch("freqtrade.wallets.Wallets.get_free", return_value=1000)
mocker.patch("freqtrade.wallets.Wallets.check_exit_amount", return_value=True)
|
def test_may_execute_exit_stoploss_on_exchange_multi(default_conf, ticker, fee,
limit_buy_order, mocker) -> None:
"""
Tests workflow of selling stoploss_on_exchange.
Sells
* first trade as stoploss
* 2nd trade is kept
* 3rd trade is sold via sell-signal
"""
default_conf['max_open_trades'] = 3
default_conf['exchange']['name'] = 'binance'
stoploss = {
'id': 123,
'info': {}
}
stoploss_order_open = {
"id": "123",
"timestamp": 1542707426845,
"datetime": "2018-11-20T09:50:26.845Z",
"lastTradeTimestamp": None,
"symbol": "BTC/USDT",
"type": "stop_loss_limit",
"side": "sell",
"price": 1.08801,
"amount": 91.07468123,
"cost": 0.0,
"average": 0.0,
"filled": 0.0,
"remaining": 0.0,
"status": "open",
"fee": None,
"trades": None
}
stoploss_order_closed = stoploss_order_open.copy()
stoploss_order_closed['status'] = 'closed'
stoploss_order_closed['filled'] = stoploss_order_closed['amount']
# Sell first trade based on stoploss, keep 2nd and 3rd trade open
stop_orders = [stoploss_order_closed, stoploss_order_open, stoploss_order_open]
stoploss_order_mock = MagicMock(
side_effect=stop_orders)
# Sell 3rd trade (not called for the first trade)
should_sell_mock = MagicMock(side_effect=[
[],
[ExitCheckTuple(exit_type=ExitType.EXIT_SIGNAL)]]
)
cancel_order_mock = MagicMock()
mocker.patch.multiple(
EXMS,
create_stoploss=stoploss,
fetch_ticker=ticker,
get_fee=fee,
amount_to_precision=lambda s, x, y: y,
price_to_precision=lambda s, x, y: y,
fetch_stoploss_order=stoploss_order_mock,
cancel_stoploss_order_with_result=cancel_order_mock,
)
mocker.patch.multiple(
'freqtrade.freqtradebot.FreqtradeBot',
create_stoploss_order=MagicMock(return_value=True),
_notify_exit=MagicMock(),
)
mocker.patch("freqtrade.strategy.interface.IStrategy.should_exit", should_sell_mock)
wallets_mock = mocker.patch("freqtrade.wallets.Wallets.update")
mocker.patch("freqtrade.wallets.Wallets.get_free", return_value=1000)
mocker.patch("freqtrade.wallets.Wallets.check_exit_amount", return_value=True)
| freqtrade = get_patched_freqtradebot(mocker, default_conf) | 7 | 2023-10-21 10:02:05+00:00 | 24k |
yanzhh/HGERE | transformers/src/transformers/modeling_bert.py | [
{
"identifier": "gelu",
"path": "transformers/src/transformers/activations.py",
"snippet": "def swish(x):\ndef _gelu_python(x):\ndef gelu_new(x):\ndef get_activation(activation_string):\nACT2FN = {\n \"relu\": F.relu,\n \"swish\": swish,\n \"gelu\": gelu,\n \"tanh\": F.tanh,\n \"gelu_new\... | import logging
import math
import os
import torch
import torch.nn.functional as F
import pdb
import re
import numpy as np
import tensorflow as tf
import pdb
from symbol import factor
from tkinter import E
from torch import nn
from torch.nn import CrossEntropyLoss, MSELoss, BCEWithLogitsLoss
from torch.nn.utils.rnn import pad_sequence
from .modules import *
from .activations import gelu, gelu_new, swish
from .configuration_bert import BertConfig
from .file_utils import add_start_docstrings, add_start_docstrings_to_callable
from .modeling_utils import PreTrainedModel, prune_linear_layer | 16,669 | self.decoder.bias = self.bias
def forward(self, hidden_states):
hidden_states = self.transform(hidden_states)
hidden_states = self.decoder(hidden_states)
return hidden_states
class BertOnlyMLMHead(nn.Module):
def __init__(self, config):
super().__init__()
self.predictions = BertLMPredictionHead(config)
def forward(self, sequence_output):
prediction_scores = self.predictions(sequence_output)
return prediction_scores
class BertOnlyNSPHead(nn.Module):
def __init__(self, config):
super().__init__()
self.seq_relationship = nn.Linear(config.hidden_size, 2)
def forward(self, pooled_output):
seq_relationship_score = self.seq_relationship(pooled_output)
return seq_relationship_score
class BertPreTrainingHeads(nn.Module):
def __init__(self, config):
super().__init__()
self.predictions = BertLMPredictionHead(config)
self.seq_relationship = nn.Linear(config.hidden_size, 2)
def forward(self, sequence_output, pooled_output):
prediction_scores = self.predictions(sequence_output)
seq_relationship_score = self.seq_relationship(pooled_output)
return prediction_scores, seq_relationship_score
class BertPreTrainedModel(PreTrainedModel):
""" An abstract class to handle weights initialization and
a simple interface for downloading and loading pretrained models.
"""
config_class = BertConfig
pretrained_model_archive_map = BERT_PRETRAINED_MODEL_ARCHIVE_MAP
load_tf_weights = load_tf_weights_in_bert
base_model_prefix = "bert"
def _init_weights(self, module):
""" Initialize the weights """
if isinstance(module, (nn.Linear, nn.Embedding)):
# Slightly different from the TF version which uses truncated_normal for initialization
# cf https://github.com/pytorch/pytorch/pull/5617
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
elif isinstance(module, BertLayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
BERT_START_DOCSTRING = r"""
This model is a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`_ sub-class.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general
usage and behavior.
Parameters:
config (:class:`~transformers.BertConfig`): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the configuration.
Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
"""
BERT_INPUTS_DOCSTRING = r"""
Args:
input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`):
Indices of input sequence tokens in the vocabulary.
Indices can be obtained using :class:`transformers.BertTokenizer`.
See :func:`transformers.PreTrainedTokenizer.encode` and
:func:`transformers.PreTrainedTokenizer.encode_plus` for details.
`What are input IDs? <../glossary.html#input-ids>`__
attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Mask to avoid performing attention on padding token indices.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
`What are attention masks? <../glossary.html#attention-mask>`__
token_type_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Segment token indices to indicate first and second portions of the inputs.
Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
corresponds to a `sentence B` token
`What are token type IDs? <../glossary.html#token-type-ids>`_
position_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Indices of positions of each input sequence tokens in the position embeddings.
Selected in the range ``[0, config.max_position_embeddings - 1]``.
`What are position IDs? <../glossary.html#position-ids>`_
head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`):
Mask to nullify selected heads of the self-attention modules.
Mask values selected in ``[0, 1]``:
:obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
This is useful if you want more control over how to convert `input_ids` indices into associated vectors
than the model's internal embedding lookup matrix.
encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
if the model is configured as a decoder.
encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Mask to avoid performing attention on the padding token indices of the encoder input. This mask
is used in the cross-attention if the model is configured as a decoder.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
"""
| # coding=utf-8
# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
# Copyright (c) 2018, NVIDIA CORPORATION. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""PyTorch BERT model. """
# from .modules import BiaffineSpanRepr, BiaffineRelationCls, BiafEncoder, \
# CatEncoder, max_pool, Tetrafine, BiaffineMessagePasser, \
# LinearMessegePasser, CPDTrilinear, CatEncoderCross, \
# bilinear_classifier, BiafCrossEncoder
logger = logging.getLogger(__name__)
BERT_PRETRAINED_MODEL_ARCHIVE_MAP = {
"bert-base-uncased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-pytorch_model.bin",
"bert-large-uncased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-uncased-pytorch_model.bin",
"bert-base-cased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-cased-pytorch_model.bin",
"bert-large-cased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-cased-pytorch_model.bin",
"bert-base-multilingual-uncased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-multilingual-uncased-pytorch_model.bin",
"bert-base-multilingual-cased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-multilingual-cased-pytorch_model.bin",
"bert-base-chinese": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-chinese-pytorch_model.bin",
"bert-base-german-cased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-german-cased-pytorch_model.bin",
"bert-large-uncased-whole-word-masking": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-uncased-whole-word-masking-pytorch_model.bin",
"bert-large-cased-whole-word-masking": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-cased-whole-word-masking-pytorch_model.bin",
"bert-large-uncased-whole-word-masking-finetuned-squad": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-uncased-whole-word-masking-finetuned-squad-pytorch_model.bin",
"bert-large-cased-whole-word-masking-finetuned-squad": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-large-cased-whole-word-masking-finetuned-squad-pytorch_model.bin",
"bert-base-cased-finetuned-mrpc": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-cased-finetuned-mrpc-pytorch_model.bin",
"bert-base-german-dbmdz-cased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-german-dbmdz-cased-pytorch_model.bin",
"bert-base-german-dbmdz-uncased": "https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-german-dbmdz-uncased-pytorch_model.bin",
"bert-base-japanese": "https://s3.amazonaws.com/models.huggingface.co/bert/cl-tohoku/bert-base-japanese-pytorch_model.bin",
"bert-base-japanese-whole-word-masking": "https://s3.amazonaws.com/models.huggingface.co/bert/cl-tohoku/bert-base-japanese-whole-word-masking-pytorch_model.bin",
"bert-base-japanese-char": "https://s3.amazonaws.com/models.huggingface.co/bert/cl-tohoku/bert-base-japanese-char-pytorch_model.bin",
"bert-base-japanese-char-whole-word-masking": "https://s3.amazonaws.com/models.huggingface.co/bert/cl-tohoku/bert-base-japanese-char-whole-word-masking-pytorch_model.bin",
"bert-base-finnish-cased-v1": "https://s3.amazonaws.com/models.huggingface.co/bert/TurkuNLP/bert-base-finnish-cased-v1/pytorch_model.bin",
"bert-base-finnish-uncased-v1": "https://s3.amazonaws.com/models.huggingface.co/bert/TurkuNLP/bert-base-finnish-uncased-v1/pytorch_model.bin",
"bert-base-dutch-cased": "https://s3.amazonaws.com/models.huggingface.co/bert/wietsedv/bert-base-dutch-cased/pytorch_model.bin",
}
def load_tf_weights_in_bert(model, config, tf_checkpoint_path):
""" Load tf checkpoints in a pytorch model.
"""
try:
except ImportError:
logger.error(
"Loading a TensorFlow model in PyTorch, requires TensorFlow to be installed. Please see "
"https://www.tensorflow.org/install/ for installation instructions."
)
raise
tf_path = os.path.abspath(tf_checkpoint_path)
logger.info("Converting TensorFlow checkpoint from {}".format(tf_path))
# Load weights from TF model
init_vars = tf.train.list_variables(tf_path)
names = []
arrays = []
for name, shape in init_vars:
logger.info("Loading TF weight {} with shape {}".format(name, shape))
array = tf.train.load_variable(tf_path, name)
names.append(name)
arrays.append(array)
for name, array in zip(names, arrays):
name = name.split("/")
# adam_v and adam_m are variables used in AdamWeightDecayOptimizer to calculated m and v
# which are not required for using pretrained model
if any(
n in ["adam_v", "adam_m", "AdamWeightDecayOptimizer", "AdamWeightDecayOptimizer_1", "global_step"]
for n in name
):
logger.info("Skipping {}".format("/".join(name)))
continue
pointer = model
for m_name in name:
if re.fullmatch(r"[A-Za-z]+_\d+", m_name):
scope_names = re.split(r"_(\d+)", m_name)
else:
scope_names = [m_name]
if scope_names[0] == "kernel" or scope_names[0] == "gamma":
pointer = getattr(pointer, "weight")
elif scope_names[0] == "output_bias" or scope_names[0] == "beta":
pointer = getattr(pointer, "bias")
elif scope_names[0] == "output_weights":
pointer = getattr(pointer, "weight")
elif scope_names[0] == "squad":
pointer = getattr(pointer, "classifier")
else:
try:
pointer = getattr(pointer, scope_names[0])
except AttributeError:
logger.info("Skipping {}".format("/".join(name)))
continue
if len(scope_names) >= 2:
num = int(scope_names[1])
pointer = pointer[num]
if m_name[-11:] == "_embeddings":
pointer = getattr(pointer, "weight")
elif m_name == "kernel":
array = np.transpose(array)
try:
assert pointer.shape == array.shape
except AssertionError as e:
e.args += (pointer.shape, array.shape)
raise
logger.info("Initialize PyTorch weight {}".format(name))
pointer.data = torch.from_numpy(array)
return model
def mish(x):
return x * torch.tanh(nn.functional.softplus(x))
ACT2FN = {"gelu": gelu, "relu": torch.nn.functional.relu, "swish": swish, "gelu_new": gelu_new, "mish": mish}
BertLayerNorm = torch.nn.LayerNorm
class BertEmbeddings(nn.Module):
"""Construct the embeddings from word, position and token_type embeddings.
"""
def __init__(self, config):
super().__init__()
self.word_embeddings = nn.Embedding(config.vocab_size, config.hidden_size, padding_idx=0)
self.position_embeddings = nn.Embedding(config.max_position_embeddings, config.hidden_size)
self.token_type_embeddings = nn.Embedding(config.type_vocab_size, config.hidden_size)
# self.LayerNorm is not snake-cased to stick with TensorFlow model variable name and be able to load
# any TensorFlow checkpoint file
self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
def forward(self, input_ids=None, token_type_ids=None, position_ids=None, inputs_embeds=None):
if input_ids is not None:
input_shape = input_ids.size()
else:
input_shape = inputs_embeds.size()[:-1]
seq_length = input_shape[1]
device = input_ids.device if input_ids is not None else inputs_embeds.device
if position_ids is None:
position_ids = torch.arange(seq_length, dtype=torch.long, device=device)
position_ids = position_ids.unsqueeze(0).expand(input_shape)
if token_type_ids is None:
token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
if inputs_embeds is None:
inputs_embeds = self.word_embeddings(input_ids)
position_embeddings = self.position_embeddings(position_ids)
token_type_embeddings = self.token_type_embeddings(token_type_ids)
embeddings = inputs_embeds + position_embeddings + token_type_embeddings
embeddings = self.LayerNorm(embeddings)
embeddings = self.dropout(embeddings)
return embeddings
class BertSelfAttention(nn.Module):
def __init__(self, config):
super().__init__()
if config.hidden_size % config.num_attention_heads != 0:
raise ValueError(
"The hidden size (%d) is not a multiple of the number of attention "
"heads (%d)" % (config.hidden_size, config.num_attention_heads)
)
self.output_attentions = config.output_attentions
self.num_attention_heads = config.num_attention_heads
self.attention_head_size = int(config.hidden_size / config.num_attention_heads)
self.all_head_size = self.num_attention_heads * self.attention_head_size
self.query = nn.Linear(config.hidden_size, self.all_head_size)
self.key = nn.Linear(config.hidden_size, self.all_head_size)
self.value = nn.Linear(config.hidden_size, self.all_head_size)
self.dropout = nn.Dropout(config.attention_probs_dropout_prob)
def transpose_for_scores(self, x):
new_x_shape = x.size()[:-1] + (self.num_attention_heads, self.attention_head_size)
x = x.view(*new_x_shape)
return x.permute(0, 2, 1, 3)
def forward(
self,
hidden_states,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
):
mixed_query_layer = self.query(hidden_states)
# If this is instantiated as a cross-attention module, the keys
# and values come from an encoder; the attention mask needs to be
# such that the encoder's padding tokens are not attended to.
if encoder_hidden_states is not None:
mixed_key_layer = self.key(encoder_hidden_states)
mixed_value_layer = self.value(encoder_hidden_states)
attention_mask = encoder_attention_mask
else:
mixed_key_layer = self.key(hidden_states)
mixed_value_layer = self.value(hidden_states)
query_layer = self.transpose_for_scores(mixed_query_layer)
key_layer = self.transpose_for_scores(mixed_key_layer)
value_layer = self.transpose_for_scores(mixed_value_layer)
# Take the dot product between "query" and "key" to get the raw attention scores.
attention_scores = torch.matmul(query_layer, key_layer.transpose(-1, -2))
attention_scores = attention_scores / math.sqrt(self.attention_head_size)
if attention_mask is not None:
# Apply the attention mask is (precomputed for all layers in BertModel forward() function)
attention_scores = attention_scores + attention_mask
# Normalize the attention scores to probabilities.
attention_probs = nn.Softmax(dim=-1)(attention_scores)
# This is actually dropping out entire tokens to attend to, which might
# seem a bit unusual, but is taken from the original Transformer paper.
attention_probs = self.dropout(attention_probs)
# Mask heads if we want to
if head_mask is not None:
attention_probs = attention_probs * head_mask
context_layer = torch.matmul(attention_probs, value_layer)
context_layer = context_layer.permute(0, 2, 1, 3).contiguous()
new_context_layer_shape = context_layer.size()[:-2] + (self.all_head_size,)
context_layer = context_layer.view(*new_context_layer_shape)
outputs = (context_layer, attention_probs) if self.output_attentions else (context_layer,)
return outputs
class BertSelfOutput(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
def forward(self, hidden_states, input_tensor):
hidden_states = self.dense(hidden_states)
hidden_states = self.dropout(hidden_states)
hidden_states = self.LayerNorm(hidden_states + input_tensor)
return hidden_states
class BertAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.self = BertSelfAttention(config)
self.output = BertSelfOutput(config)
self.pruned_heads = set()
def prune_heads(self, heads):
if len(heads) == 0:
return
mask = torch.ones(self.self.num_attention_heads, self.self.attention_head_size)
heads = set(heads) - self.pruned_heads # Convert to set and remove already pruned heads
for head in heads:
# Compute how many pruned heads are before the head and move the index accordingly
head = head - sum(1 if h < head else 0 for h in self.pruned_heads)
mask[head] = 0
mask = mask.view(-1).contiguous().eq(1)
index = torch.arange(len(mask))[mask].long()
# Prune linear layers
self.self.query = prune_linear_layer(self.self.query, index)
self.self.key = prune_linear_layer(self.self.key, index)
self.self.value = prune_linear_layer(self.self.value, index)
self.output.dense = prune_linear_layer(self.output.dense, index, dim=1)
# Update hyper params and store pruned heads
self.self.num_attention_heads = self.self.num_attention_heads - len(heads)
self.self.all_head_size = self.self.attention_head_size * self.self.num_attention_heads
self.pruned_heads = self.pruned_heads.union(heads)
def forward(
self,
hidden_states,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
):
self_outputs = self.self(
hidden_states, attention_mask, head_mask, encoder_hidden_states, encoder_attention_mask
)
attention_output = self.output(self_outputs[0], hidden_states)
outputs = (attention_output,) + self_outputs[1:] # add attentions if we output them
return outputs
class BertIntermediate(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.intermediate_size)
if isinstance(config.hidden_act, str):
self.intermediate_act_fn = ACT2FN[config.hidden_act]
else:
self.intermediate_act_fn = config.hidden_act
def forward(self, hidden_states):
hidden_states = self.dense(hidden_states)
hidden_states = self.intermediate_act_fn(hidden_states)
return hidden_states
class BertOutput(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.intermediate_size, config.hidden_size)
self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
self.dropout = nn.Dropout(config.hidden_dropout_prob)
def forward(self, hidden_states, input_tensor):
hidden_states = self.dense(hidden_states)
hidden_states = self.dropout(hidden_states)
hidden_states = self.LayerNorm(hidden_states + input_tensor)
return hidden_states
class BertLayer(nn.Module):
def __init__(self, config):
super().__init__()
self.attention = BertAttention(config)
self.is_decoder = config.is_decoder
if self.is_decoder:
self.crossattention = BertAttention(config)
self.intermediate = BertIntermediate(config)
self.output = BertOutput(config)
def forward(
self,
hidden_states,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
):
self_attention_outputs = self.attention(hidden_states, attention_mask, head_mask)
attention_output = self_attention_outputs[0]
outputs = self_attention_outputs[1:] # add self attentions if we output attention weights
if self.is_decoder and encoder_hidden_states is not None:
cross_attention_outputs = self.crossattention(
attention_output, attention_mask, head_mask, encoder_hidden_states, encoder_attention_mask
)
attention_output = cross_attention_outputs[0]
outputs = outputs + cross_attention_outputs[1:] # add cross attentions if we output attention weights
intermediate_output = self.intermediate(attention_output)
layer_output = self.output(intermediate_output, attention_output)
outputs = (layer_output,) + outputs
return outputs
class BertEncoder(nn.Module):
def __init__(self, config):
super().__init__()
self.output_attentions = config.output_attentions
self.output_hidden_states = config.output_hidden_states
self.layer = nn.ModuleList([BertLayer(config) for _ in range(config.num_hidden_layers)])
try:
self.use_full_layer = config.use_full_layer
except:
self.use_full_layer = -1
def forward(
self,
hidden_states,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
full_attention_mask=None,
):
all_hidden_states = ()
all_attentions = ()
for i, layer_module in enumerate(self.layer):
if i==self.use_full_layer:
attention_mask = full_attention_mask
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
layer_outputs = layer_module(
hidden_states, attention_mask, head_mask[i], encoder_hidden_states, encoder_attention_mask
)
hidden_states = layer_outputs[0]
if self.output_attentions:
all_attentions = all_attentions + (layer_outputs[1],)
# Add last layer
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
outputs = (hidden_states,)
if self.output_hidden_states:
outputs = outputs + (all_hidden_states,)
if self.output_attentions:
outputs = outputs + (all_attentions,)
return outputs # last-layer hidden state, (all hidden states), (all attentions)
class BertPooler(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.activation = nn.Tanh()
def forward(self, hidden_states):
# We "pool" the model by simply taking the hidden state corresponding
# to the first token.
first_token_tensor = hidden_states[:, 0]
pooled_output = self.dense(first_token_tensor)
pooled_output = self.activation(pooled_output)
return pooled_output
class BertPredictionHeadTransform(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
if isinstance(config.hidden_act, str):
self.transform_act_fn = ACT2FN[config.hidden_act]
else:
self.transform_act_fn = config.hidden_act
self.LayerNorm = BertLayerNorm(config.hidden_size, eps=config.layer_norm_eps)
def forward(self, hidden_states):
hidden_states = self.dense(hidden_states)
hidden_states = self.transform_act_fn(hidden_states)
hidden_states = self.LayerNorm(hidden_states)
return hidden_states
class BertLMPredictionHead(nn.Module):
def __init__(self, config):
super().__init__()
self.transform = BertPredictionHeadTransform(config)
# The output weights are the same as the input embeddings, but there is
# an output-only bias for each token.
self.decoder = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
self.bias = nn.Parameter(torch.zeros(config.vocab_size))
# Need a link between the two variables so that the bias is correctly resized with `resize_token_embeddings`
self.decoder.bias = self.bias
def forward(self, hidden_states):
hidden_states = self.transform(hidden_states)
hidden_states = self.decoder(hidden_states)
return hidden_states
class BertOnlyMLMHead(nn.Module):
def __init__(self, config):
super().__init__()
self.predictions = BertLMPredictionHead(config)
def forward(self, sequence_output):
prediction_scores = self.predictions(sequence_output)
return prediction_scores
class BertOnlyNSPHead(nn.Module):
def __init__(self, config):
super().__init__()
self.seq_relationship = nn.Linear(config.hidden_size, 2)
def forward(self, pooled_output):
seq_relationship_score = self.seq_relationship(pooled_output)
return seq_relationship_score
class BertPreTrainingHeads(nn.Module):
def __init__(self, config):
super().__init__()
self.predictions = BertLMPredictionHead(config)
self.seq_relationship = nn.Linear(config.hidden_size, 2)
def forward(self, sequence_output, pooled_output):
prediction_scores = self.predictions(sequence_output)
seq_relationship_score = self.seq_relationship(pooled_output)
return prediction_scores, seq_relationship_score
class BertPreTrainedModel(PreTrainedModel):
""" An abstract class to handle weights initialization and
a simple interface for downloading and loading pretrained models.
"""
config_class = BertConfig
pretrained_model_archive_map = BERT_PRETRAINED_MODEL_ARCHIVE_MAP
load_tf_weights = load_tf_weights_in_bert
base_model_prefix = "bert"
def _init_weights(self, module):
""" Initialize the weights """
if isinstance(module, (nn.Linear, nn.Embedding)):
# Slightly different from the TF version which uses truncated_normal for initialization
# cf https://github.com/pytorch/pytorch/pull/5617
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
elif isinstance(module, BertLayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
BERT_START_DOCSTRING = r"""
This model is a PyTorch `torch.nn.Module <https://pytorch.org/docs/stable/nn.html#torch.nn.Module>`_ sub-class.
Use it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general
usage and behavior.
Parameters:
config (:class:`~transformers.BertConfig`): Model configuration class with all the parameters of the model.
Initializing with a config file does not load the weights associated with the model, only the configuration.
Check out the :meth:`~transformers.PreTrainedModel.from_pretrained` method to load the model weights.
"""
BERT_INPUTS_DOCSTRING = r"""
Args:
input_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`):
Indices of input sequence tokens in the vocabulary.
Indices can be obtained using :class:`transformers.BertTokenizer`.
See :func:`transformers.PreTrainedTokenizer.encode` and
:func:`transformers.PreTrainedTokenizer.encode_plus` for details.
`What are input IDs? <../glossary.html#input-ids>`__
attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Mask to avoid performing attention on padding token indices.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
`What are attention masks? <../glossary.html#attention-mask>`__
token_type_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Segment token indices to indicate first and second portions of the inputs.
Indices are selected in ``[0, 1]``: ``0`` corresponds to a `sentence A` token, ``1``
corresponds to a `sentence B` token
`What are token type IDs? <../glossary.html#token-type-ids>`_
position_ids (:obj:`torch.LongTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Indices of positions of each input sequence tokens in the position embeddings.
Selected in the range ``[0, config.max_position_embeddings - 1]``.
`What are position IDs? <../glossary.html#position-ids>`_
head_mask (:obj:`torch.FloatTensor` of shape :obj:`(num_heads,)` or :obj:`(num_layers, num_heads)`, `optional`, defaults to :obj:`None`):
Mask to nullify selected heads of the self-attention modules.
Mask values selected in ``[0, 1]``:
:obj:`1` indicates the head is **not masked**, :obj:`0` indicates the head is **masked**.
inputs_embeds (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
Optionally, instead of passing :obj:`input_ids` you can choose to directly pass an embedded representation.
This is useful if you want more control over how to convert `input_ids` indices into associated vectors
than the model's internal embedding lookup matrix.
encoder_hidden_states (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length, hidden_size)`, `optional`, defaults to :obj:`None`):
Sequence of hidden-states at the output of the last layer of the encoder. Used in the cross-attention
if the model is configured as a decoder.
encoder_attention_mask (:obj:`torch.FloatTensor` of shape :obj:`(batch_size, sequence_length)`, `optional`, defaults to :obj:`None`):
Mask to avoid performing attention on the padding token indices of the encoder input. This mask
is used in the cross-attention if the model is configured as a decoder.
Mask values selected in ``[0, 1]``:
``1`` for tokens that are NOT MASKED, ``0`` for MASKED tokens.
"""
| @add_start_docstrings( | 2 | 2023-10-15 02:31:09+00:00 | 24k |
akashgreninja/GreSec | backend/venv/lib/python3.10/site-packages/urllib3/connectionpool.py | [
{
"identifier": "_TYPE_BODY",
"path": "backend/venv/lib/python3.10/site-packages/urllib3/_base_connection.py",
"snippet": "_TYPE_BODY = typing.Union[bytes, typing.IO[typing.Any], typing.Iterable[bytes], str]"
},
{
"identifier": "HTTPHeaderDict",
"path": "backend/venv/lib/python3.10/site-pack... | import errno
import logging
import queue
import sys
import typing
import warnings
import weakref
import ssl
from socket import timeout as SocketTimeout
from types import TracebackType
from ._base_connection import _TYPE_BODY
from ._collections import HTTPHeaderDict
from ._request_methods import RequestMethods
from .connection import (
BaseSSLError,
BrokenPipeError,
DummyConnection,
HTTPConnection,
HTTPException,
HTTPSConnection,
ProxyConfig,
_wrap_proxy_error,
)
from .connection import port_by_scheme as port_by_scheme
from .exceptions import (
ClosedPoolError,
EmptyPoolError,
FullPoolError,
HostChangedError,
InsecureRequestWarning,
LocationValueError,
MaxRetryError,
NewConnectionError,
ProtocolError,
ProxyError,
ReadTimeoutError,
SSLError,
TimeoutError,
)
from .response import BaseHTTPResponse
from .util.connection import is_connection_dropped
from .util.proxy import connection_requires_http_tunnel
from .util.request import _TYPE_BODY_POSITION, set_file_position
from .util.retry import Retry
from .util.ssl_match_hostname import CertificateError
from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_DEFAULT, Timeout
from .util.url import Url, _encode_target
from .util.url import _normalize_host as normalize_host
from .util.url import parse_url
from .util.util import to_str
from typing_extensions import Literal
from ._base_connection import BaseHTTPConnection, BaseHTTPSConnection | 21,573 | # Pool objects
class ConnectionPool:
"""
Base class for all connection pools, such as
:class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
.. note::
ConnectionPool.urlopen() does not normalize or percent-encode target URIs
which is useful if your target server doesn't support percent-encoded
target URIs.
"""
scheme: str | None = None
QueueCls = queue.LifoQueue
def __init__(self, host: str, port: int | None = None) -> None:
if not host:
raise LocationValueError("No host specified.")
self.host = _normalize_host(host, scheme=self.scheme)
self.port = port
# This property uses 'normalize_host()' (not '_normalize_host()')
# to avoid removing square braces around IPv6 addresses.
# This value is sent to `HTTPConnection.set_tunnel()` if called
# because square braces are required for HTTP CONNECT tunneling.
self._tunnel_host = normalize_host(host, scheme=self.scheme).lower()
def __str__(self) -> str:
return f"{type(self).__name__}(host={self.host!r}, port={self.port!r})"
def __enter__(self: _SelfT) -> _SelfT:
return self
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> Literal[False]:
self.close()
# Return False to re-raise any potential exceptions
return False
def close(self) -> None:
"""
Close all pooled connections and disable the pool.
"""
# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252
_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}
class HTTPConnectionPool(ConnectionPool, RequestMethods):
"""
Thread-safe connection pool for one host.
:param host:
Host used for this HTTP Connection (e.g. "localhost"), passed into
:class:`http.client.HTTPConnection`.
:param port:
Port used for this HTTP Connection (None is equivalent to 80), passed
into :class:`http.client.HTTPConnection`.
:param timeout:
Socket timeout in seconds for each individual connection. This can
be a float or integer, which sets the timeout for the HTTP request,
or an instance of :class:`urllib3.util.Timeout` which gives you more
fine-grained control over request timeouts. After the constructor has
been parsed, this is always a `urllib3.util.Timeout` object.
:param maxsize:
Number of connections to save that can be reused. More than 1 is useful
in multithreaded situations. If ``block`` is set to False, more
connections will be created but they will not be saved once they've
been used.
:param block:
If set to True, no more than ``maxsize`` connections will be used at
a time. When no free connections are available, the call will block
until a connection has been released. This is a useful side effect for
particular multithreaded situations where one does not want to use more
than maxsize connections per host to prevent flooding.
:param headers:
Headers to include with all requests, unless other headers are given
explicitly.
:param retries:
Retry configuration to use by default with requests in this pool.
:param _proxy:
Parsed proxy URL, should not be used directly, instead, see
:class:`urllib3.ProxyManager`
:param _proxy_headers:
A dictionary with proxy headers, should not be used directly,
instead, see :class:`urllib3.ProxyManager`
:param \\**conn_kw:
Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`,
:class:`urllib3.connection.HTTPSConnection` instances.
"""
scheme = "http"
ConnectionCls: (
type[BaseHTTPConnection] | type[BaseHTTPSConnection]
) = HTTPConnection
def __init__(
self,
host: str,
port: int | None = None,
timeout: _TYPE_TIMEOUT | None = _DEFAULT_TIMEOUT,
maxsize: int = 1,
block: bool = False,
headers: typing.Mapping[str, str] | None = None,
retries: Retry | bool | int | None = None,
| from __future__ import annotations
if typing.TYPE_CHECKING:
log = logging.getLogger(__name__)
_TYPE_TIMEOUT = typing.Union[Timeout, float, _TYPE_DEFAULT, None]
_SelfT = typing.TypeVar("_SelfT")
# Pool objects
class ConnectionPool:
"""
Base class for all connection pools, such as
:class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`.
.. note::
ConnectionPool.urlopen() does not normalize or percent-encode target URIs
which is useful if your target server doesn't support percent-encoded
target URIs.
"""
scheme: str | None = None
QueueCls = queue.LifoQueue
def __init__(self, host: str, port: int | None = None) -> None:
if not host:
raise LocationValueError("No host specified.")
self.host = _normalize_host(host, scheme=self.scheme)
self.port = port
# This property uses 'normalize_host()' (not '_normalize_host()')
# to avoid removing square braces around IPv6 addresses.
# This value is sent to `HTTPConnection.set_tunnel()` if called
# because square braces are required for HTTP CONNECT tunneling.
self._tunnel_host = normalize_host(host, scheme=self.scheme).lower()
def __str__(self) -> str:
return f"{type(self).__name__}(host={self.host!r}, port={self.port!r})"
def __enter__(self: _SelfT) -> _SelfT:
return self
def __exit__(
self,
exc_type: type[BaseException] | None,
exc_val: BaseException | None,
exc_tb: TracebackType | None,
) -> Literal[False]:
self.close()
# Return False to re-raise any potential exceptions
return False
def close(self) -> None:
"""
Close all pooled connections and disable the pool.
"""
# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252
_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK}
class HTTPConnectionPool(ConnectionPool, RequestMethods):
"""
Thread-safe connection pool for one host.
:param host:
Host used for this HTTP Connection (e.g. "localhost"), passed into
:class:`http.client.HTTPConnection`.
:param port:
Port used for this HTTP Connection (None is equivalent to 80), passed
into :class:`http.client.HTTPConnection`.
:param timeout:
Socket timeout in seconds for each individual connection. This can
be a float or integer, which sets the timeout for the HTTP request,
or an instance of :class:`urllib3.util.Timeout` which gives you more
fine-grained control over request timeouts. After the constructor has
been parsed, this is always a `urllib3.util.Timeout` object.
:param maxsize:
Number of connections to save that can be reused. More than 1 is useful
in multithreaded situations. If ``block`` is set to False, more
connections will be created but they will not be saved once they've
been used.
:param block:
If set to True, no more than ``maxsize`` connections will be used at
a time. When no free connections are available, the call will block
until a connection has been released. This is a useful side effect for
particular multithreaded situations where one does not want to use more
than maxsize connections per host to prevent flooding.
:param headers:
Headers to include with all requests, unless other headers are given
explicitly.
:param retries:
Retry configuration to use by default with requests in this pool.
:param _proxy:
Parsed proxy URL, should not be used directly, instead, see
:class:`urllib3.ProxyManager`
:param _proxy_headers:
A dictionary with proxy headers, should not be used directly,
instead, see :class:`urllib3.ProxyManager`
:param \\**conn_kw:
Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`,
:class:`urllib3.connection.HTTPSConnection` instances.
"""
scheme = "http"
ConnectionCls: (
type[BaseHTTPConnection] | type[BaseHTTPSConnection]
) = HTTPConnection
def __init__(
self,
host: str,
port: int | None = None,
timeout: _TYPE_TIMEOUT | None = _DEFAULT_TIMEOUT,
maxsize: int = 1,
block: bool = False,
headers: typing.Mapping[str, str] | None = None,
retries: Retry | bool | int | None = None, | _proxy: Url | None = None, | 28 | 2023-10-23 18:09:28+00:00 | 24k |
zju3dv/nr_in_a_room | test/test_optim_pano.py | [
{
"identifier": "RoomOptimizer",
"path": "optim/room_optimizer.py",
"snippet": "class RoomOptimizer:\n def __init__(\n self,\n scale_factor: float,\n bg_scale_factor: float,\n bg_scene_center: list,\n img_wh: list,\n near: float,\n far: float,\n ... | import sys
import os
import torch
import numpy as np
from PIL import Image
from omegaconf import OmegaConf
from optim.room_optimizer import RoomOptimizer
from optim.misc_utils import (
read_real_scene_localization,
read_real_scene_localization_with_name,
read_testing_config,
) | 14,879 |
os.environ["OMP_NUM_THREADS"] = "1" # noqa
os.environ["MKL_NUM_THREADS"] = "1" # noqa
sys.path.append(".") # noqa
def main(config):
active_instance_id = config.active_instance_id
image_path = config.test_image_path
dataset_config = config.dataset_config["dataset"]
bg_scale_factor = 1
bg_scene_center = [0, 0, 0]
if config.bg_dataset_config != "":
bg_dataset_config = config.bg_dataset_config["dataset"]
bg_scale_factor = bg_dataset_config["scale_factor"]
bg_scene_center = bg_dataset_config["scene_center"]
img_wh = config.img_wh
# read image
input_rgb = Image.open(image_path)
input_rgb = input_rgb.resize(img_wh, Image.LANCZOS)
input_rgb = np.array(input_rgb)
input_rgb = torch.from_numpy(input_rgb).float() / 255 # (H, W, 3)
# intialize room optimizer
room_optimizer = RoomOptimizer(
scene_info_json_path=config.scene_info_json,
scale_factor=dataset_config["scale_factor"],
scale_factor_dict=dataset_config.get("scale_factor_dict", {}),
bg_scale_factor=bg_scale_factor,
bg_scene_center=bg_scene_center,
img_wh=config.img_wh,
near=0.3,
far=10.0,
N_samples=64,
N_importance=128,
chunk=config.chunk,
model_ckpt_path_dict=config.ckpt_path_dict,
# relation_info=relation_info,
relation_info={},
output_path="debug",
prefix=config.prefix,
active_instance_id=active_instance_id,
lr=1e-2,
# lr=5e-2,
N_optim_step=500,
adjust_lr_per_step=0,
optim_batch_size=1024,
# optim_batch_size=2048,
# optim_batch_size=4096,
# use_amp=False,
use_amp=True,
optimize_light_env=True,
optimize_appearance_code=config.get("optimize_appearance_code", False),
mask_per_object=False,
bbox_ray_intersect=True,
bbox_enlarge=0.1,
optimize_option=[
"keypoint_mask",
"photometric_loss",
# "perceptual_loss",
"z_axis_align_loss",
"object_room_wall_attach",
"object_room_floor_attach",
"physical_violation",
# "physical_violation_delayed_start",
"object_object_attach",
"viewing_constraint",
"optimize_exposure",
"regenerate_relation_during_test",
# "visualize_pred",
# "print_loss_dict",
],
)
# room_optimizer.set_sampling_mask_from_seg(
# seg_mask=None,
# seg_mask_path=config.seg_mask_path,
# # add_noise_to_seg=0,
# add_noise_to_seg=5, # dilate mask
# convert_seg_mask_to_box_mask=True,
# # convert_seg_mask_to_box_mask=False,
# )
room_optimizer.set_sampling_mask_from_seg(
# seg_mask=torch.ones_like(input_rgb[:, :, 0]).numpy() * 31,
seg_mask_path=config.seg_mask_path,
# add_noise_to_seg=0,
add_noise_to_seg=5, # dilate mask
convert_seg_mask_to_box_mask=False,
# convert_seg_mask_to_box_mask=False,
)
if "obj_prediction_json" in config:
room_optimizer.set_initial_pose_from_prediction(config["obj_prediction_json"])
else:
room_optimizer.set_initial_object_poses_from_scene_meta()
# dump config
config["optimize_option"] = room_optimizer.optimize_option
OmegaConf.save(
config=config,
f=os.path.join(room_optimizer.output_path, "optim_config_full.yaml"),
)
room_optimizer.generate_relation()
|
os.environ["OMP_NUM_THREADS"] = "1" # noqa
os.environ["MKL_NUM_THREADS"] = "1" # noqa
sys.path.append(".") # noqa
def main(config):
active_instance_id = config.active_instance_id
image_path = config.test_image_path
dataset_config = config.dataset_config["dataset"]
bg_scale_factor = 1
bg_scene_center = [0, 0, 0]
if config.bg_dataset_config != "":
bg_dataset_config = config.bg_dataset_config["dataset"]
bg_scale_factor = bg_dataset_config["scale_factor"]
bg_scene_center = bg_dataset_config["scene_center"]
img_wh = config.img_wh
# read image
input_rgb = Image.open(image_path)
input_rgb = input_rgb.resize(img_wh, Image.LANCZOS)
input_rgb = np.array(input_rgb)
input_rgb = torch.from_numpy(input_rgb).float() / 255 # (H, W, 3)
# intialize room optimizer
room_optimizer = RoomOptimizer(
scene_info_json_path=config.scene_info_json,
scale_factor=dataset_config["scale_factor"],
scale_factor_dict=dataset_config.get("scale_factor_dict", {}),
bg_scale_factor=bg_scale_factor,
bg_scene_center=bg_scene_center,
img_wh=config.img_wh,
near=0.3,
far=10.0,
N_samples=64,
N_importance=128,
chunk=config.chunk,
model_ckpt_path_dict=config.ckpt_path_dict,
# relation_info=relation_info,
relation_info={},
output_path="debug",
prefix=config.prefix,
active_instance_id=active_instance_id,
lr=1e-2,
# lr=5e-2,
N_optim_step=500,
adjust_lr_per_step=0,
optim_batch_size=1024,
# optim_batch_size=2048,
# optim_batch_size=4096,
# use_amp=False,
use_amp=True,
optimize_light_env=True,
optimize_appearance_code=config.get("optimize_appearance_code", False),
mask_per_object=False,
bbox_ray_intersect=True,
bbox_enlarge=0.1,
optimize_option=[
"keypoint_mask",
"photometric_loss",
# "perceptual_loss",
"z_axis_align_loss",
"object_room_wall_attach",
"object_room_floor_attach",
"physical_violation",
# "physical_violation_delayed_start",
"object_object_attach",
"viewing_constraint",
"optimize_exposure",
"regenerate_relation_during_test",
# "visualize_pred",
# "print_loss_dict",
],
)
# room_optimizer.set_sampling_mask_from_seg(
# seg_mask=None,
# seg_mask_path=config.seg_mask_path,
# # add_noise_to_seg=0,
# add_noise_to_seg=5, # dilate mask
# convert_seg_mask_to_box_mask=True,
# # convert_seg_mask_to_box_mask=False,
# )
room_optimizer.set_sampling_mask_from_seg(
# seg_mask=torch.ones_like(input_rgb[:, :, 0]).numpy() * 31,
seg_mask_path=config.seg_mask_path,
# add_noise_to_seg=0,
add_noise_to_seg=5, # dilate mask
convert_seg_mask_to_box_mask=False,
# convert_seg_mask_to_box_mask=False,
)
if "obj_prediction_json" in config:
room_optimizer.set_initial_pose_from_prediction(config["obj_prediction_json"])
else:
room_optimizer.set_initial_object_poses_from_scene_meta()
# dump config
config["optimize_option"] = room_optimizer.optimize_option
OmegaConf.save(
config=config,
f=os.path.join(room_optimizer.output_path, "optim_config_full.yaml"),
)
room_optimizer.generate_relation()
| real_room_loc = read_real_scene_localization_with_name("arrangement3") | 2 | 2023-10-15 08:41:29+00:00 | 24k |
WenzhengZhang/Seq2seqCoref | main_trainer.py | [
{
"identifier": "DataArguments",
"path": "arguments.py",
"snippet": "class DataArguments:\n data_dir: Optional[str] = field(\n default=None, metadata={\"help\": \"Path to data directory\"}\n )\n\n max_train_len: Optional[int] = field(\n default=1536,\n metadata={\n ... | import logging
import os
import sys
from transformers import HfArgumentParser, set_seed
from transformers import AutoModelForSeq2SeqLM, \
DataCollatorForSeq2Seq, AutoConfig, AutoTokenizer
from transformers.integrations import TensorBoardCallback
from arguments import DataArguments, ModelArguments, CorefTrainingArguments \
as TrainingArguments
from data import CorefDataset, JointDataset
from constants import SPEAKER_START, SPEAKER_END, MENTION_START, MENTION_END, \
COPY, CLUSTER_NEW, CLUSTERS, SENTENCE_START, SENTENCE_END, SPECIAL_IDS, \
NON_INT_SPECIAL_IDS, MARK_SPECIAL_IDS, MENTION_END_NON_INT_SPECIAL_IDS, \
MENTION_ENDS
from trainer import CorefTrainer
from data import ConstrainedDataCollator
from model import ConstrainedT5 | 20,269 |
logger = logging.getLogger(__name__)
logger.addHandler(logging.StreamHandler(sys.stdout))
def main():
parser = HfArgumentParser(
(ModelArguments, DataArguments, TrainingArguments))
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
model_args, data_args, training_args = parser.parse_json_file(
json_file=os.path.abspath(sys.argv[1]))
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
model_args: ModelArguments
data_args: DataArguments
training_args: TrainingArguments
if (
os.path.exists(training_args.output_dir)
and os.listdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
)
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
level=logging.INFO if training_args.local_rank in [-1,
0] else logging.WARN,
)
logger.warning(
"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, fp16 training: %s, bf16 training: %s",
training_args.local_rank,
training_args.device,
training_args.n_gpu,
bool(training_args.local_rank != -1),
training_args.fp16,
training_args.bf16,
)
logger.info("Training/evaluation parameters %s", training_args)
logger.info("MODEL parameters %s", model_args)
logger.info("Data arguments %s", data_args)
set_seed(training_args.seed)
tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
if training_args.action_type == "integer":
num_new_tokens = tokenizer.add_tokens([SPEAKER_START, SPEAKER_END,
MENTION_START, MENTION_END,
|
logger = logging.getLogger(__name__)
logger.addHandler(logging.StreamHandler(sys.stdout))
def main():
parser = HfArgumentParser(
(ModelArguments, DataArguments, TrainingArguments))
if len(sys.argv) == 2 and sys.argv[1].endswith(".json"):
model_args, data_args, training_args = parser.parse_json_file(
json_file=os.path.abspath(sys.argv[1]))
else:
model_args, data_args, training_args = parser.parse_args_into_dataclasses()
model_args: ModelArguments
data_args: DataArguments
training_args: TrainingArguments
if (
os.path.exists(training_args.output_dir)
and os.listdir(training_args.output_dir)
and training_args.do_train
and not training_args.overwrite_output_dir
):
raise ValueError(
f"Output directory ({training_args.output_dir}) already exists and is not empty. Use --overwrite_output_dir to overcome."
)
# Setup logging
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
level=logging.INFO if training_args.local_rank in [-1,
0] else logging.WARN,
)
logger.warning(
"Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, fp16 training: %s, bf16 training: %s",
training_args.local_rank,
training_args.device,
training_args.n_gpu,
bool(training_args.local_rank != -1),
training_args.fp16,
training_args.bf16,
)
logger.info("Training/evaluation parameters %s", training_args)
logger.info("MODEL parameters %s", model_args)
logger.info("Data arguments %s", data_args)
set_seed(training_args.seed)
tokenizer = AutoTokenizer.from_pretrained(model_args.model_name_or_path)
if training_args.action_type == "integer":
num_new_tokens = tokenizer.add_tokens([SPEAKER_START, SPEAKER_END,
MENTION_START, MENTION_END, | COPY]) | 9 | 2023-10-17 17:39:16+00:00 | 24k |
giulio98/functional-diffusion-processes | src/functional_diffusion_processes/trainers/trainer.py | [
{
"identifier": "AudioDataset",
"path": "src/functional_diffusion_processes/datasets/audio_dataset.py",
"snippet": "class AudioDataset(BaseDataset, abc.ABC):\n \"\"\"Base class for defining audio datasets.\n\n This class serves as the foundation for defining datasets containing audio data.\n It... | import abc
import gc
import io
import logging
import os
import flax
import flax.jax_utils as flax_utils
import hydra.utils
import jax
import numpy as np
import tensorflow as tf
import wandb
from typing import Any, Callable, Tuple, Union
from cleanfid import fid
from flax import linen, traverse_util
from flax.training import checkpoints
from flax.training.checkpoints import restore_checkpoint
from jax import numpy as jnp
from omegaconf import DictConfig, OmegaConf
from tqdm.auto import tqdm
from wandb.sdk.lib import RunDisabled
from wandb.sdk.wandb_run import Run
from ..datasets import AudioDataset, ImageDataset
from ..datasets.base_dataset import BaseDataset
from ..losses.base_loss import Loss
from ..metrics import FIDMetric
from ..samplers import Sampler
from ..sdetools.base_sde import SDE
from ..utils.common import filter_mask, make_grid_image, process_images, save_samples, to_grayscale
from ..utils.scaler import get_data_inverse_scaler, get_data_scaler
from ..utils.training_state import TrainState
from .helpers import colorizing_fn, construct_sampling_fn, construct_train_step, inpainting_fn, sampling_fn | 14,800 |
# update the TrainState with replicated parameters and optimizer state
state = state.replace(
params=p_params,
opt_state_params=p_opt_state_params,
step=p_step,
ema_params=p_ema_params,
)
if jax.host_id() == 0:
pylogger.info("Starting training loop at step %d." % (start_step,))
rng = jax.random.fold_in(rng, jax.host_id())
assert (
self.training_config.log_freq % self.training_config.n_jitted_steps == 0
and self.training_config.eval_freq % self.training_config.n_jitted_steps == 0
), "Missing logs or checkpoints!"
ds_train_iter = iter(ds_train)
with tqdm(
total=self.training_config.total_steps + 1,
initial=start_step,
position=0,
leave=True,
) as pbar:
for step in range(
start_step,
self.training_config.total_steps + 1,
self.training_config.n_jitted_steps,
):
# Get the next batch of data and scale it
batch = jax.tree_map(f=lambda x: scaler(x._numpy()), tree=next(ds_train_iter)["data"])
if not self.training_config.sampling_only:
# Split the random number generator for the current step
rng, *next_rng = jax.random.split(key=rng, num=jax.local_device_count() + 1)
next_rng = jnp.asarray(next_rng)
((_, state), batch_reconstructed, batch_corrupted, target) = self.train_step(
train_step_fn=train_step_fn,
carry_state=(next_rng, state),
batch=batch,
batch_input=p_batch_input,
)
if not self.training_config.sampling_only and (
(jax.host_id() == 0 and step % self.training_config.checkpoint_freq == 0 and step != 0)
):
self.save_checkpoint(step, run, state)
# Evaluate the model
if self.training_config.sampling and (step % self.training_config.eval_freq == 0):
# if step != 0:
if jax.host_id() == 0:
pylogger.info("Generating samples at step %d." % (step,))
_, *sample_rng = jax.random.split(rng, jax.local_device_count() + 1)
_, b, g, c = batch.shape
sample_rng = jnp.asarray(sample_rng)
if self.training_config.sampling_type == "full":
batch_sampled, batch_sampled_last, batch_sampled_all = sampling_fn(
sample_fn, (sample_rng, state), p_batch_input
)
elif self.training_config.sampling_type == "colorization":
batch_grayscale = to_grayscale(batch)
batch_grayscale = batch_grayscale.reshape(-1, b, g, 1)
batch_sampled, batch_sampled_last, batch_sampled_all = colorizing_fn(
sample_fn, (sample_rng, state), p_batch_input, batch_grayscale
)
elif self.training_config.sampling_type == "inpainting":
config_object = OmegaConf.create(
{
"_target_": "functional_diffusion_processes.datasets.mnist_dataset.MNISTDataset",
"data_config": {
"seed": 42,
"batch_size": ds_train.data_config.batch_size,
"image_height_size": ds_train.data_config.image_height_size,
"image_width_size": ds_train.data_config.image_width_size,
"output_size": 1,
"random_flip": False,
"uniform_dequantization": False,
"data_centered": False,
"data_dir": "${oc.env:DATA_ROOT}/tensorflow_datasets",
"download": True,
"is_mask": True,
},
"split": "train",
"evaluation": False,
}
)
ds_mask = hydra.utils.instantiate(config_object, _recursive_=False)
ds_mask_iter = iter(ds_mask)
batch_masked = jax.tree_map(f=lambda x: x._numpy(), tree=next(ds_mask_iter)["data"])
batch_sampled, batch_sampled_last, batch_sampled_all = inpainting_fn(
sample_fn, (sample_rng, state), p_batch_input, (batch * batch_masked), batch_masked
)
elif self.training_config.sampling_type == "deblurring":
n_rows, n_cols = ds_train.data_config.image_height_size, ds_train.data_config.image_width_size
batch_masked = filter_mask(batch.reshape(-1, b, n_rows, n_cols, c).shape, radius=10)
batch_freq = jnp.fft.fftshift(
jnp.fft.fft2(batch.reshape(-1, b, n_rows, n_cols, c), axes=(2, 3)),
axes=(2, 3),
)
batch_freq = batch_freq * batch_masked
batch_blurred = jnp.real(jnp.fft.ifft2(jnp.fft.ifftshift(batch_freq, axes=(2, 3)), axes=(2, 3)))
batch_blurred = batch_blurred.reshape(-1, b, g, c)
batch_masked = batch_masked.reshape(-1, b, g, c)
batch_sampled, batch_sampled_last, batch_sampled_all = inpainting_fn(
sample_fn, (sample_rng, state), p_batch_input, batch_blurred, batch_masked
)
if jax.host_id() == 0 and self.logging.use_wandb:
|
# import imageio
# import imageio
pylogger = logging.getLogger(__name__)
class Trainer(abc.ABC):
"""Class for training a model."""
def __init__(
self,
mode: str,
model_name: str,
training_config: DictConfig,
optimizer,
evaluation_config: DictConfig,
trainer_logging: DictConfig,
sampler: Sampler,
loss_obj: Loss,
) -> None:
"""Initialize a Trainer instance with configurations and core components.
Args:
mode (str): Specifies the mode of the trainer which can be either "train" or "eval".
model_name (str): The name identifier for the model.
training_config (DictConfig): A configuration dictionary for training settings.
optimizer: The optimizer instance used for training.
evaluation_config (DictConfig): A configuration dictionary for evaluation settings.
trainer_logging (DictConfig): A configuration dictionary for logging settings.
sampler (Sampler): A sampler instance for sampling from the model.
loss_obj (Loss): A loss object used for computing the loss during training.
"""
self.mode = mode
self.model_name = model_name
self.training_config = training_config
self.optimizer = hydra.utils.instantiate(optimizer)
self.evaluation_config = evaluation_config
self.logging = trainer_logging
self.sampler = sampler
self.loss_obj = loss_obj
self.checkpoint_dir = os.path.join(self.training_config.save_dir, self.training_config.checkpoint_dir)
self.sample_dir = os.path.join(self.training_config.save_dir, self.training_config.sample_dir)
self.eval_dir = os.path.join(self.training_config.save_dir, self.evaluation_config.eval_dir)
# Create the directories for saving samples and checkpoints
tf.io.gfile.makedirs(self.checkpoint_dir)
tf.io.gfile.makedirs(self.sample_dir)
tf.io.gfile.makedirs(self.eval_dir)
tf.io.gfile.makedirs(os.path.join(self.eval_dir, "clean"))
def initialize_wandb(
self, dataset_config: DictConfig, sde_config: DictConfig, model_config: DictConfig
) -> Union[Run, RunDisabled, None]:
"""Initialize wandb if logging is enabled."""
if self.logging.use_wandb:
run = wandb.init(
name=os.path.basename(self.logging.wandb_init.name),
project=self.logging.wandb_init.project,
entity=self.logging.wandb_init.entity,
save_code=self.logging.wandb_init.save_code,
config={
**self.training_config,
**dataset_config,
**sde_config,
**model_config,
},
)
else:
run = None
return run
def initialize_run(self, model, ds_train, sde):
"""Perform all initialization steps required for training."""
run = self.initialize_wandb(ds_train.data_config, sde.sde_config, model.model_config)
scaler = get_data_scaler(is_centered=ds_train.data_config.data_centered)
inverse_scaler = get_data_inverse_scaler(is_centered=ds_train.data_config.data_centered)
rng = jax.random.PRNGKey(seed=self.training_config.seed)
rng, step_rng = jax.random.split(rng)
batch_input = model.initialize_input(
(ds_train.data_config.batch_size, *sde.sde_config.shape, ds_train.data_config.output_size)
)
params = jax.jit(model.initialize_model, backend="cpu")(step_rng, batch_input)
flat_params = traverse_util.flatten_dict(params).values()
tot_params = sum([jnp.size(p) for p in flat_params])
pylogger.info("Total number of parameters: {:.2f}M".format(tot_params / 1e6))
state = TrainState.create(
apply_fn=model.apply,
params=params,
tx=self.optimizer,
opt_state_params=self.optimizer.init(params),
rng=rng,
ema_params=params,
)
train_step_fn = construct_train_step(self.optimizer, self.loss_obj.construct_loss_fn(model))
sample_fn = construct_sampling_fn(model, self.sampler)
# Resume training when intermediate checkpoints are detected
if self.training_config.resume_training:
pylogger.warning("Resuming training from the latest checkpoint.")
if self.logging.use_wandb and self.model_name != "local":
model_file = wandb.use_artifact(self.model_name).download()
state = restore_checkpoint(ckpt_dir=model_file, prefix="checkpoint_", target=state)
else:
state = checkpoints.restore_checkpoint(ckpt_dir=self.checkpoint_dir, target=state)
return run, scaler, inverse_scaler, rng, state, train_step_fn, sample_fn, batch_input
def train_step(
self,
train_step_fn: Callable,
carry_state: Tuple,
batch: jnp.ndarray,
batch_input: jnp.ndarray,
) -> Tuple:
"""Perform a single training step, updating the model parameters.
Args:
train_step_fn (Callable): The train step function.
carry_state (Tuple): The current state of the model and optimizer.
batch (jnp.ndarray): The batch of data used for training.
batch_input (jnp.ndarray): The input data to the model.
Returns:
Tuple: The updated state after performing the training step.
"""
(rng, state) = carry_state
(
new_rng,
loss,
loss_inner,
new_params,
new_optim_state,
batch_reconstructed,
batch_corrupted,
target,
) = train_step_fn(
rng,
state.params,
state.opt_state_params,
state.step,
batch_input,
batch,
)
ema_rate = self.training_config.ema_rate
new_params_ema = jax.tree_map(
lambda p_ema, p: p_ema * ema_rate + p * (1.0 - ema_rate),
state.ema_params,
new_params,
)
# update the state
new_state = state.replace(
rng=flax.jax_utils.unreplicate(new_rng),
step=state.step + 1,
opt_state_params=new_optim_state,
params=new_params,
ema_params=new_params_ema,
)
new_carry_state = (new_rng, new_state)
loss = flax.jax_utils.unreplicate(loss)
step = int(flax_utils.unreplicate(state.step))
# Log the training progress
if jax.host_id() == 0 and step % self.training_config.log_freq == 0:
pylogger.info("step: %d, training_loss: %.5e" % (step, loss))
if self.logging.use_wandb:
wandb.log({"step": step, "loss": loss}, step=step)
if loss_inner is not None:
loss_inner = flax.jax_utils.unreplicate(loss_inner)
for inner_step, loss in enumerate(loss_inner):
pylogger.info("step: %d, training_loss_inner: %.5e" % (step, loss))
if self.logging.use_wandb:
wandb.log({"step": step, f"loss inner step {inner_step}": loss}, step=step)
return new_carry_state, batch_reconstructed, batch_corrupted, target
def save_checkpoint(self, step, run, state):
pylogger.info("Saving the model at step %d." % (step,))
# Log the evaluation progress
# Save the model parameters
(
params,
opt_state_params,
step_,
ema_params,
) = flax_utils.unreplicate(
(
state.params,
state.opt_state_params,
state.step,
state.ema_params,
)
)
saved_state = state.replace(
step=step_,
opt_state_params=opt_state_params,
params=params,
ema_params=ema_params,
)
checkpoint_file = checkpoints.save_checkpoint(
self.checkpoint_dir,
saved_state,
step=step_ // self.training_config.eval_freq,
keep=np.inf,
)
if self.logging.use_wandb:
wandb_model_artifact_name = str(step_) + "_" + run.id
wandb_model = wandb.Artifact(wandb_model_artifact_name, type="model")
wandb_model.add_file(checkpoint_file)
run.log_artifact(wandb_model)
# noinspection PyProtectedMember
def train(self, model: linen.Module, ds_train: BaseDataset, sde: SDE) -> None:
"""Train the model with optional evaluation and logging.
This method encapsulates the entire training process including initialization,
training loop, checkpointing, evaluation, and logging. It supports different
sampling types like colorization, inpainting, super resolution, and deblurring.
Args:
model (linen.Module): The model to be trained.
ds_train (BaseDataset): The training dataset.
sde (SDE): Stochastic differential equation object, governing the dynamics
for sampling.
Raises:
ValueError: If an unsupported dataset type is provided.
Note:
The method leverages the Weights & Biases (wandb) platform for logging
and checkpointing, make sure it's configured properly if logging is enabled.
"""
run, scaler, inverse_scaler, rng, state, train_step_fn, sample_fn, batch_input = self.initialize_run(
model, ds_train, sde
)
# `state.step` is JAX integer on the GPU/TPU devices
start_step = int(state.step)
rng = state.rng
# Replicate the train state on all devices
(
p_params,
p_opt_state_params,
p_step,
p_ema_params,
p_batch_input,
) = flax_utils.replicate(
(
state.params,
state.opt_state_params,
state.step,
state.ema_params,
batch_input,
)
)
# update the TrainState with replicated parameters and optimizer state
state = state.replace(
params=p_params,
opt_state_params=p_opt_state_params,
step=p_step,
ema_params=p_ema_params,
)
if jax.host_id() == 0:
pylogger.info("Starting training loop at step %d." % (start_step,))
rng = jax.random.fold_in(rng, jax.host_id())
assert (
self.training_config.log_freq % self.training_config.n_jitted_steps == 0
and self.training_config.eval_freq % self.training_config.n_jitted_steps == 0
), "Missing logs or checkpoints!"
ds_train_iter = iter(ds_train)
with tqdm(
total=self.training_config.total_steps + 1,
initial=start_step,
position=0,
leave=True,
) as pbar:
for step in range(
start_step,
self.training_config.total_steps + 1,
self.training_config.n_jitted_steps,
):
# Get the next batch of data and scale it
batch = jax.tree_map(f=lambda x: scaler(x._numpy()), tree=next(ds_train_iter)["data"])
if not self.training_config.sampling_only:
# Split the random number generator for the current step
rng, *next_rng = jax.random.split(key=rng, num=jax.local_device_count() + 1)
next_rng = jnp.asarray(next_rng)
((_, state), batch_reconstructed, batch_corrupted, target) = self.train_step(
train_step_fn=train_step_fn,
carry_state=(next_rng, state),
batch=batch,
batch_input=p_batch_input,
)
if not self.training_config.sampling_only and (
(jax.host_id() == 0 and step % self.training_config.checkpoint_freq == 0 and step != 0)
):
self.save_checkpoint(step, run, state)
# Evaluate the model
if self.training_config.sampling and (step % self.training_config.eval_freq == 0):
# if step != 0:
if jax.host_id() == 0:
pylogger.info("Generating samples at step %d." % (step,))
_, *sample_rng = jax.random.split(rng, jax.local_device_count() + 1)
_, b, g, c = batch.shape
sample_rng = jnp.asarray(sample_rng)
if self.training_config.sampling_type == "full":
batch_sampled, batch_sampled_last, batch_sampled_all = sampling_fn(
sample_fn, (sample_rng, state), p_batch_input
)
elif self.training_config.sampling_type == "colorization":
batch_grayscale = to_grayscale(batch)
batch_grayscale = batch_grayscale.reshape(-1, b, g, 1)
batch_sampled, batch_sampled_last, batch_sampled_all = colorizing_fn(
sample_fn, (sample_rng, state), p_batch_input, batch_grayscale
)
elif self.training_config.sampling_type == "inpainting":
config_object = OmegaConf.create(
{
"_target_": "functional_diffusion_processes.datasets.mnist_dataset.MNISTDataset",
"data_config": {
"seed": 42,
"batch_size": ds_train.data_config.batch_size,
"image_height_size": ds_train.data_config.image_height_size,
"image_width_size": ds_train.data_config.image_width_size,
"output_size": 1,
"random_flip": False,
"uniform_dequantization": False,
"data_centered": False,
"data_dir": "${oc.env:DATA_ROOT}/tensorflow_datasets",
"download": True,
"is_mask": True,
},
"split": "train",
"evaluation": False,
}
)
ds_mask = hydra.utils.instantiate(config_object, _recursive_=False)
ds_mask_iter = iter(ds_mask)
batch_masked = jax.tree_map(f=lambda x: x._numpy(), tree=next(ds_mask_iter)["data"])
batch_sampled, batch_sampled_last, batch_sampled_all = inpainting_fn(
sample_fn, (sample_rng, state), p_batch_input, (batch * batch_masked), batch_masked
)
elif self.training_config.sampling_type == "deblurring":
n_rows, n_cols = ds_train.data_config.image_height_size, ds_train.data_config.image_width_size
batch_masked = filter_mask(batch.reshape(-1, b, n_rows, n_cols, c).shape, radius=10)
batch_freq = jnp.fft.fftshift(
jnp.fft.fft2(batch.reshape(-1, b, n_rows, n_cols, c), axes=(2, 3)),
axes=(2, 3),
)
batch_freq = batch_freq * batch_masked
batch_blurred = jnp.real(jnp.fft.ifft2(jnp.fft.ifftshift(batch_freq, axes=(2, 3)), axes=(2, 3)))
batch_blurred = batch_blurred.reshape(-1, b, g, c)
batch_masked = batch_masked.reshape(-1, b, g, c)
batch_sampled, batch_sampled_last, batch_sampled_all = inpainting_fn(
sample_fn, (sample_rng, state), p_batch_input, batch_blurred, batch_masked
)
if jax.host_id() == 0 and self.logging.use_wandb: | if isinstance(ds_train, ImageDataset): | 1 | 2023-10-24 22:01:35+00:00 | 24k |
violet-sto/HN-GFN | main_mobo.py | [
{
"identifier": "Dataset",
"path": "dataset.py",
"snippet": "class Dataset:\n\n def __init__(self, args, bpath, oracle, device):\n self.test_split_rng = np.random.RandomState(142857)\n self.train_rng = np.random.RandomState(int(time.time()))\n self.train_mols = []\n self.t... | from collections import defaultdict
from dataset import Dataset
from mol_mdp_ext import MolMDPExtended, BlockMoleculeDataExtended
from oracle.oracle import Oracle
from proxy import get_proxy
from generator import TBGFlowNet, FMGFlowNet, MOReinforce
from utils.utils import set_random_seed
from utils.metrics import compute_success, compute_diversity, compute_novelty, compute_correlation, circle_points
from utils.logging import get_logger
from datetime import datetime
from botorch.utils.multi_objective.hypervolume import Hypervolume
from botorch.utils.sampling import sample_simplex
from botorch.utils.transforms import normalize, unnormalize
from torch.distributions.dirichlet import Dirichlet
from main import RolloutWorker, get_test_mols
from pymoo.util.ref_dirs import get_reference_directions
from copy import deepcopy
import random
import os
import re
import argparse
import json
import time
import threading
import pdb
import pickle
import gzip
import torch.multiprocessing as mp
import torch.nn.functional as F
import torch
import pandas as pd
import numpy as np
import warnings | 15,576 | picked_mols = []
smis = []
for i, weights in enumerate(rollout_worker.test_weights):
sampled_mols = []
sampled_raw_rewards = []
sampled_means = []
sampled_smis = []
while len(sampled_mols) < args.num_samples:
rollout_worker.rollout(generator, use_rand_policy=False, weights=torch.tensor(weights).unsqueeze(0).to(args.device))
(raw_r, _, m, trajectory_stats, inflow) = rollout_worker.sampled_mols[-1]
sampled_mols.append(m)
sampled_raw_rewards.append(raw_r[0].item())
sampled_means.append(raw_r[1])
sampled_smis.append(m.smiles)
idx_pick = np.argsort(sampled_raw_rewards)[::-1][:int(args.num_samples/len(rollout_worker.test_weights))]
picked_mols.extend(np.array(sampled_mols)[idx_pick].tolist())
means.extend(np.array(sampled_means)[idx_pick].tolist())
smis.extend(np.array(sampled_smis)[idx_pick].tolist())
raw_rewards.extend(np.array(sampled_raw_rewards)[idx_pick].tolist())
raw_rewards_weight[str(weights.cpu())] = np.array(sampled_raw_rewards)[idx_pick].mean()
raw_rewards_mean = np.mean(list(raw_rewards_weight.values()))
assert len(picked_mols) == args.num_samples
top_means = torch.tensor(means)
scores_dict = oracle.batch_get_scores(picked_mols)
scores = torch.tensor(pd.DataFrame.from_dict(scores_dict).values)
test_loss = F.mse_loss(top_means, scores)
hypervolume = Hypervolume(ref_point=torch.zeros(len(args.objectives)))
volume = hypervolume.compute(top_means)
volume_oracle = hypervolume.compute(scores)
diversity = compute_diversity(picked_mols)
batch_metrics = {'Hypervolume_reward': volume,
'Hypervolume_oracle': volume_oracle,
'Reward_mean': raw_rewards_mean,
'scores_max': pd.DataFrame.from_dict(scores_dict).max().to_dict(),
'scores_mean': pd.DataFrame.from_dict(scores_dict).mean().to_dict(),
'Test_loss': test_loss,
'Diversity': diversity}
print(batch_metrics)
print('Time: {}'.format(time.time()-time_start))
if not compute_multi_objective_metric:
return volume, volume_oracle, raw_rewards_weight, raw_rewards_mean, test_loss, diversity
else:
for i in range(len(picked_mols)):
picked_mols[i].score = scores_dict[i]
# success/diversity/novelty is computed among the top mols.
success, positive_mols = compute_success(
picked_mols, scores_dict, args.objectives, score_succ)
succ_diversity = compute_diversity(positive_mols)
if ref_mols:
novelty = compute_novelty(positive_mols, ref_mols)
else:
novelty = 1.
mo_metrics = {'success': success, 'novelty': novelty,
'succ_diversity': succ_diversity, }
picked_smis = [(raw_rewards[i], picked_mols[i].score, smis[i])
for i in range(len(raw_rewards))]
print(mo_metrics)
return (picked_mols, scores_dict, picked_smis), batch_metrics, mo_metrics
def log_overall_metrics(args, dataset, batch_infos=None, MultiObjective_metrics=None):
volume = dataset.compute_hypervolume()
print("Hypervolume for {}: {}".format(args.logger.context, volume))
args.logger.add_scalar('Metric/hypervolume', volume, use_context=False)
args.logger.add_object('scores', dataset.scores)
args.logger.add_object('smis', dataset.smis)
if batch_infos:
args.logger.add_scalar(
'Metric/test_loss', batch_infos['Test_loss'], use_context=False)
args.logger.add_object('collected_info', batch_infos)
if MultiObjective_metrics:
args.logger.add_scalars('Metric/MultiObjective',
MultiObjective_metrics, use_context=False)
def get_test_rays():
if args.n_objectives == 3:
n_partitions = 6
elif args.n_objectives == 4:
n_partitions = 7
test_rays = get_reference_directions("das-dennis", args.n_objectives, n_partitions=n_partitions).astype(np.float32)
test_rays = test_rays[[(r > 0).all() for r in test_rays]]
print(f"initialize {len(test_rays)} test rays")
return test_rays
def main(args):
set_random_seed(args.seed)
args.logger.set_context('iter_0')
bpath = "./data/blocks_105.json"
dpath = "./data/docked_mols.h5"
# Initialize oracle and dataset (for training surrogate function)
oracle = Oracle(args)
dataset = Dataset(args, bpath, oracle, args.device)
dataset.load_h5(dpath, num_init_examples=args.num_init_examples)
log_overall_metrics(args, dataset)
args.n_objectives = len(args.objectives)
# Initialize surrogate function
proxy = get_proxy(args, bpath, oracle)
proxy.update(dataset, 0, reset=False)
for i in range(1, args.num_outer_loop_iters+1):
print(f"====== Starting round {i} ======")
args.logger.set_context('iter_{}'.format(i))
test_weights = np.random.dirichlet(args.alpha_vector, 5*(2**(args.n_objectives-2))).astype(np.float32)
if args.criterion == 'TB':
| warnings.filterwarnings('ignore')
def arg_parse():
parser = argparse.ArgumentParser()
parser.add_argument("--device", type=str, default='cuda')
parser.add_argument('--seed', type=int, default=42, help='seed')
parser.add_argument("--run", default=0, help="run", type=int)
parser.add_argument('--save', action='store_true',
default=False, help='Save model.')
parser.add_argument('--debug',action='store_true',
default=False, help='debug mode, no multi thread')
parser.add_argument("--enable_tensorboard",
action='store_true', default=False)
parser.add_argument("--log_dir", default='runs/mobo')
parser.add_argument("--include_nblocks", default=False)
parser.add_argument("--num_init_examples", default=200, type=int)
parser.add_argument("--num_outer_loop_iters", default=8, type=int)
parser.add_argument("--num_samples", default=100, type=int)
parser.add_argument("--floatX", default='float32')
parser.add_argument('--sample_iterations', type=int, default=1000, help='sample mols and compute metrics')
parser.add_argument("--log_weight_score", action='store_true', default=False)
# objectives
parser.add_argument("--objectives", type=str,
default='gsk3b,jnk3,qed,sa')
parser.add_argument("--acq_fn", default='UCB', type=str)
parser.add_argument("--beta", default=0.1, type=float)
parser.add_argument("--scalar", default='WeightedSum', type=str)
parser.add_argument("--alpha", default=1., type=float,
help='dirichlet distribution')
parser.add_argument("--alpha_vector", default='1,1,1,1', type=str)
# Proxy
parser.add_argument("--proxy_normalize", action='store_true',
default=False, help='normalize Y')
parser.add_argument("--proxy_num_iterations", default=10000, type=int)
parser.add_argument("--proxy_learning_rate", default=2.5e-4,
help="Learning rate", type=float)
parser.add_argument("--proxy_mbsize", default=64,
help="Minibatch size", type=int)
parser.add_argument("--proxy_early_stop_tol", default=10, type=int)
parser.add_argument("--proxy_repr_type", default='atom_graph')
parser.add_argument("--proxy_model_version", default='v2')
parser.add_argument("--proxy_num_conv_steps",
default=12, type=int)
parser.add_argument("--proxy_nemb", default=64, help="#hidden", type=int)
parser.add_argument("--proxy_weight_decay", default=1e-6,
help="Weight Decay in Proxy", type=float)
parser.add_argument("--proxy_uncertainty", default="evidential", type=str) # deep ensemble and GP
parser.add_argument("--proxy_dropout", default=0.1,
help="MC Dropout in Proxy", type=float)
parser.add_argument("--proxy_num_dropout_samples", default=5, type=int)
parser.add_argument("--evidential_lam", default=0.1, type=float)
parser.add_argument(
"--fp_radius", type=int, default=2, help="Morgan fingerprint radius."
)
parser.add_argument(
"--fp_nbits", type=int, default=1024, help="Morgan fingerprint nBits."
)
# GFlowNet
parser.add_argument("--min_blocks", default=2, type=int)
parser.add_argument("--max_blocks", default=8, type=int)
parser.add_argument("--num_iterations", default=5000, type=int)
parser.add_argument("--criterion", default="FM", type=str)
parser.add_argument("--learning_rate", default=5e-4,
help="Learning rate", type=float)
parser.add_argument("--Z_learning_rate", default=5e-3,
help="Learning rate", type=float)
parser.add_argument("--clip_grad", default=0, type=float)
parser.add_argument("--trajectories_mbsize", default=8, type=int)
parser.add_argument("--offline_mbsize", default=8, type=int)
parser.add_argument("--hindsight_prob", default=0.2, type=float)
parser.add_argument("--hindsight_buffer_mbsize", default=8, type=int)
parser.add_argument("--hindsight_trajectories_mbsize", default=8, type=int)
parser.add_argument("--reward_min", default=1e-2, type=float)
parser.add_argument("--reward_norm", default=1, type=float)
parser.add_argument("--reward_exp", default=8, type=float)
parser.add_argument("--reward_exp_ramping", default=0, type=float)
parser.add_argument("--logit_clipping", default=0., type=float)
# Hyperparameters for TB
parser.add_argument("--partition_init", default=1, type=float)
# Hyperparameters for FM
parser.add_argument("--log_reg_c", default=(0.1/8)**4, type=float)
parser.add_argument("--balanced_loss", default=True)
parser.add_argument("--leaf_coef", default=10, type=float)
# Architecture
parser.add_argument("--repr_type", default='block_graph')
parser.add_argument("--model_version", default='v4')
parser.add_argument("--num_conv_steps", default=10, type=int)
parser.add_argument("--nemb", default=256, help="#hidden", type=int)
parser.add_argument("--weight_decay", default=0, type=float)
parser.add_argument("--random_action_prob", default=0.05, type=float)
parser.add_argument("--bootstrap_tau", default=0, type=float)
parser.add_argument("--condition_type", type=str, default='HN')
parser.add_argument("--ray_hidden_dim", default=100, type=int)
return parser.parse_args()
class BoRolloutWorker(RolloutWorker):
def __init__(self, args, bpath, proxy, device):
super(BoRolloutWorker, self).__init__(args, bpath, proxy, device)
self.hindsight_prob = args.hindsight_prob
self.hindsight_mols = defaultdict(list)
self.hindsight_smiles = defaultdict(list)
self.replay_threshold = 0.9
def _get(self, i, dset, weights=None):
# Sample trajectories by walking backwards from the molecules in our dataset
# Handle possible multithreading issues when independent threads
# add/substract from dset:
m = dset[i]
if not isinstance(m, BlockMoleculeDataExtended):
m = m[-1]
r, raw_r = self._get_reward(m, weights)
done = 1
samples = []
# a sample is a tuple (parents(s), parent actions, reward(s), s, done)
# an action is (blockidx, stemidx) or (-1, x) for 'stop'
# so we start with the stop action, unless the molecule is already
# a "terminal" node (if it has no stems, no actions).
if len(m.stems) and len(m.blocks) < self.max_blocks:
samples.append(((m,), ((-1, 0),), weights, weights, r, m, done))
r = done = 0
while len(m.blocks): # and go backwards
if self.ignore_parents:
parents = self.mdp.parents(m)
parent, action = parents[self.train_rng.randint(len(parents))]
samples.append(((parent,), (action,), weights, weights, r, m, done))
r = done = 0
m = parent
else:
parents, actions = zip(*self.mdp.parents(m))
samples.append((parents, actions, weights.repeat(len(parents), 1), weights, r, m, done))
r = done = 0
m = parents[self.train_rng.randint(len(parents))]
return samples[::-1]
def _add_mol_to_replay(self, m):
for i, weights in enumerate(self.test_weights):
r, raw_r = self._get_reward(m, weights)
if len(self.hindsight_mols[i]) < self.max_hindsight_mols or raw_r[0] > self.hindsight_mols[i][0][0]:
if m.smiles not in self.hindsight_smiles[i]:
self.hindsight_mols[i].append((raw_r[0].item(), m.smiles, m))
self.hindsight_smiles[i].append(m.smiles)
if len(self.hindsight_mols[i]) > self.max_hindsight_mols:
self.hindsight_mols[i] = sorted(self.hindsight_mols[i], key=lambda x:(x[0]))[
max(int(0.05 * self.max_hindsight_mols), 1):]
self.hindsight_smiles[i] = [x[1] for x in self.hindsight_mols[i]]
def _add_mol_to_online(self, r, m, inflow):
if self.replay_mode == 'online':
r = r + self.train_rng.normal() * 0.01
if len(self.online_mols) < self.max_online_mols or r > self.online_mols[0][0]:
self.online_mols.append((r, m))
if len(self.online_mols) > self.max_online_mols:
self.online_mols = sorted(self.online_mols)[
max(int(0.05 * self.max_online_mols), 1):]
elif self.replay_mode == 'prioritized':
self.online_mols.append((abs(inflow - np.log(r)), m))
if len(self.online_mols) > self.max_online_mols * 1.1:
self.online_mols = self.online_mols[-self.max_online_mols:]
def _get_reward(self, m, weights=None):
rdmol = m.mol
if rdmol is None:
return self.reward_min
# get reward from proxy
raw_reward, score = self.proxy(m, weights)
raw_reward = raw_reward.clip(self.reward_min)
reward = self.l2r(raw_reward)
return reward, (raw_reward, score)
def execute_train_episode_batch(self, generator, dataset=None, Y_bounds=None, use_rand_policy=True):
if self.train_rng.uniform() < self.hindsight_prob:
idx = self.train_rng.randint(self.test_weights.shape[0])
weights = self.test_weights[idx].unsqueeze(0)
samples = sum((self.rollout(generator, use_rand_policy, weights)
for i in range(self.args.hindsight_trajectories_mbsize)), [])
if self.args.hindsight_buffer_mbsize > 0:
buffer = deepcopy(self.hindsight_mols[idx])
reward = np.array([x[0] for x in buffer])
prob = reward / sum(reward)
eidx = np.random.choice(list(range(len(buffer))), self.args.hindsight_buffer_mbsize, replace=False, p=prob)
offline_samples = sum((self._get(i, buffer, weights)
for i in eidx), [])
samples += offline_samples
else:
weights = Dirichlet(torch.tensor(self.args.alpha_vector)*self.args.alpha).sample_n(1).to(self.args.device) #* sample weights per batch, seem better
samples = sum((self.rollout(generator, use_rand_policy, weights, replay=True)
for i in range(self.args.trajectories_mbsize)), [])
# offline sampling from dataset
if self.args.offline_mbsize > 0 and dataset is not None:
# use the oracle reward
scores = torch.tensor(pd.DataFrame.from_dict(dataset.scores).values, dtype=torch.float32).to(args.device)
if Y_bounds is not None:
scores = normalize(scores, Y_bounds)
reward = torch.matmul(scores, weights.reshape(-1, 1))
prob = (reward / sum(reward)).squeeze(1).cpu().numpy()
eidx = np.random.choice(list(range(len(dataset.all_mols))), self.args.offline_mbsize, replace=False, p=prob)
offline_samples = sum((self._get(i, dataset.all_mols, weights)
for i in eidx), [])
samples += offline_samples
return zip(*samples)
def initialize_hindsight_mols(self, dataset):
for m in dataset.all_mols:
for i, weights in enumerate(self.test_weights):
r, raw_r = self._get_reward(m, weights)
self.hindsight_mols[i].append((raw_r[0].item(), m.smiles, m))
for i, weights in enumerate(self.test_weights):
self.hindsight_mols[i] = sorted(self.hindsight_mols[i], key=lambda x:(x[0]))
self.hindsight_smiles[i] = [x[1] for x in self.hindsight_mols[i]]
def train_generative_model(args, generator, bpath, proxy, oracle, dataset, test_weights,
round_idx, do_save=False):
print("Training generator...")
os.makedirs(os.path.join(args.log_dir, f'round_{round_idx}'), exist_ok=True)
device = args.device
rollout_worker = BoRolloutWorker(args, bpath, proxy, device)
rollout_worker.test_weights = torch.tensor(test_weights).to(device)
rollout_worker.initialize_hindsight_mols(dataset)
Y_bounds = torch.stack([proxy.partitioning.Y.min(dim=-2).values, proxy.partitioning.Y.max(dim=-2).values])
def save_stuff(round_idx, iter):
torch.save(generator.state_dict(), os.path.join(
args.log_dir, 'round_{}/{}_generator_checkpoint.pth'.format(round_idx, iter)))
pickle.dump(rollout_worker.sampled_mols,
gzip.open(f'{args.log_dir}/sampled_mols.pkl.gz', 'wb'))
multi_thread = not args.debug
if multi_thread:
sampler = rollout_worker.start_samplers(generator, 8, dataset)
def stop_everything():
print('joining')
rollout_worker.stop_samplers_and_join()
last_losses = []
train_losses = []
test_losses = []
test_infos = []
train_infos = []
time_last_check = time.time()
for i in range(args.num_iterations + 1):
if multi_thread:
r = sampler()
for thread in rollout_worker.sampler_threads:
if thread.failed:
stop_everything()
pdb.post_mortem(thread.exception.__traceback__)
return
p, pb, a, pw, w, r, s, d, mols = r
else:
p, pb, a, pw, w, r, s, d, mols = rollout_worker.sample2batch(
rollout_worker.execute_train_episode_batch(generator, dataset, Y_bounds, use_rand_policy=True))
loss = generator.train_step(p, pb, a, pw, w, r, s, d, mols, i)
last_losses.append(loss)
if not i % 100:
train_loss = [np.round(np.mean(i), 3) for i in zip(*last_losses)]
train_losses.append(train_loss)
args.logger.add_scalar(
'Loss/round{}/train'.format(round_idx), train_loss[0], use_context=False)
print('Iter {}: Loss {}, Time {}'.format(
i, train_loss, round(time.time() - time_last_check, 3)))
time_last_check = time.time()
last_losses = []
if not i % args.sample_iterations and i != 0:
volume, volume_oracle, reward_weight, reward_mean, test_loss, diversity = sample_batch(
args, generator, rollout_worker, oracle, proxy, Y_bounds, compute_multi_objective_metric=False)
args.logger.add_scalar(
'round{}/Top-100-sampled/volumes'.format(round_idx), volume, use_context=False)
args.logger.add_scalar(
'round{}/Top-100-sampled/volumes_oracle'.format(round_idx), volume_oracle, use_context=False)
args.logger.add_scalars(
'round{}/Top-100-sampled/reward_weight'.format(round_idx), reward_weight, use_context=False)
args.logger.add_scalar(
'round{}/Top-100-sampled/reward_mean'.format(round_idx), reward_mean, use_context=False) # reward_mean is a dict, the keys are test_weights
args.logger.add_scalar(
'round{}/Top-100-sampled/test_loss'.format(round_idx), test_loss, use_context=False)
args.logger.add_scalar(
'round{}/Top-100-sampled/dists'.format(round_idx), diversity, use_context=False)
if do_save:
save_stuff(round_idx, i)
stop_everything()
if do_save:
save_stuff(round_idx, i)
checkpoint_path = os.path.join(args.log_dir, f'round_{round_idx}/{i}_generator_checkpoint.pth')
generator.load_state_dict(torch.load(checkpoint_path))
return rollout_worker, {'train_losses': train_losses,
'test_losses': test_losses,
'test_infos': test_infos,
'train_infos': train_infos}
def sample_batch(args, generator, rollout_worker, oracle=None, proxy=None, ref_mols=None, Y_bounds=None, compute_multi_objective_metric=False):
score_succ = {'gsk3b': 0.5, 'jnk3': 0.5, 'drd2': 0.5,
'chemprop_sars': 0.5, 'chemprop_hiv': 0.5, "seh": 0.5,
'qed': 0.6, 'sa': 0.67}
if Y_bounds is None:
Y_bounds = torch.stack([proxy.partitioning.Y.min(
dim=-2).values, proxy.partitioning.Y.max(dim=-2).values])
time_start = time.time()
print(f"Sampling molecules...")
raw_rewards = []
raw_rewards_weight = {}
means = []
picked_mols = []
smis = []
for i, weights in enumerate(rollout_worker.test_weights):
sampled_mols = []
sampled_raw_rewards = []
sampled_means = []
sampled_smis = []
while len(sampled_mols) < args.num_samples:
rollout_worker.rollout(generator, use_rand_policy=False, weights=torch.tensor(weights).unsqueeze(0).to(args.device))
(raw_r, _, m, trajectory_stats, inflow) = rollout_worker.sampled_mols[-1]
sampled_mols.append(m)
sampled_raw_rewards.append(raw_r[0].item())
sampled_means.append(raw_r[1])
sampled_smis.append(m.smiles)
idx_pick = np.argsort(sampled_raw_rewards)[::-1][:int(args.num_samples/len(rollout_worker.test_weights))]
picked_mols.extend(np.array(sampled_mols)[idx_pick].tolist())
means.extend(np.array(sampled_means)[idx_pick].tolist())
smis.extend(np.array(sampled_smis)[idx_pick].tolist())
raw_rewards.extend(np.array(sampled_raw_rewards)[idx_pick].tolist())
raw_rewards_weight[str(weights.cpu())] = np.array(sampled_raw_rewards)[idx_pick].mean()
raw_rewards_mean = np.mean(list(raw_rewards_weight.values()))
assert len(picked_mols) == args.num_samples
top_means = torch.tensor(means)
scores_dict = oracle.batch_get_scores(picked_mols)
scores = torch.tensor(pd.DataFrame.from_dict(scores_dict).values)
test_loss = F.mse_loss(top_means, scores)
hypervolume = Hypervolume(ref_point=torch.zeros(len(args.objectives)))
volume = hypervolume.compute(top_means)
volume_oracle = hypervolume.compute(scores)
diversity = compute_diversity(picked_mols)
batch_metrics = {'Hypervolume_reward': volume,
'Hypervolume_oracle': volume_oracle,
'Reward_mean': raw_rewards_mean,
'scores_max': pd.DataFrame.from_dict(scores_dict).max().to_dict(),
'scores_mean': pd.DataFrame.from_dict(scores_dict).mean().to_dict(),
'Test_loss': test_loss,
'Diversity': diversity}
print(batch_metrics)
print('Time: {}'.format(time.time()-time_start))
if not compute_multi_objective_metric:
return volume, volume_oracle, raw_rewards_weight, raw_rewards_mean, test_loss, diversity
else:
for i in range(len(picked_mols)):
picked_mols[i].score = scores_dict[i]
# success/diversity/novelty is computed among the top mols.
success, positive_mols = compute_success(
picked_mols, scores_dict, args.objectives, score_succ)
succ_diversity = compute_diversity(positive_mols)
if ref_mols:
novelty = compute_novelty(positive_mols, ref_mols)
else:
novelty = 1.
mo_metrics = {'success': success, 'novelty': novelty,
'succ_diversity': succ_diversity, }
picked_smis = [(raw_rewards[i], picked_mols[i].score, smis[i])
for i in range(len(raw_rewards))]
print(mo_metrics)
return (picked_mols, scores_dict, picked_smis), batch_metrics, mo_metrics
def log_overall_metrics(args, dataset, batch_infos=None, MultiObjective_metrics=None):
volume = dataset.compute_hypervolume()
print("Hypervolume for {}: {}".format(args.logger.context, volume))
args.logger.add_scalar('Metric/hypervolume', volume, use_context=False)
args.logger.add_object('scores', dataset.scores)
args.logger.add_object('smis', dataset.smis)
if batch_infos:
args.logger.add_scalar(
'Metric/test_loss', batch_infos['Test_loss'], use_context=False)
args.logger.add_object('collected_info', batch_infos)
if MultiObjective_metrics:
args.logger.add_scalars('Metric/MultiObjective',
MultiObjective_metrics, use_context=False)
def get_test_rays():
if args.n_objectives == 3:
n_partitions = 6
elif args.n_objectives == 4:
n_partitions = 7
test_rays = get_reference_directions("das-dennis", args.n_objectives, n_partitions=n_partitions).astype(np.float32)
test_rays = test_rays[[(r > 0).all() for r in test_rays]]
print(f"initialize {len(test_rays)} test rays")
return test_rays
def main(args):
set_random_seed(args.seed)
args.logger.set_context('iter_0')
bpath = "./data/blocks_105.json"
dpath = "./data/docked_mols.h5"
# Initialize oracle and dataset (for training surrogate function)
oracle = Oracle(args)
dataset = Dataset(args, bpath, oracle, args.device)
dataset.load_h5(dpath, num_init_examples=args.num_init_examples)
log_overall_metrics(args, dataset)
args.n_objectives = len(args.objectives)
# Initialize surrogate function
proxy = get_proxy(args, bpath, oracle)
proxy.update(dataset, 0, reset=False)
for i in range(1, args.num_outer_loop_iters+1):
print(f"====== Starting round {i} ======")
args.logger.set_context('iter_{}'.format(i))
test_weights = np.random.dirichlet(args.alpha_vector, 5*(2**(args.n_objectives-2))).astype(np.float32)
if args.criterion == 'TB': | generator = TBGFlowNet(args, bpath) | 6 | 2023-10-24 14:10:35+00:00 | 24k |
caglarkucuk/earthformer-satellite-to-radar | ef-sat2rad/earthformer/cuboid_transformer/cuboid_transformer_unet_dec.py | [
{
"identifier": "Upsample3DLayer",
"path": "ef-sat2rad/earthformer/cuboid_transformer/cuboid_transformer.py",
"snippet": "class Upsample3DLayer(nn.Module):\n \"\"\"Upsampling based on nn.UpSampling and Conv3x3.\n\n If the temporal dimension remains the same:\n x --> interpolation-2d (neares... | from typing import Sequence, Union
from functools import lru_cache
from collections import OrderedDict
from torch import nn
from einops import rearrange
from .cuboid_transformer import (
Upsample3DLayer, PatchMerging3D, PosEmbed,
InitialEncoder, FinalDecoder,
InitialStackPatchMergingEncoder, FinalStackUpsamplingDecoder,
StackCuboidSelfAttentionBlock, StackCuboidCrossAttentionBlock,
CuboidTransformerEncoder)
from .cuboid_transformer_patterns import CuboidSelfAttentionPatterns, CuboidCrossAttentionPatterns
from .utils import (
get_activation, get_norm_layer,
_generalize_padding, _generalize_unpadding,
apply_initialization, round_to)
import warnings
import torch
import torch.nn.functional as F
import torch.utils.checkpoint as checkpoint | 17,519 | downsample_type=downsample_type,
block_attn_patterns=enc_attn_patterns,
block_cuboid_size=enc_cuboid_size,
block_strategy=enc_cuboid_strategy,
block_shift_size=enc_shift_size,
num_heads=num_heads,
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
gated_ffn=gated_ffn,
ffn_activation=ffn_activation,
norm_layer=norm_layer,
use_inter_ffn=enc_use_inter_ffn,
padding_type=padding_type,
use_global_vector=num_global_vectors > 0,
use_global_vector_ffn=use_global_vector_ffn,
use_global_self_attn=use_global_self_attn,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
self_attn_use_final_proj=self_attn_use_final_proj,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
conv_init_mode=conv_init_mode,
down_linear_init_mode=down_up_linear_init_mode,
norm_init_mode=norm_init_mode,
)
self.enc_pos_embed = PosEmbed(
embed_dim=base_units, typ=pos_embed_type,
maxH=H_in, maxW=W_in, maxT=T_in)
mem_shapes = self.encoder.get_mem_shapes()
self.dec_pos_embed = PosEmbed(
embed_dim=mem_shapes[-1][-1], typ=pos_embed_type,
maxT=T_out, maxH=mem_shapes[-1][1], maxW=mem_shapes[-1][2])
self.unet_dec_cross_mode = unet_dec_cross_mode
self.decoder = CuboidTransformerUNetDecoder(
target_temporal_length=T_out,
mem_shapes=mem_shapes,
cross_start=dec_cross_start,
depth=dec_depth,
upsample_type=upsample_type,
block_self_attn_patterns=dec_self_attn_patterns,
block_self_cuboid_size=dec_self_cuboid_size,
block_self_shift_size=dec_self_shift_size,
block_self_cuboid_strategy=dec_self_cuboid_strategy,
block_cross_attn_patterns=dec_cross_attn_patterns,
block_cross_cuboid_hw=dec_cross_cuboid_hw,
block_cross_shift_hw=dec_cross_shift_hw,
block_cross_cuboid_strategy=dec_cross_cuboid_strategy,
block_cross_n_temporal=dec_cross_n_temporal,
cross_last_n_frames=dec_cross_last_n_frames,
num_heads=num_heads,
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
upsample_kernel_size=upsample_kernel_size,
ffn_activation=ffn_activation,
gated_ffn=gated_ffn,
norm_layer=norm_layer,
use_inter_ffn=dec_use_inter_ffn,
max_temporal_relative=T_in + T_out,
padding_type=padding_type,
hierarchical_pos_embed=dec_hierarchical_pos_embed,
pos_embed_type=pos_embed_type,
use_self_global=(num_global_vectors > 0) and use_dec_self_global,
self_update_global=dec_self_update_global,
use_cross_global=(num_global_vectors > 0) and use_dec_cross_global,
use_global_vector_ffn=use_global_vector_ffn,
use_global_self_attn=use_global_self_attn,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
self_attn_use_final_proj=self_attn_use_final_proj,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
conv_init_mode=conv_init_mode,
up_linear_init_mode=down_up_linear_init_mode,
norm_init_mode=norm_init_mode,
# different from CuboidTransformerDecoder
downsample=downsample,
downsample_type=downsample_type,
cross_mode=unet_dec_cross_mode,
down_linear_init_mode=down_up_linear_init_mode,
)
self.reset_parameters()
def get_initial_encoder_final_decoder(
self,
initial_downsample_type,
activation,
# initial_downsample_type=="conv"
initial_downsample_scale,
initial_downsample_conv_layers,
final_upsample_conv_layers,
padding_type,
# initial_downsample_type == "stack_conv"
initial_downsample_stack_conv_num_layers,
initial_downsample_stack_conv_dim_list,
initial_downsample_stack_conv_downscale_list,
initial_downsample_stack_conv_num_conv_list,
):
T_in, H_in, W_in, C_in = self.input_shape
T_out, H_out, W_out, C_out = self.target_shape
# Construct the initial upsampling / downsampling layers
self.initial_downsample_type = initial_downsample_type
if self.initial_downsample_type == "conv":
if isinstance(initial_downsample_scale, int):
initial_downsample_scale = (1, initial_downsample_scale, initial_downsample_scale)
elif len(initial_downsample_scale) == 2:
initial_downsample_scale = (1, *initial_downsample_scale)
elif len(initial_downsample_scale) == 3:
initial_downsample_scale = tuple(initial_downsample_scale)
else:
raise NotImplementedError(f"initial_downsample_scale {initial_downsample_scale} format not supported!")
# if any(ele > 1 for ele in initial_downsample_scale):
| """CuboidTransformer adapted for auxiliary inputs in decoder"""
class CuboidTransformerUNetDecoder(nn.Module):
"""U-Net style Decoder of the CuboidTransformer.
For each block, we first apply the StackCuboidSelfAttention and then apply the StackCuboidCrossAttention
We add cross attention following 3 modes:
cross_mode == "down":
x --> attn --> cross_attn --> downscale --> ... --> z --> attn --> upscale --> ... --> out
^ ^
| |
| |
mem mem
cross_mode == "up":
x --> attn --> downscale --> ... --> z --> attn --> cross_attn --> upscale --> ... --> out
^ ^
| |
| |
mem mem
cross_mode == "both":
x --> attn --> cross_attn --> downscale --> ... --> z --> attn --> cross_attn --> upscale --> ... --> out
^ ^ ^ ^
| | | |
| | | |
mem mem mem mem
"""
def __init__(self,
target_temporal_length,
mem_shapes,
cross_start=0,
depth=[2, 2],
upsample_type="upsample",
upsample_kernel_size=3,
block_self_attn_patterns=None,
block_self_cuboid_size=[(4, 4, 4), (4, 4, 4)],
block_self_cuboid_strategy=[('l', 'l', 'l'), ('d', 'd', 'd')],
block_self_shift_size=[(1, 1, 1), (0, 0, 0)],
block_cross_attn_patterns=None,
block_cross_cuboid_hw=[(4, 4), (4, 4)],
block_cross_cuboid_strategy=[('l', 'l', 'l'), ('d', 'l', 'l')],
block_cross_shift_hw=[(0, 0), (0, 0)],
block_cross_n_temporal=[1, 2],
cross_last_n_frames=None,
num_heads=4,
attn_drop=0.0,
proj_drop=0.0,
ffn_drop=0.0,
ffn_activation='leaky',
gated_ffn=False,
norm_layer='layer_norm',
use_inter_ffn=False,
hierarchical_pos_embed=False,
pos_embed_type='t+hw',
max_temporal_relative=50,
padding_type='ignore',
checkpoint_level=True,
use_relative_pos=True,
self_attn_use_final_proj=True,
# global vectors
use_self_global=False,
self_update_global=True,
use_cross_global=False,
use_global_vector_ffn=True,
use_global_self_attn=False,
separate_global_qkv=False,
global_dim_ratio=1,
# initialization
attn_linear_init_mode="0",
ffn_linear_init_mode="0",
conv_init_mode="0",
up_linear_init_mode="0",
norm_init_mode="0",
# different from `CuboidTransformerDecoder`, no arg `use_first_self_attn=False`
downsample=2,
downsample_type='patch_merge',
cross_mode="up",
down_linear_init_mode="0",
):
"""
Parameters
----------
target_temporal_length
mem_shapes
cross_start
The block to start cross attention
depth
Depth of each block
downsample
The downsample ratio
downsample_type
Type of the downsampling layer
upsample_type
The type of the upsampling layers
upsample_kernel_size
block_self_attn_patterns
Pattern of the block self attentions
block_self_cuboid_size
block_self_cuboid_strategy
block_self_shift_size
block_cross_attn_patterns
block_cross_cuboid_hw
block_cross_cuboid_strategy
block_cross_shift_hw
block_cross_n_temporal
cross_last_n_frames
cross_mode
Must be one of ("up", "down", "both")
Control whether the upsampling/downsampling/both phases cross attend to the encoded latent features
num_heads
attn_drop
proj_drop
ffn_drop
ffn_activation
gated_ffn
Whether to enable gated ffn or not
norm_layer
The normalization layer
use_inter_ffn
Whether to use intermediate FFN
hierarchical_pos_embed
Whether to add pos embedding for each hierarchy.
max_temporal_relative
padding_type
checkpoint_level
"""
super(CuboidTransformerUNetDecoder, self).__init__()
# initialization mode
self.attn_linear_init_mode = attn_linear_init_mode
self.ffn_linear_init_mode = ffn_linear_init_mode
self.conv_init_mode = conv_init_mode
self.up_linear_init_mode = up_linear_init_mode
self.norm_init_mode = norm_init_mode
assert len(depth) == len(mem_shapes)
self.target_temporal_length = target_temporal_length
self.num_blocks = len(mem_shapes)
self.cross_start = cross_start
self.mem_shapes = mem_shapes
self.block_units = tuple(mem_shape[-1] for mem_shape in self.mem_shapes)
self.depth = depth
if not isinstance(downsample, (tuple, list)):
downsample = (1, downsample, downsample)
self.downsample = downsample
self.downsample_type = downsample_type
self.upsample_type = upsample_type
self.hierarchical_pos_embed = hierarchical_pos_embed
self.checkpoint_level = checkpoint_level
self.use_self_global = use_self_global
self.self_update_global = self_update_global
self.use_cross_global = use_cross_global
self.use_global_vector_ffn = use_global_vector_ffn
assert cross_mode in ["up", "down", "both"], f"Invalid cross_mode {cross_mode}!"
self.cross_mode = cross_mode
self.up_use_cross = self.cross_mode in ["up", "both"]
self.down_use_cross = self.cross_mode in ["down", "both"]
if self.num_blocks > 1:
# Construct downsampling layers
if downsample_type == 'patch_merge':
self.downsample_layers = nn.ModuleList(
[PatchMerging3D(dim=self.block_units[i],
downsample=downsample,
# downsample=(1, 1, 1),
padding_type=padding_type,
out_dim=self.block_units[i + 1],
linear_init_mode=down_linear_init_mode,
norm_init_mode=norm_init_mode)
for i in range(self.num_blocks - 1)])
else:
raise NotImplementedError
# Construct upsampling layers
if self.upsample_type == "upsample":
self.upsample_layers = nn.ModuleList([
Upsample3DLayer(
dim=self.mem_shapes[i + 1][-1],
out_dim=self.mem_shapes[i][-1],
target_size=(target_temporal_length,) + self.mem_shapes[i][1:3],
kernel_size=upsample_kernel_size,
temporal_upsample=False,
conv_init_mode=conv_init_mode,
)
for i in range(self.num_blocks - 1)])
else:
raise NotImplementedError
if self.hierarchical_pos_embed:
self.down_hierarchical_pos_embed_l = nn.ModuleList([
PosEmbed(embed_dim=self.block_units[i], typ=pos_embed_type,
maxT=self.mem_shapes[i][0], maxH=self.mem_shapes[i][1], maxW=self.mem_shapes[i][2])
for i in range(self.num_blocks - 1)])
self.up_hierarchical_pos_embed_l = nn.ModuleList([
PosEmbed(embed_dim=self.block_units[i], typ=pos_embed_type,
maxT=self.mem_shapes[i][0], maxH=self.mem_shapes[i][1], maxW=self.mem_shapes[i][2])
for i in range(self.num_blocks - 1)])
if block_self_attn_patterns is not None:
if isinstance(block_self_attn_patterns, (tuple, list)):
assert len(block_self_attn_patterns) == self.num_blocks
else:
block_self_attn_patterns = [block_self_attn_patterns for _ in range(self.num_blocks)]
block_self_cuboid_size = []
block_self_cuboid_strategy = []
block_self_shift_size = []
for idx, key in enumerate(block_self_attn_patterns):
func = CuboidSelfAttentionPatterns.get(key)
cuboid_size, strategy, shift_size = func(mem_shapes[idx])
block_self_cuboid_size.append(cuboid_size)
block_self_cuboid_strategy.append(strategy)
block_self_shift_size.append(shift_size)
else:
if not isinstance(block_self_cuboid_size[0][0], (list, tuple)):
block_self_cuboid_size = [block_self_cuboid_size for _ in range(self.num_blocks)]
else:
assert len(block_self_cuboid_size) == self.num_blocks,\
f'Incorrect input format! Received block_self_cuboid_size={block_self_cuboid_size}'
if not isinstance(block_self_cuboid_strategy[0][0], (list, tuple)):
block_self_cuboid_strategy = [block_self_cuboid_strategy for _ in range(self.num_blocks)]
else:
assert len(block_self_cuboid_strategy) == self.num_blocks,\
f'Incorrect input format! Received block_self_cuboid_strategy={block_self_cuboid_strategy}'
if not isinstance(block_self_shift_size[0][0], (list, tuple)):
block_self_shift_size = [block_self_shift_size for _ in range(self.num_blocks)]
else:
assert len(block_self_shift_size) == self.num_blocks,\
f'Incorrect input format! Received block_self_shift_size={block_self_shift_size}'
down_self_blocks = []
up_self_blocks = []
for i in range(self.num_blocks):
ele_depth = depth[i]
stack_cuboid_blocks =\
[StackCuboidSelfAttentionBlock(
dim=self.mem_shapes[i][-1],
num_heads=num_heads,
block_cuboid_size=block_self_cuboid_size[i],
block_strategy=block_self_cuboid_strategy[i],
block_shift_size=block_self_shift_size[i],
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
activation=ffn_activation,
gated_ffn=gated_ffn,
norm_layer=norm_layer,
use_inter_ffn=use_inter_ffn,
padding_type=padding_type,
use_global_vector=use_self_global,
use_global_vector_ffn=use_global_vector_ffn,
use_global_self_attn=use_global_self_attn,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
use_final_proj=self_attn_use_final_proj,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
norm_init_mode=norm_init_mode,
) for _ in range(ele_depth)]
down_self_blocks.append(nn.ModuleList(stack_cuboid_blocks))
stack_cuboid_blocks = \
[StackCuboidSelfAttentionBlock(
dim=self.mem_shapes[i][-1],
num_heads=num_heads,
block_cuboid_size=block_self_cuboid_size[i],
block_strategy=block_self_cuboid_strategy[i],
block_shift_size=block_self_shift_size[i],
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
activation=ffn_activation,
gated_ffn=gated_ffn,
norm_layer=norm_layer,
use_inter_ffn=use_inter_ffn,
padding_type=padding_type,
use_global_vector=use_self_global,
use_global_vector_ffn=use_global_vector_ffn,
use_global_self_attn=use_global_self_attn,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
use_final_proj=self_attn_use_final_proj,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
norm_init_mode=norm_init_mode,
) for _ in range(ele_depth)]
up_self_blocks.append(nn.ModuleList(stack_cuboid_blocks))
self.down_self_blocks = nn.ModuleList(down_self_blocks)
self.up_self_blocks = nn.ModuleList(up_self_blocks)
if block_cross_attn_patterns is not None:
if isinstance(block_cross_attn_patterns, (tuple, list)):
assert len(block_cross_attn_patterns) == self.num_blocks
else:
block_cross_attn_patterns = [block_cross_attn_patterns for _ in range(self.num_blocks)]
block_cross_cuboid_hw = []
block_cross_cuboid_strategy = []
block_cross_shift_hw = []
block_cross_n_temporal = []
for idx, key in enumerate(block_cross_attn_patterns):
if key == "last_frame_dst":
cuboid_hw = None
shift_hw = None
strategy = None
n_temporal = None
else:
func = CuboidCrossAttentionPatterns.get(key)
cuboid_hw, shift_hw, strategy, n_temporal = func(mem_shapes[idx])
block_cross_cuboid_hw.append(cuboid_hw)
block_cross_cuboid_strategy.append(strategy)
block_cross_shift_hw.append(shift_hw)
block_cross_n_temporal.append(n_temporal)
else:
if not isinstance(block_cross_cuboid_hw[0][0], (list, tuple)):
block_cross_cuboid_hw = [block_cross_cuboid_hw for _ in range(self.num_blocks)]
else:
assert len(block_cross_cuboid_hw) == self.num_blocks, \
f'Incorrect input format! Received block_cross_cuboid_hw={block_cross_cuboid_hw}'
if not isinstance(block_cross_cuboid_strategy[0][0], (list, tuple)):
block_cross_cuboid_strategy = [block_cross_cuboid_strategy for _ in range(self.num_blocks)]
else:
assert len(block_cross_cuboid_strategy) == self.num_blocks, \
f'Incorrect input format! Received block_cross_cuboid_strategy={block_cross_cuboid_strategy}'
if not isinstance(block_cross_shift_hw[0][0], (list, tuple)):
block_cross_shift_hw = [block_cross_shift_hw for _ in range(self.num_blocks)]
else:
assert len(block_cross_shift_hw) == self.num_blocks, \
f'Incorrect input format! Received block_cross_shift_hw={block_cross_shift_hw}'
if not isinstance(block_cross_n_temporal[0], (list, tuple)):
block_cross_n_temporal = [block_cross_n_temporal for _ in range(self.num_blocks)]
else:
assert len(block_cross_n_temporal) == self.num_blocks, \
f'Incorrect input format! Received block_cross_n_temporal={block_cross_n_temporal}'
if self.up_use_cross:
self.up_cross_blocks = nn.ModuleList()
for i in range(self.cross_start, self.num_blocks):
cross_block = nn.ModuleList(
[StackCuboidCrossAttentionBlock(
dim=self.mem_shapes[i][-1],
num_heads=num_heads,
block_cuboid_hw=block_cross_cuboid_hw[i],
block_strategy=block_cross_cuboid_strategy[i],
block_shift_hw=block_cross_shift_hw[i],
block_n_temporal=block_cross_n_temporal[i],
cross_last_n_frames=cross_last_n_frames,
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
gated_ffn=gated_ffn,
norm_layer=norm_layer,
use_inter_ffn=use_inter_ffn,
activation=ffn_activation,
max_temporal_relative=max_temporal_relative,
padding_type=padding_type,
use_global_vector=use_cross_global,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
norm_init_mode=norm_init_mode,
) for _ in range(depth[i])])
self.up_cross_blocks.append(cross_block)
if self.down_use_cross:
self.down_cross_blocks = nn.ModuleList()
for i in range(self.cross_start, self.num_blocks):
cross_block = nn.ModuleList(
[StackCuboidCrossAttentionBlock(
dim=self.mem_shapes[i][-1],
num_heads=num_heads,
block_cuboid_hw=block_cross_cuboid_hw[i],
block_strategy=block_cross_cuboid_strategy[i],
block_shift_hw=block_cross_shift_hw[i],
block_n_temporal=block_cross_n_temporal[i],
cross_last_n_frames=cross_last_n_frames,
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
gated_ffn=gated_ffn,
norm_layer=norm_layer,
use_inter_ffn=use_inter_ffn,
activation=ffn_activation,
max_temporal_relative=max_temporal_relative,
padding_type=padding_type,
use_global_vector=use_cross_global,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
norm_init_mode=norm_init_mode,
) for _ in range(depth[i])])
self.down_cross_blocks.append(cross_block)
self.reset_parameters()
def reset_parameters(self):
for ms in self.down_self_blocks:
for m in ms:
m.reset_parameters()
for ms in self.up_self_blocks:
for m in ms:
m.reset_parameters()
if self.up_use_cross:
for ms in self.up_cross_blocks:
for m in ms:
m.reset_parameters()
if self.down_use_cross:
for ms in self.down_cross_blocks:
for m in ms:
m.reset_parameters()
if self.num_blocks > 1:
for m in self.downsample_layers:
m.reset_parameters()
for m in self.upsample_layers:
m.reset_parameters()
if self.hierarchical_pos_embed:
for m in self.down_hierarchical_pos_embed_l:
m.reset_parameters()
for m in self.up_hierarchical_pos_embed_l:
m.reset_parameters()
def forward(self, x, mem_l, mem_global_vector_l=None):
"""
Parameters
----------
x
Shape (B, T, H, W, C)
mem_l
A list of memory tensors
Returns
-------
out
"""
B, T, H, W, C = x.shape
assert T == self.target_temporal_length
assert (H, W) == (self.mem_shapes[0][1], self.mem_shapes[0][2])
new_mem_global_vector_l = []
for i in range(self.num_blocks):
# Downample
if i > 0:
x = self.downsample_layers[i - 1](x)
if self.hierarchical_pos_embed:
x = self.down_hierarchical_pos_embed_l[i - 1](x)
mem_global_vector = None if mem_global_vector_l is None else mem_global_vector_l[i]
for idx in range(self.depth[i]):
if self.use_self_global:
if self.self_update_global:
x, mem_global_vector = self.down_self_blocks[i][idx](x, mem_global_vector)
else:
x, _ = self.down_self_blocks[i][idx](x, mem_global_vector)
else:
x = self.down_self_blocks[i][idx](x)
if self.down_use_cross and i >= self.cross_start:
x = self.down_cross_blocks[i - self.cross_start][idx](x, mem_l[i], mem_global_vector)
new_mem_global_vector_l.append(mem_global_vector)
for i in range(self.num_blocks - 1, -1, -1):
mem_global_vector = new_mem_global_vector_l[i]
for idx in range(self.depth[i]):
if self.use_self_global:
if self.self_update_global:
x, mem_global_vector = self.up_self_blocks[i][idx](x, mem_global_vector)
else:
x, _ = self.up_self_blocks[i][idx](x, mem_global_vector)
else:
x = self.up_self_blocks[i][idx](x)
if self.up_use_cross and i >= self.cross_start:
x = self.up_cross_blocks[i - self.cross_start][idx](x, mem_l[i], mem_global_vector)
# Upsample
if i > 0:
x = self.upsample_layers[i - 1](x)
if self.hierarchical_pos_embed:
x = self.up_hierarchical_pos_embed_l[i - 1](x)
return x
class CuboidTransformerAuxModel(nn.Module):
"""Cuboid Transformer with auxiliary input in decoder for spatiotemporal forecasting
We adopt the Non-autoregressive encoder-decoder architecture.
The decoder takes the multi-scale memory output from the encoder, as well as auxiliary input.
The initial downsampling / upsampling layers will be
Downsampling: [K x Conv2D --> PatchMerge]
Upsampling: [Nearest Interpolation-based Upsample --> K x Conv2D]
x -----------> downsample (optional) ---> (+pos_embed) ---> enc ---------> mem_l
| |
|------------------|
|
|
aux_input ---> downsample (optional) ---> (+pos_embed) ---> enc -> cross_attn -> dec -> upsample (optional) -> y
"""
def __init__(self,
input_shape,
target_shape,
base_units=128,
block_units=None,
scale_alpha=1.0,
num_heads=4,
attn_drop=0.0,
proj_drop=0.0,
ffn_drop=0.0,
# inter-attn downsample/upsample
downsample=2,
downsample_type='patch_merge',
upsample_type="upsample",
upsample_kernel_size=3,
# encoder
enc_depth=[4, 4, 4],
enc_attn_patterns=None,
enc_cuboid_size=[(4, 4, 4), (4, 4, 4)],
enc_cuboid_strategy=[('l', 'l', 'l'), ('d', 'd', 'd')],
enc_shift_size=[(0, 0, 0), (0, 0, 0)],
enc_use_inter_ffn=True,
# decoder
dec_depth=[2, 2],
dec_cross_start=0,
dec_self_attn_patterns=None,
dec_self_cuboid_size=[(4, 4, 4), (4, 4, 4)],
dec_self_cuboid_strategy=[('l', 'l', 'l'), ('d', 'd', 'd')],
dec_self_shift_size=[(1, 1, 1), (0, 0, 0)],
dec_cross_attn_patterns=None,
dec_cross_cuboid_hw=[(4, 4), (4, 4)],
dec_cross_cuboid_strategy=[('l', 'l', 'l'), ('d', 'l', 'l')],
dec_cross_shift_hw=[(0, 0), (0, 0)],
dec_cross_n_temporal=[1, 2],
dec_cross_last_n_frames=None,
dec_use_inter_ffn=True,
dec_hierarchical_pos_embed=False,
# global vectors
num_global_vectors=4,
use_dec_self_global=True,
dec_self_update_global=True,
use_dec_cross_global=True,
use_global_vector_ffn=True,
use_global_self_attn=False,
separate_global_qkv=False,
global_dim_ratio=1,
# # initial downsample and final upsample
initial_downsample_type="conv",
initial_downsample_activation="leaky",
# initial_downsample_type=="conv"
initial_downsample_scale=1,
initial_downsample_conv_layers=2,
final_upsample_conv_layers=2,
# initial_downsample_type == "stack_conv"
initial_downsample_stack_conv_num_layers=1,
initial_downsample_stack_conv_dim_list=None,
initial_downsample_stack_conv_downscale_list=[1, ],
initial_downsample_stack_conv_num_conv_list=[2, ],
# # end of initial downsample and final upsample
ffn_activation='leaky',
gated_ffn=False,
norm_layer='layer_norm',
padding_type='ignore',
pos_embed_type='t+hw',
checkpoint_level=True,
use_relative_pos=True,
self_attn_use_final_proj=True,
# initialization
attn_linear_init_mode="0",
ffn_linear_init_mode="0",
conv_init_mode="0",
down_up_linear_init_mode="0",
norm_init_mode="0",
# different from CuboidTransformerModel, no arg `dec_use_first_self_attn=False`
auxiliary_channels: int = 1,
unet_dec_cross_mode="up",
):
"""
Parameters
----------
input_shape
Shape of the input tensor. It will be (T, H, W, C_in)
target_shape
Shape of the input tensor. It will be (T_out, H, W, C_out)
base_units
The base units
"""
super(CuboidTransformerAuxModel, self).__init__()
# initialization mode
self.attn_linear_init_mode = attn_linear_init_mode
self.ffn_linear_init_mode = ffn_linear_init_mode
self.conv_init_mode = conv_init_mode
self.down_up_linear_init_mode = down_up_linear_init_mode
self.norm_init_mode = norm_init_mode
assert len(enc_depth) == len(dec_depth)
self.base_units = base_units
self.num_global_vectors = num_global_vectors
if global_dim_ratio != 1:
assert separate_global_qkv == True, \
f"Setting global_dim_ratio != 1 requires separate_global_qkv == True."
self.global_dim_ratio = global_dim_ratio
self.input_shape = input_shape
self.target_shape = target_shape
T_in, H_in, W_in, C_in = input_shape
T_out, H_out, W_out, C_out = target_shape
assert H_in == H_out and W_in == W_out
self.auxiliary_channels = auxiliary_channels
if self.num_global_vectors > 0:
self.init_global_vectors = nn.Parameter(
torch.zeros((self.num_global_vectors, global_dim_ratio*base_units)))
new_input_shape = self.get_initial_encoder_final_decoder(
initial_downsample_scale=initial_downsample_scale,
initial_downsample_type=initial_downsample_type,
activation=initial_downsample_activation,
# initial_downsample_type=="conv"
initial_downsample_conv_layers=initial_downsample_conv_layers,
final_upsample_conv_layers=final_upsample_conv_layers,
padding_type=padding_type,
# initial_downsample_type == "stack_conv"
initial_downsample_stack_conv_num_layers=initial_downsample_stack_conv_num_layers,
initial_downsample_stack_conv_dim_list=initial_downsample_stack_conv_dim_list,
initial_downsample_stack_conv_downscale_list=initial_downsample_stack_conv_downscale_list,
initial_downsample_stack_conv_num_conv_list=initial_downsample_stack_conv_num_conv_list,
)
T_in, H_in, W_in, _ = new_input_shape
self.encoder = CuboidTransformerEncoder(
input_shape=(T_in, H_in, W_in, base_units),
base_units=base_units,
block_units=block_units,
scale_alpha=scale_alpha,
depth=enc_depth,
downsample=downsample,
downsample_type=downsample_type,
block_attn_patterns=enc_attn_patterns,
block_cuboid_size=enc_cuboid_size,
block_strategy=enc_cuboid_strategy,
block_shift_size=enc_shift_size,
num_heads=num_heads,
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
gated_ffn=gated_ffn,
ffn_activation=ffn_activation,
norm_layer=norm_layer,
use_inter_ffn=enc_use_inter_ffn,
padding_type=padding_type,
use_global_vector=num_global_vectors > 0,
use_global_vector_ffn=use_global_vector_ffn,
use_global_self_attn=use_global_self_attn,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
self_attn_use_final_proj=self_attn_use_final_proj,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
conv_init_mode=conv_init_mode,
down_linear_init_mode=down_up_linear_init_mode,
norm_init_mode=norm_init_mode,
)
self.enc_pos_embed = PosEmbed(
embed_dim=base_units, typ=pos_embed_type,
maxH=H_in, maxW=W_in, maxT=T_in)
mem_shapes = self.encoder.get_mem_shapes()
self.dec_pos_embed = PosEmbed(
embed_dim=mem_shapes[-1][-1], typ=pos_embed_type,
maxT=T_out, maxH=mem_shapes[-1][1], maxW=mem_shapes[-1][2])
self.unet_dec_cross_mode = unet_dec_cross_mode
self.decoder = CuboidTransformerUNetDecoder(
target_temporal_length=T_out,
mem_shapes=mem_shapes,
cross_start=dec_cross_start,
depth=dec_depth,
upsample_type=upsample_type,
block_self_attn_patterns=dec_self_attn_patterns,
block_self_cuboid_size=dec_self_cuboid_size,
block_self_shift_size=dec_self_shift_size,
block_self_cuboid_strategy=dec_self_cuboid_strategy,
block_cross_attn_patterns=dec_cross_attn_patterns,
block_cross_cuboid_hw=dec_cross_cuboid_hw,
block_cross_shift_hw=dec_cross_shift_hw,
block_cross_cuboid_strategy=dec_cross_cuboid_strategy,
block_cross_n_temporal=dec_cross_n_temporal,
cross_last_n_frames=dec_cross_last_n_frames,
num_heads=num_heads,
attn_drop=attn_drop,
proj_drop=proj_drop,
ffn_drop=ffn_drop,
upsample_kernel_size=upsample_kernel_size,
ffn_activation=ffn_activation,
gated_ffn=gated_ffn,
norm_layer=norm_layer,
use_inter_ffn=dec_use_inter_ffn,
max_temporal_relative=T_in + T_out,
padding_type=padding_type,
hierarchical_pos_embed=dec_hierarchical_pos_embed,
pos_embed_type=pos_embed_type,
use_self_global=(num_global_vectors > 0) and use_dec_self_global,
self_update_global=dec_self_update_global,
use_cross_global=(num_global_vectors > 0) and use_dec_cross_global,
use_global_vector_ffn=use_global_vector_ffn,
use_global_self_attn=use_global_self_attn,
separate_global_qkv=separate_global_qkv,
global_dim_ratio=global_dim_ratio,
checkpoint_level=checkpoint_level,
use_relative_pos=use_relative_pos,
self_attn_use_final_proj=self_attn_use_final_proj,
# initialization
attn_linear_init_mode=attn_linear_init_mode,
ffn_linear_init_mode=ffn_linear_init_mode,
conv_init_mode=conv_init_mode,
up_linear_init_mode=down_up_linear_init_mode,
norm_init_mode=norm_init_mode,
# different from CuboidTransformerDecoder
downsample=downsample,
downsample_type=downsample_type,
cross_mode=unet_dec_cross_mode,
down_linear_init_mode=down_up_linear_init_mode,
)
self.reset_parameters()
def get_initial_encoder_final_decoder(
self,
initial_downsample_type,
activation,
# initial_downsample_type=="conv"
initial_downsample_scale,
initial_downsample_conv_layers,
final_upsample_conv_layers,
padding_type,
# initial_downsample_type == "stack_conv"
initial_downsample_stack_conv_num_layers,
initial_downsample_stack_conv_dim_list,
initial_downsample_stack_conv_downscale_list,
initial_downsample_stack_conv_num_conv_list,
):
T_in, H_in, W_in, C_in = self.input_shape
T_out, H_out, W_out, C_out = self.target_shape
# Construct the initial upsampling / downsampling layers
self.initial_downsample_type = initial_downsample_type
if self.initial_downsample_type == "conv":
if isinstance(initial_downsample_scale, int):
initial_downsample_scale = (1, initial_downsample_scale, initial_downsample_scale)
elif len(initial_downsample_scale) == 2:
initial_downsample_scale = (1, *initial_downsample_scale)
elif len(initial_downsample_scale) == 3:
initial_downsample_scale = tuple(initial_downsample_scale)
else:
raise NotImplementedError(f"initial_downsample_scale {initial_downsample_scale} format not supported!")
# if any(ele > 1 for ele in initial_downsample_scale): | self.initial_encoder = InitialEncoder(dim=C_in, | 3 | 2023-10-23 11:45:50+00:00 | 24k |
IBM/VillanDiffusion | loss.py | [
{
"identifier": "Backdoor",
"path": "dataset.py",
"snippet": "class Backdoor():\n CHANNEL_LAST = -1\n CHANNEL_FIRST = -3\n \n GREY_BG_RATIO = 0.3\n \n STOP_SIGN_IMG = \"static/stop_sign_wo_bg.png\"\n # STOP_SIGN_IMG = \"static/stop_sign_bg_blk.jpg\"\n CAT_IMG = \"static/cat_wo_bg... | import copy
import torch
import torch.nn.functional as F
import os
from functools import partial
from os import terminal_size
from sched import scheduler
from typing import Callable, Dict, List, Tuple, Union
from torch import nn
from matplotlib import pyplot as plt
from dataset import Backdoor, DEFAULT_VMIN, DEFAULT_VMAX
from model import DiffuserModelSched
from diffusers import DDPMScheduler
from dataset import DatasetLoader
from model import DiffuserModelSched | 17,665 | ws.append((sigma_i ** 2 - residuals[i]) ** 0.5)
return torch.Tensor(ws)
def get_hs_ve(rhos_hat: torch.Tensor) -> torch.Tensor:
hs = [rhos_hat[0]]
residuals = [0]
for i, rho_hat_i in enumerate(rhos_hat):
if i < 1:
continue
residuals.append(hs[i - 1] + residuals[i - 1])
hs.append(rho_hat_i - residuals[i])
return torch.Tensor(hs)
def get_R_coef_gen_ve(sigmas: torch.Tensor, rhos_hat: torch.Tensor,
ws: torch.Tensor, hs: torch.Tensor, psi: float=1,
solver_type: str='sde', vp_scale: float=1.0,
ve_scale: float=1.0) -> Tuple[torch.Tensor, torch.Tensor]:
# BadDiffusion style correction term, None
if psi != 0:
raise NotImplementedError(f"Variance Explode model doesn't support BadDiffusion style correction term")
# TrojDiff style correction term
if hs == None:
raise ValueError(f"Arguement hs shouldn't be {hs} when psi is {psi}")
prev_rhos_hat = torch.roll(rhos_hat, 1, 0)
prev_rhos_hat[0] = 0
prev_sigmas = torch.roll(sigmas, 1, 0)
prev_sigmas[0] = 0
trojdiff_step = rhos_hat
trojdiff_coef = ve_scale * (ws ** 2 * (rhos_hat - prev_rhos_hat) + hs * prev_sigmas) / (ws ** 2 * sigmas)
# print(f"trojdiff_coef isnan: {torch.isnan(trojdiff_coef)}")
# Coefficients & Steps
step = trojdiff_step
coef = trojdiff_coef
if str(solver_type).lower() == 'ode':
return step, 2 * coef
elif str(solver_type).lower() == 'sde':
return step, coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_R_coef_gen_ve_reduce(sigmas: torch.Tensor, hs: torch.Tensor, rhos_hat_w: float=1.0, psi: float=1,
solver_type: str='sde', vp_scale: float=1.0,
ve_scale: float=1.0) -> Tuple[torch.Tensor, torch.Tensor]:
# BadDiffusion style correction term, None
if psi != 0:
raise NotImplementedError(f"Variance Explode model doesn't support BadDiffusion style correction term")
# TrojDiff style correction term
if hs == None:
raise ValueError(f"Arguement hs shouldn't be {hs} when psi is {psi}")
# prev_rhos_hat = torch.roll(rhos_hat, 1, 0)
# prev_rhos_hat[0] = 0
prev_sigmas = torch.roll(sigmas, 1, 0)
prev_sigmas[0] = 0
trojdiff_step = rhos_hat_w * sigmas
trojdiff_coef = ve_scale * (sigmas * rhos_hat_w / (sigmas + prev_sigmas))
# print(f"trojdiff_coef isnan: {torch.isnan(trojdiff_coef)}")
# Coefficients & Steps
step = trojdiff_step
coef = trojdiff_coef
if str(solver_type).lower() == 'ode':
return step, 2 * coef
elif str(solver_type).lower() == 'sde':
return step, coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_hs_vp(alphas: torch.Tensor, alphas_cumprod: torch.Tensor) -> torch.Tensor:
hs = [(1 - alphas_cumprod[0]) ** 0.5]
residuals = [0]
for i, (alphas_cumprod_i, alphas_i) in enumerate(zip(alphas_cumprod, alphas)):
if i < 1:
continue
residuals.append((alphas_i ** 0.5) * (hs[i - 1] + residuals[i - 1]))
hs.append((1 - alphas_cumprod_i) ** 0.5 - residuals[i])
return torch.Tensor(hs)
def get_R_coef_gen_vp(alphas_cumprod: torch.Tensor, alphas: torch.Tensor,
hs: torch.Tensor=None, psi: float=1, solver_type: str='sde',
vp_scale: float=1.0, ve_scale: float=1.0) -> Tuple[torch.Tensor, torch.Tensor]:
# BadDiffusion style correction term
baddiff_step = 1 - alphas_cumprod ** 0.5
baddiff_coef = vp_scale * (1 - alphas ** 0.5) * (1 - alphas_cumprod) ** 0.5 / (1 - alphas)
# TrojDiff style correction term
if psi != 1:
if hs == None:
raise ValueError(f"Arhuement hs shouldn't be {hs} when psi is {psi}")
trojdiff_step = (1 - alphas_cumprod) ** 0.5
trojdiff_coef = - ve_scale * ((alphas ** 0.5 - 1) * (1 - alphas_cumprod) ** 0.5 * (1 - alphas) - hs * (alphas - alphas_cumprod)) / (1 - alphas)
# Coefficients & Steps
step = psi * baddiff_step + (1 - psi) * trojdiff_step
coef = psi * baddiff_coef + (1 - psi) * trojdiff_coef
else:
# Coefficients & Steps
step = baddiff_step
coef = baddiff_coef
if str(solver_type).lower() == 'ode':
return step, 2 * coef
elif str(solver_type).lower() == 'sde':
return step, coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_R_coef_elbo_gen(noise_sched, sde_type: str="vp", psi: float=1, solver_type: str='sde',
vp_scale: float=1.0, ve_scale: float=1.0, device=None, dtype=None,
rhos_hat_w: float=1.0, rhos_hat_b: float=0.0) -> Tuple[torch.Tensor, torch.Tensor]:
| # %%
# from tmp_loss_sde import q_sample_diffuser_alt_half
"""## Defining the forward diffusion process
The forward diffusion process gradually adds noise to an image from the real distribution, in a number of time steps $T$. This happens according to a **variance schedule**. The original DDPM authors employed a linear schedule:
> We set the forward process variances to constants
increasing linearly from $\beta_1 = 10^{−4}$
to $\beta_T = 0.02$.
However, it was shown in ([Nichol et al., 2021](https://arxiv.org/abs/2102.09672)) that better results can be achieved when employing a cosine schedule.
Below, we define various schedules for the $T$ timesteps, as well as corresponding variables which we'll need, such as cumulative variances.
"""
def cosine_beta_schedule(timesteps, s=0.008):
"""
cosine schedule as proposed in https://arxiv.org/abs/2102.09672
"""
steps = timesteps + 1
x = torch.linspace(0, timesteps, steps)
alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2
alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
return torch.clip(betas, 0.0001, 0.9999)
def linear_beta_schedule(timesteps):
beta_start = 0.0001
beta_end = 0.02
return torch.linspace(beta_start, beta_end, timesteps)
def quadratic_beta_schedule(timesteps):
beta_start = 0.0001
beta_end = 0.02
return torch.linspace(beta_start**0.5, beta_end**0.5, timesteps) ** 2
def sigmoid_beta_schedule(timesteps):
beta_start = 0.0001
beta_end = 0.02
betas = torch.linspace(-6, 6, timesteps)
return torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
def extract(a, t, x_shape):
batch_size = t.shape[0]
out = a.gather(-1, t.cpu())
return out.reshape(batch_size, *((1,) * (len(x_shape) - 1))).to(t.device)
class NoiseScheduler():
SCHED_COSINE = "SC_COS"
SCHED_LINEAR = "SC_LIN"
SCHED_QUADRATIC = "SC_QUAD"
SCHED_SIGMOID = "SC_SIGM"
def __init__(self, timesteps: int, scheduler: str, s: float=0.008):
self.__timesteps = int(timesteps)
self.__s = float(s)
self.__scheduler = scheduler
# define beta schedule
if self.__scheduler == self.SCHED_COSINE:
self.__betas = NoiseScheduler.cosine_beta_schedule(timesteps=self.__timesteps, s=self.__s)
elif self.__scheduler == self.SCHED_LINEAR:
self.__betas = NoiseScheduler.linear_beta_schedule(timesteps=self.__timesteps)
self.__derivative_beta = 1 / self.__timesteps
self.__derivative_alpha = - 1 / self.__timesteps
elif self.__scheduler == self.SCHED_QUADRATIC:
self.__betas = NoiseScheduler.quadratic_beta_schedule(timesteps=self.__timesteps)
elif self.__scheduler == self.SCHED_SIGMOID:
self.__betas = NoiseScheduler.sigmoid_beta_schedule(timesteps=self.__timesteps)
else:
raise ImportError(f"Undefined scheduler: {self.__scheduler}")
# define alphas
self.__alphas = 1. - self.betas
self.__alphas_cumprod = torch.cumprod(self.alphas, axis=0)
self.__alphas_cumprod_prev = F.pad(self.alphas_cumprod[:-1], (1, 0), value=1.0)
self.__sqrt_recip_alphas = torch.sqrt(1.0 / self.alphas)
# Calculations for backdoor
self.__sqrt_alphas = torch.sqrt(self.alphas)
self.__one_minus_sqrt_alphas = 1 - self.sqrt_alphas
self.__one_minus_alphas = 1 - self.alphas
# calculations for diffusion q(x_t | x_{t-1}) and others
self.__sqrt_alphas_cumprod = torch.sqrt(self.alphas_cumprod)
self.__sqrt_one_minus_alphas_cumprod = torch.sqrt(1. - self.alphas_cumprod)
self.__R_coef = self.one_minus_sqrt_alphas * self.sqrt_one_minus_alphas_cumprod / self.one_minus_alphas
# calculations for posterior q(x_{t-1} | x_t, x_0)
self.__posterior_variance = self.betas * (1. - self.alphas_cumprod_prev) / (1. - self.alphas_cumprod)
@staticmethod
def cosine_beta_schedule(timesteps, s=0.008):
"""
cosine schedule as proposed in https://arxiv.org/abs/2102.09672
"""
steps = timesteps + 1
x = torch.linspace(0, timesteps, steps)
alphas_cumprod = torch.cos(((x / timesteps) + s) / (1 + s) * torch.pi * 0.5) ** 2
alphas_cumprod = alphas_cumprod / alphas_cumprod[0]
betas = 1 - (alphas_cumprod[1:] / alphas_cumprod[:-1])
return torch.clip(betas, 0.0001, 0.9999)
@staticmethod
def linear_beta_schedule(timesteps):
beta_start = 0.0001
beta_end = 0.02
return torch.linspace(beta_start, beta_end, timesteps)
@staticmethod
def quadratic_beta_schedule(timesteps):
beta_start = 0.0001
beta_end = 0.02
return torch.linspace(beta_start**0.5, beta_end**0.5, timesteps) ** 2
@staticmethod
def sigmoid_beta_schedule(timesteps):
beta_start = 0.0001
beta_end = 0.02
betas = torch.linspace(-6, 6, timesteps)
return torch.sigmoid(betas) * (beta_end - beta_start) + beta_start
@property
def betas(self):
return self.__betas
@property
def alphas(self):
return self.__alphas
@property
def alphas_cumprod(self):
return self.__alphas_cumprod
@property
def alphas_cumprod_prev(self):
return self.__alphas_cumprod_prev
@property
def sqrt_recip_alphas(self):
return self.__sqrt_recip_alphas
@property
def sqrt_alphas(self):
return self.__sqrt_alphas
@property
def one_minus_sqrt_alphas(self):
return self.__one_minus_sqrt_alphas
@property
def one_minus_alphas(self):
return self.__one_minus_alphas
@property
def sqrt_alphas_cumprod(self):
return self.__sqrt_alphas_cumprod
@property
def sqrt_one_minus_alphas_cumprod(self):
return self.__sqrt_one_minus_alphas_cumprod
@property
def R_coef(self):
return self.__R_coef
@property
def posterior_variance(self):
return self.__posterior_variance
"""<img src="https://drive.google.com/uc?id=1QifsBnYiijwTqru6gur9C0qKkFYrm-lN" width="800" />
This means that we can now define the loss function given the model as follows:
"""
# forward diffusion
def q_sample_clean(noise_sched, x_start, t, noise=None):
if noise is None:
noise = torch.randn_like(x_start)
sqrt_alphas_cumprod_t = extract(noise_sched.sqrt_alphas_cumprod, t, x_start.shape)
sqrt_one_minus_alphas_cumprod_t = extract(
noise_sched.sqrt_one_minus_alphas_cumprod, t, x_start.shape
)
return sqrt_alphas_cumprod_t * x_start + sqrt_one_minus_alphas_cumprod_t * noise, noise
def q_sample_backdoor(noise_sched, x_start, R, t, noise=None):
if noise is None:
noise = torch.randn_like(x_start)
sqrt_alphas_cumprod_t = extract(noise_sched.sqrt_alphas_cumprod, t, x_start.shape)
sqrt_one_minus_alphas_cumprod_t = extract(
noise_sched.sqrt_one_minus_alphas_cumprod, t, x_start.shape
)
R_coef_t = extract(noise_sched.R_coef, t, x_start.shape)
return sqrt_alphas_cumprod_t * x_start + (1 - sqrt_alphas_cumprod_t) * R + sqrt_one_minus_alphas_cumprod_t * noise, R_coef_t * R + noise
"""
<img src="https://drive.google.com/uc?id=1QifsBnYiijwTqru6gur9C0qKkFYrm-lN" width="800" />
This means that we can now define the loss function given the model as follows:
"""
def p_losses_clean(noise_sched, denoise_model, x_start, t, noise=None, loss_type="l2"):
if len(x_start) == 0:
return 0
if noise is None:
noise = torch.randn_like(x_start)
x_noisy, target = q_sample_clean(noise_sched=noise_sched, x_start=x_start, t=t, noise=noise)
predicted_noise = denoise_model(x_noisy, t)
if loss_type == 'l1':
loss = F.l1_loss(target, predicted_noise)
elif loss_type == 'l2':
loss = F.mse_loss(target, predicted_noise)
elif loss_type == "huber":
loss = F.smooth_l1_loss(target, predicted_noise)
else:
raise NotImplementedError()
return loss
def p_losses_backdoor(noise_sched, denoise_model, x_start, R, t, noise=None, loss_type="l2"):
if len(x_start) == 0:
return 0
if noise is None:
noise = torch.randn_like(x_start)
x_noisy, target = q_sample_backdoor(noise_sched=noise_sched, x_start=x_start, R=R, t=t, noise=noise)
predicted_noise = denoise_model(x_noisy, t)
if loss_type == 'l1':
loss = F.l1_loss(target, predicted_noise)
elif loss_type == 'l2':
loss = F.mse_loss(target, predicted_noise)
elif loss_type == "huber":
loss = F.smooth_l1_loss(target, predicted_noise)
else:
raise NotImplementedError()
return loss
def p_losses(noise_sched, denoise_model, x_start, R, is_clean, t, noise=None, loss_type="l2"):
is_not_clean = torch.where(is_clean, False, True)
if noise != None:
noise_clean = noise[is_clean]
noise_backdoor = noise[is_not_clean]
else:
noise_clean = noise_backdoor = noise
loss_clean = p_losses_clean(noise_sched=noise_sched, denoise_model=denoise_model, x_start=x_start[is_clean], t=t[is_clean], noise=noise_clean, loss_type=loss_type)
loss_backdoor = p_losses_backdoor(noise_sched=noise_sched, denoise_model=denoise_model, x_start=x_start[is_not_clean], R=R[is_not_clean], t=t[is_not_clean], noise=noise_backdoor, loss_type=loss_type)
return (loss_clean + loss_backdoor) / 2
# ==================================================
class LossSampler():
def __init__(self, noise_sched: NoiseScheduler):
self.__noise_sched = noise_sched
def get_fn(self):
return partial(p_losses_backdoor, self.__noise_sched), partial(q_sample_backdoor, self.__noise_sched)
def plot(x, title: str, log_scale: bool=False):
plt.plot(x)
plt.title(title)
if log_scale:
plt.yscale("log")
plt.show()
def get_derivative(x: torch.Tensor, t: int):
if t + 1 < len(x):
return x[t + 1] - x[t]
return x[t] - x[t - 1]
def get_derivatives(x: torch.Tensor):
x_delta_t = torch.roll(x, -1, 0)
x_delta_t[-1] = x_delta_t[-2]
x[-1] = x[-2]
return x_delta_t - x
def central_derivative(fn, x, stop_thres: float=1e-5, stop_iter_n: int=50, delta: float=1e-2, divisor: float=10.0):
der = lambda d: (fn(x + d) - fn(x - d)) / (2 * d)
iter_n = 0
res = der(delta)
last_res = 0
while (abs(res - last_res) > stop_thres or iter_n < 1) and iter_n < stop_iter_n:
last_res = res
delta = delta / divisor
res = der(delta)
iter_n = iter_n + 1
return res
def get_alpha_beta_fn_linear(beta_start: float, beta_end: float, timesteps: int):
def beta_fn(t):
return float(beta_start) + (float(beta_end) - float(beta_start)) * t / (float(timesteps) - 1.0)
def alpha_fn(t):
return 1.0 - beta_fn(t)
return alpha_fn, beta_fn
def integral(fn: Callable[[Union[int, float]], Union[int, float]], interval_low: float, interval_up: float, div: int=100):
lin_space = torch.linspace(interval_low, interval_up, div, dtype=torch.float32)
res = fn(lin_space[:-1])
return torch.sum(res, dim=0) * (interval_up - interval_low) / div
def prod_integral(xs: torch.Tensor, x_fn: Callable[[Union[int, float]], Union[int, float]], div: int=200):
def log_x_fn(x):
return torch.log(x_fn(x).double()).double()
def integral_fn(x):
return (torch.trapezoid(log_x_fn(torch.linspace(0, x, div * int(x)).to('cpu').double())) / div).double()
def exp_integral_fn(x):
return torch.exp(integral_fn(x)).double()
return torch.linspace(start=0, end=len(xs)-1, steps=len(xs)).to('cpu').double().apply_(exp_integral_fn).float()
def get_alphas_cumprod_derivative(alphas: torch.Tensor, alpha_fn: Callable[[Union[int, float]], Union[int, float]]):
div = 200
def log_alpha_fn(x):
return torch.log(alpha_fn(x).double()).double()
def integral_fn(x):
return (torch.trapezoid(log_alpha_fn(torch.linspace(0, x, div * int(x)).to('cpu').double())) / div).double()
def exp_integral_fn(x):
return torch.exp(integral_fn(x)).double()
def der_fn(x):
return central_derivative(exp_integral_fn, x, stop_thres=1e-3, stop_iter_n=2, delta=1e-2, divisor=10.0)
def coef_fn(x):
return (exp_integral_fn(x) * torch.log(alpha_fn(torch.Tensor([x]).double()))).double()
# fn_int = torch.linspace(start=0, end=len(alphas)-1, steps=len(alphas)).double().apply_(integral_fn)
# fn_prod_int = torch.linspace(start=0, end=len(alphas)-1, steps=len(alphas)).double().apply_(exp_integral_fn)
# for i in range(len(fn_prod_int[:20])):
# print(f"Time: {i} - Alpha Fn Product Integral Analytic: {fn_prod_int[i]}")
# plot(fn_prod_int, title="Alpha Fn Product Integral", log_scale=True)
# print(f"fn_int: {fn_int[:20]}")
# plot(fn_int, title="Alpha Fn Integral")
res = torch.linspace(start=0, end=len(alphas)-1, steps=len(alphas)).to('cpu').float().apply_(coef_fn).double()
return res
# return torch.exp(integral_res) * (torch.log(alphas[-1]) - torch.log(alphas[0]))
def get_alphas_hat_derivative(alphas_cumprod: torch.Tensor, alphas: torch.Tensor, alpha_fn: Callable[[Union[int, float]], Union[int, float]]):
return get_alphas_cumprod_derivative(alphas=alphas, alpha_fn=alpha_fn).to(alphas_cumprod.device) / 2 * (alphas_cumprod ** 0.5)
def get_sigmas_hat_derivative(alphas_cumprod: torch.Tensor, alphas: torch.Tensor, alpha_fn: Callable[[Union[int, float]], Union[int, float]]):
return - get_alphas_cumprod_derivative(alphas=alphas, alpha_fn=alpha_fn).to(alphas_cumprod.device) / 2 * ((1 - alphas_cumprod) ** 0.5)
def sci(x: float):
return "{:.2e}".format(x)
def get_R_coef_alt(alphas_cumprod: torch.Tensor, alphas: torch.Tensor, alpha_fn: Callable[[Union[int, float]], Union[int, float]], psi: float=1, solver_type: str='sde'):
one_minus_alphas_cumprod = 1 - alphas_cumprod
# Fokker-Planck: g^2(t) = derivative of \hat{\beta}^2(t)
# coef = psi * (torch.sqrt(one_minus_alphas_cumprod / alphas_cumprod)) + (1 - psi)
# g^2(t) = \frac{d \hat{\beta}^2(t)}{dt} - 2 * \frac{d \log \hat{\alpha}(t)}{dt} * \hat{\beta}^2(t)
coef = (psi * (torch.sqrt(one_minus_alphas_cumprod / alphas_cumprod)) + (1 - psi)) / (1 + (one_minus_alphas_cumprod / alphas_cumprod))
# Simplified
# coef = torch.ones_like(alphas_cumprod)
if str(solver_type).lower() == 'ode':
return coef
elif str(solver_type).lower() == 'sde':
return 0.5 * coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_R_coef_variational(alphas_cumprod: torch.Tensor, psi: float=1, solver_type: str='sde'):
coef = psi * (1 - alphas_cumprod ** 0.5) / (1 - alphas_cumprod) ** 0.5 + (1 - psi)
if str(solver_type).lower() == 'ode':
return 2 * coef
elif str(solver_type).lower() == 'sde':
return coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
# def get_R_coef_baddiff(alphas_cumprod: torch.Tensor, psi: float=1, solver_type: str='sde'):
# coef = psi * (1 - alphas_cumprod ** 0.5) / (1 - alphas_cumprod) ** 0.5 + (1 - psi)
# if str(solver_type).lower() == 'ode':
# return 2 * coef
# elif str(solver_type).lower() == 'sde':
# return coef
# else:
# raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_R_coef(alphas_cumprod: torch.Tensor, alphas: torch.Tensor, alpha_fn: Callable[[Union[int, float]], Union[int, float]], psi: float=1):
alphas_hat = (alphas_cumprod ** 0.5).double()
sigmas_hat = ((1 - alphas_cumprod) ** 0.5).double()
alphas_hat_derivative = get_alphas_hat_derivative(alphas_cumprod=alphas_cumprod, alphas=alphas, alpha_fn=alpha_fn).double()
sigmas_hat_derivative = get_sigmas_hat_derivative(alphas_cumprod=alphas_cumprod, alphas=alphas, alpha_fn=alpha_fn).double()
alt_r = 0.5 * alphas_hat / (alphas_hat + sigmas_hat)
# plot(alt_r, title="Alternate R", log_scale=True)
a = (- psi * alphas_hat_derivative + (1 - psi) * sigmas_hat_derivative).double()
b = (psi * (1 - alphas_hat) + (1 - psi) * sigmas_hat).double()
c = (2 * sigmas_hat * sigmas_hat_derivative - 2 * (alphas_hat_derivative / alphas_hat) * (sigmas_hat ** 2)).double()
# plot(alpha_fn(torch.linspace(0, 999, 1000).float()), title="Alpha Fn", log_scale=True)
# fn_cumprod = torch.cumprod(alpha_fn(torch.linspace(0, 999, 1000).float()), dim=0)
# for i in range(len(fn_cumprod[:20])):
# print(f"Time: {i} - Alpha Fn Cumprod: {fn_cumprod[i]}")
# plot(fn_cumprod, title="Alpha Fn Cumprod", log_scale=True)
# plot(alphas, title="Alpha")
# for i in range(len(alphas_cumprod[:20])):
# print(f"Time: {i} - Alpha Cumprod: {alphas_cumprod[i]}")
# plot(alphas_cumprod, title="Alpha Cumprod", log_scale=True)
# plot(get_alphas_cumprod_derivative(alphas=alphas, alpha_fn=alpha_fn), title="Alpha Cumprod Derivative Anlytic")
# plot(get_derivatives(x=alphas_cumprod)[:-1], title="Alpha Cumprod Derivative Numeric")
# plot(alphas_hat, title="Alpha Hat", log_scale=True)
# plot(sigmas_hat, title="Beta Hat", log_scale=True)
# plot(alphas_hat_derivative, title="Alpha Hat Derivative")
# plot(sigmas_hat_derivative, title="Sigma Hat Derivative")
# plot(a, title="Rho Derivative")
# plot(b, title="Rho")
# plot(c, title="G^2", log_scale=True)
# plot(alphas_hat_derivative / alphas_hat, title="f(t)")
coef = (sigmas_hat * a / (c)).double()
# for i in range(len(sigmas_hat[:20])):
# print(f"Time: {i} - R: {sci(coef[i])} beta_hat: {sci(sigmas_hat[i])}, rho_deriv: {sci(a[i])}, G^2: {sci(c[i])}")
if torch.isnan(sigmas_hat).any():
print(f"sigmas_hat - Nan: {sigmas_hat[torch.isnan(sigmas_hat).nonzero()]}")
if torch.isnan(a).any():
print(f"Rho Derivative - Nan: {a[torch.isnan(a).nonzero()]}")
if torch.isnan(b).any():
print(f"Rho - Nan: {b[torch.isnan(b).nonzero()]}")
if torch.isnan(c).any():
print(f"G^2 - Nan: {c[torch.isnan(c).nonzero()]}")
# return torch.clamp(coef, min=None, max=1)
# return coef
return alt_r
def get_ks(alphas_hat: torch.Tensor) -> torch.Tensor:
prev_alphas_hat = torch.roll(alphas_hat, 1, 0)
prev_alphas_hat[0] = 1
return alphas_hat / prev_alphas_hat
def get_ws(betas_hat: torch.Tensor, ks: torch.Tensor) -> torch.Tensor:
ws = [betas_hat[0]]
residuals = [0]
for i, beta_hat_i in enumerate(betas_hat):
if i < 1:
continue
residuals.append((ks[i] ** 2) * (ws[i - 1] ** 2 + residuals[i - 1]))
ws.append((beta_hat_i ** 2 - residuals[i]) ** 0.5)
return torch.Tensor(ws)
def get_hs(rhos_hat: torch.Tensor, ks: torch.Tensor) -> torch.Tensor:
hs = [rhos_hat[0]]
residuals = [0]
for i, rho_hat_i in enumerate(rhos_hat):
if i < 1:
continue
residuals.append(ks[i] * (hs[i - 1] + residuals[i - 1]))
hs.append(rho_hat_i - residuals[i])
return torch.Tensor(hs)
def get_ws_ve(sigmas: torch.Tensor) -> torch.Tensor:
ws = [sigmas[0]]
residuals = [0]
for i, sigma_i in enumerate(sigmas):
if i < 1:
continue
residuals.append(ws[i - 1] ** 2 + residuals[i - 1])
ws.append((sigma_i ** 2 - residuals[i]) ** 0.5)
return torch.Tensor(ws)
def get_hs_ve(rhos_hat: torch.Tensor) -> torch.Tensor:
hs = [rhos_hat[0]]
residuals = [0]
for i, rho_hat_i in enumerate(rhos_hat):
if i < 1:
continue
residuals.append(hs[i - 1] + residuals[i - 1])
hs.append(rho_hat_i - residuals[i])
return torch.Tensor(hs)
def get_R_coef_gen_ve(sigmas: torch.Tensor, rhos_hat: torch.Tensor,
ws: torch.Tensor, hs: torch.Tensor, psi: float=1,
solver_type: str='sde', vp_scale: float=1.0,
ve_scale: float=1.0) -> Tuple[torch.Tensor, torch.Tensor]:
# BadDiffusion style correction term, None
if psi != 0:
raise NotImplementedError(f"Variance Explode model doesn't support BadDiffusion style correction term")
# TrojDiff style correction term
if hs == None:
raise ValueError(f"Arguement hs shouldn't be {hs} when psi is {psi}")
prev_rhos_hat = torch.roll(rhos_hat, 1, 0)
prev_rhos_hat[0] = 0
prev_sigmas = torch.roll(sigmas, 1, 0)
prev_sigmas[0] = 0
trojdiff_step = rhos_hat
trojdiff_coef = ve_scale * (ws ** 2 * (rhos_hat - prev_rhos_hat) + hs * prev_sigmas) / (ws ** 2 * sigmas)
# print(f"trojdiff_coef isnan: {torch.isnan(trojdiff_coef)}")
# Coefficients & Steps
step = trojdiff_step
coef = trojdiff_coef
if str(solver_type).lower() == 'ode':
return step, 2 * coef
elif str(solver_type).lower() == 'sde':
return step, coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_R_coef_gen_ve_reduce(sigmas: torch.Tensor, hs: torch.Tensor, rhos_hat_w: float=1.0, psi: float=1,
solver_type: str='sde', vp_scale: float=1.0,
ve_scale: float=1.0) -> Tuple[torch.Tensor, torch.Tensor]:
# BadDiffusion style correction term, None
if psi != 0:
raise NotImplementedError(f"Variance Explode model doesn't support BadDiffusion style correction term")
# TrojDiff style correction term
if hs == None:
raise ValueError(f"Arguement hs shouldn't be {hs} when psi is {psi}")
# prev_rhos_hat = torch.roll(rhos_hat, 1, 0)
# prev_rhos_hat[0] = 0
prev_sigmas = torch.roll(sigmas, 1, 0)
prev_sigmas[0] = 0
trojdiff_step = rhos_hat_w * sigmas
trojdiff_coef = ve_scale * (sigmas * rhos_hat_w / (sigmas + prev_sigmas))
# print(f"trojdiff_coef isnan: {torch.isnan(trojdiff_coef)}")
# Coefficients & Steps
step = trojdiff_step
coef = trojdiff_coef
if str(solver_type).lower() == 'ode':
return step, 2 * coef
elif str(solver_type).lower() == 'sde':
return step, coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_hs_vp(alphas: torch.Tensor, alphas_cumprod: torch.Tensor) -> torch.Tensor:
hs = [(1 - alphas_cumprod[0]) ** 0.5]
residuals = [0]
for i, (alphas_cumprod_i, alphas_i) in enumerate(zip(alphas_cumprod, alphas)):
if i < 1:
continue
residuals.append((alphas_i ** 0.5) * (hs[i - 1] + residuals[i - 1]))
hs.append((1 - alphas_cumprod_i) ** 0.5 - residuals[i])
return torch.Tensor(hs)
def get_R_coef_gen_vp(alphas_cumprod: torch.Tensor, alphas: torch.Tensor,
hs: torch.Tensor=None, psi: float=1, solver_type: str='sde',
vp_scale: float=1.0, ve_scale: float=1.0) -> Tuple[torch.Tensor, torch.Tensor]:
# BadDiffusion style correction term
baddiff_step = 1 - alphas_cumprod ** 0.5
baddiff_coef = vp_scale * (1 - alphas ** 0.5) * (1 - alphas_cumprod) ** 0.5 / (1 - alphas)
# TrojDiff style correction term
if psi != 1:
if hs == None:
raise ValueError(f"Arhuement hs shouldn't be {hs} when psi is {psi}")
trojdiff_step = (1 - alphas_cumprod) ** 0.5
trojdiff_coef = - ve_scale * ((alphas ** 0.5 - 1) * (1 - alphas_cumprod) ** 0.5 * (1 - alphas) - hs * (alphas - alphas_cumprod)) / (1 - alphas)
# Coefficients & Steps
step = psi * baddiff_step + (1 - psi) * trojdiff_step
coef = psi * baddiff_coef + (1 - psi) * trojdiff_coef
else:
# Coefficients & Steps
step = baddiff_step
coef = baddiff_coef
if str(solver_type).lower() == 'ode':
return step, 2 * coef
elif str(solver_type).lower() == 'sde':
return step, coef
else:
raise NotImplementedError(f"Coefficient solver_type: {solver_type} isn't implemented")
def get_R_coef_elbo_gen(noise_sched, sde_type: str="vp", psi: float=1, solver_type: str='sde',
vp_scale: float=1.0, ve_scale: float=1.0, device=None, dtype=None,
rhos_hat_w: float=1.0, rhos_hat_b: float=0.0) -> Tuple[torch.Tensor, torch.Tensor]: | if sde_type == DiffuserModelSched.SDE_VP or sde_type == DiffuserModelSched.SDE_LDM: | 3 | 2023-10-17 19:57:37+00:00 | 24k |
nchen909/Pass-Tuning | evaluator/CodeBLEU/syntax_match.py | [
{
"identifier": "DFG_python",
"path": "evaluator/CodeBLEU/parser/DFG.py",
"snippet": "def DFG_python(root_node,index_to_code,states):\n assignment=['assignment','augmented_assignment','for_in_clause']\n if_statement=['if_statement']\n for_statement=['for_statement']\n while_statement=['while... | from evaluator.CodeBLEU.parser import DFG_python, DFG_java, DFG_ruby, DFG_go, DFG_php, DFG_javascript, DFG_csharp,DFG_c
from evaluator.CodeBLEU.parser import (remove_comments_and_docstrings,
tree_to_token_index,
index_to_code_token,
tree_to_variable_index)
from tree_sitter import Language, Parser
| 17,382 | # Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
parser_path = '/data/pretrain-attention/CodePrompt/evaluator/CodeBLEU/parser'
dfg_function = {
'python': DFG_python,
| # Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
parser_path = '/data/pretrain-attention/CodePrompt/evaluator/CodeBLEU/parser'
dfg_function = {
'python': DFG_python,
| 'java': DFG_java,
| 1 | 2023-10-20 09:24:44+00:00 | 24k |
JoaoPedro9674/django-ledger | django_ledger/io/io_mixin.py | [
{
"identifier": "settings",
"path": "django_ledger/settings.py",
"snippet": " DJANGO_LEDGER_GRAPHQL_SUPPORT_ENABLED = True\n DJANGO_LEDGER_GRAPHQL_SUPPORT_ENABLED = False\n DJANGO_LEDGER_PDF_SUPPORT_ENABLED = True\n DJANGO_LEDGER_PDF_SUPPORT_ENABLED = False\nDJANGO_LEDGER_USE_CLOSING_ENTRIES... | from collections import defaultdict, namedtuple
from datetime import datetime, date
from itertools import groupby
from pathlib import Path
from random import choice
from typing import List, Set, Union, Tuple, Optional, Dict
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError, ObjectDoesNotExist
from django.db.models import Sum, QuerySet
from django.db.models.functions import TruncMonth
from django.http import Http404
from django.utils.dateparse import parse_date, parse_datetime
from django.utils.timezone import make_aware, is_naive, localtime
from django.utils.translation import gettext_lazy as _
from django_ledger import settings
from django_ledger.exceptions import InvalidDateInputError, TransactionNotInBalanceError
from django_ledger.io import roles as roles_module
from django_ledger.io.io_context import (RoleContextManager, GroupContextManager, ActivityContextManager,
BalanceSheetStatementContextManager, IncomeStatementContextManager,
CashFlowStatementContextManager)
from django_ledger.io.io_digest import IODigestContextManager
from django_ledger.io.ratios import FinancialRatioManager
from django_ledger.models.utils import lazy_loader | 15,722 | for acc in gb_digest:
if any([
all([acc['role_bs'] == roles_module.BS_ASSET_ROLE,
acc['balance_type'] == TransactionModel.CREDIT]),
all([acc['role_bs'] in (
roles_module.BS_LIABILITIES_ROLE,
roles_module.BS_EQUITY_ROLE
),
acc['balance_type'] == TransactionModel.DEBIT])
]):
acc['balance'] = -acc['balance']
return txs_queryset, gb_digest
@staticmethod
def aggregate_balances(k, g):
gl = list(g)
return {
'account_uuid': k[0],
'unit_uuid': k[1],
'unit_name': gl[0].get('journal_entry__entity_unit__name'),
'activity': gl[0].get('journal_entry__activity'),
'period_year': k[2],
'period_month': k[3],
'role_bs': roles_module.BS_ROLES.get(gl[0]['account__role']),
'role': gl[0]['account__role'],
'code': gl[0]['account__code'],
'name': gl[0]['account__name'],
'balance_type': gl[0]['account__balance_type'],
'tx_type': k[5],
'balance': sum(a['balance'] for a in gl),
}
def digest(self,
entity_slug: str = None,
unit_slug: str = None,
user_model: UserModel = None,
txs_queryset: QuerySet = None,
as_io_digest: bool = False,
accounts: Optional[Union[Set[str], List[str]]] = None,
role: Optional[Union[Set[str], List[str]]] = None,
activity: str = None,
signs: bool = True,
to_date: Union[str, datetime, date] = None,
from_date: Union[str, datetime, date] = None,
process_roles: bool = False,
process_groups: bool = False,
process_ratios: bool = False,
process_activity: bool = False,
equity_only: bool = False,
by_period: bool = False,
by_unit: bool = False,
by_activity: bool = False,
by_tx_type: bool = False,
digest_name: str = None,
balance_sheet_statement: bool = False,
income_statement: bool = False,
cash_flow_statement: bool = False,
**kwargs) -> Union[Tuple, IODigestContextManager]:
if balance_sheet_statement:
from_date = None
if cash_flow_statement:
by_activity = True
if activity:
activity = validate_activity(activity)
if role:
role = roles_module.validate_roles(role)
from_date, to_date = validate_dates(from_date, to_date)
io_data = defaultdict(lambda: dict())
io_data['io_model'] = self
io_data['from_date'] = from_date
io_data['to_date'] = to_date
io_data['by_unit'] = by_unit
io_data['by_period'] = by_period
io_data['by_activity'] = by_activity
io_data['by_tx_type'] = by_tx_type
txs_qs, accounts_digest = self.python_digest(
txs_queryset=txs_queryset,
user_model=user_model,
accounts=accounts,
role=role,
activity=activity,
entity_slug=entity_slug,
unit_slug=unit_slug,
to_date=to_date,
from_date=from_date,
signs=signs,
equity_only=equity_only,
by_period=by_period,
by_unit=by_unit,
by_activity=by_activity,
by_tx_type=by_tx_type,
**kwargs
)
io_data['txs_qs'] = txs_qs
io_data['accounts'] = accounts_digest
if process_roles:
roles_mgr = RoleContextManager(
io_data=io_data,
by_period=by_period,
by_unit=by_unit
)
# idea: change digest() name to something else? maybe aggregate, calculate?...
io_data = roles_mgr.digest()
if any([
process_groups,
balance_sheet_statement,
income_statement,
cash_flow_statement
]):
| """
Django Ledger created by Miguel Sanda <msanda@arrobalytics.com>.
Copyright© EDMA Group Inc licensed under the GPLv3 Agreement.
Contributions to this module:
* Miguel Sanda <msanda@arrobalytics.com>
"""
UserModel = get_user_model()
def diff_tx_data(tx_data: list, raise_exception: bool = True):
IS_TX_MODEL = False
TransactionModel = lazy_loader.get_txs_model()
if isinstance(tx_data[0], TransactionModel):
CREDITS = sum(tx.amount for tx in tx_data if tx.tx_type == 'credit')
DEBITS = sum(tx.amount for tx in tx_data if tx.tx_type == 'debit')
IS_TX_MODEL = True
elif isinstance(tx_data[0], dict):
CREDITS = sum(tx['amount'] for tx in tx_data if tx['tx_type'] == 'credit')
DEBITS = sum(tx['amount'] for tx in tx_data if tx['tx_type'] == 'debit')
else:
raise ValidationError('Only Dictionary or TransactionModel allowed.')
is_valid = (CREDITS == DEBITS)
diff = CREDITS - DEBITS
if not is_valid and abs(diff) > settings.DJANGO_LEDGER_TRANSACTION_MAX_TOLERANCE:
if raise_exception:
raise TransactionNotInBalanceError(
f'Invalid tx data. Credits and debits must match. Currently cr: {CREDITS}, db {DEBITS}.'
f'Max Tolerance {settings.DJANGO_LEDGER_TRANSACTION_MAX_TOLERANCE}'
)
return IS_TX_MODEL, is_valid, diff
def check_tx_balance(tx_data: list, perform_correction: bool = False) -> bool:
if tx_data:
IS_TX_MODEL, is_valid, diff = diff_tx_data(tx_data, raise_exception=perform_correction)
if not perform_correction and abs(diff):
return False
if not perform_correction and abs(diff) > settings.DJANGO_LEDGER_TRANSACTION_MAX_TOLERANCE:
return False
while not is_valid:
tx_type_choice = choice(['debit', 'credit'])
txs_candidates = list(tx for tx in tx_data if tx['tx_type'] == tx_type_choice)
if len(txs_candidates) > 0:
tx = choice(list(tx for tx in tx_data if tx['tx_type'] == tx_type_choice))
if any([diff > 0 and tx_type_choice == 'debit',
diff < 0 and tx_type_choice == 'credit']):
if IS_TX_MODEL:
tx.amount += settings.DJANGO_LEDGER_TRANSACTION_CORRECTION
else:
tx['amount'] += settings.DJANGO_LEDGER_TRANSACTION_CORRECTION
elif any([diff < 0 and tx_type_choice == 'debit',
diff > 0 and tx_type_choice == 'credit']):
if IS_TX_MODEL:
tx.amount -= settings.DJANGO_LEDGER_TRANSACTION_CORRECTION
else:
tx['amount'] += settings.DJANGO_LEDGER_TRANSACTION_CORRECTION
IS_TX_MODEL, is_valid, diff = diff_tx_data(tx_data)
return True
def validate_io_date(dt: Union[str, date, datetime], no_parse_localdate: bool = True) -> Optional[datetime]:
if not dt:
return
if isinstance(dt, date):
dt = make_aware(
value=datetime.combine(
dt,
datetime.min.time()
))
return dt
elif isinstance(dt, datetime):
if is_naive(dt):
return make_aware(dt)
return dt
elif isinstance(dt, str):
# try to parse a date object from string...
fdt = parse_date(dt)
if not fdt:
# try to parse a datetime object from string...
fdt = parse_datetime(dt)
if not fdt:
raise InvalidDateInputError(
message=f'Could not parse date from {dt}'
)
elif is_naive(fdt):
fdt = make_aware(fdt)
return fdt
if no_parse_localdate:
return localtime()
def validate_dates(
from_date: Union[str, datetime, date] = None,
to_date: Union[str, datetime, date] = None) -> Tuple[date, date]:
from_date = validate_io_date(from_date, no_parse_localdate=False)
to_date = validate_io_date(to_date)
return from_date, to_date
def validate_activity(activity: str, raise_404: bool = False):
# idea: move to model???...
JournalEntryModel = lazy_loader.get_journal_entry_model()
valid = activity in JournalEntryModel.VALID_ACTIVITIES
if activity and not valid:
exception = ValidationError(f'{activity} is invalid. Choices are {JournalEntryModel.VALID_ACTIVITIES}.')
if raise_404:
raise Http404(exception)
raise exception
return activity
class IOValidationError(ValidationError):
pass
class IODatabaseMixIn:
"""
Controls how transactions are recorded into the ledger.
"""
def is_entity_model(self):
return isinstance(self, lazy_loader.get_entity_model())
def is_ledger_model(self):
return isinstance(self, lazy_loader.get_ledger_model())
def is_entity_unit_model(self):
return isinstance(self, lazy_loader.get_unit_model())
def get_entity_model_from_io(self):
if self.is_entity_model():
return self
elif self.is_ledger_model():
return self.entity
elif self.is_entity_unit_model():
return self.entity
# def is_time_bounded(self, from_date, to_date):
def database_digest(self,
txs_queryset: QuerySet,
entity_slug: str = None,
unit_slug: str = None,
user_model: UserModel = None,
from_date: date = None,
to_date: date = None,
activity: str = None,
role: str = None,
accounts: str or List[str] or Set[str] = None,
posted: bool = True,
exclude_zero_bal: bool = True,
by_activity: bool = False,
by_tx_type: bool = False,
by_period: bool = False,
by_unit: bool = False,
**kwargs):
if settings.DJANGO_LEDGER_USE_CLOSING_ENTRIES:
if not from_date:
entity_model = self.get_entity_model_from_io()
closing_entry_date = entity_model.select_closing_entry_for_io_date(to_date=to_date)
# print(closing_entry_date)
#
# if closing_entry_date:
# closing_entry_list = entity_model.get_closing_entry_cache_for_date(
# closing_date=closing_entry_date,
# force_cache_update=True
# )
# from_date_d = closing_entry_date + timedelta(days=1)
# print('Orig From:', from_date)
# print('New from:', from_date_d)
# print('To Date:', to_date)
# print(closing_entry_list)
if not txs_queryset:
TransactionModel = lazy_loader.get_txs_model()
if self.is_entity_model():
if entity_slug:
if entity_slug != self.slug:
raise IOValidationError('Inconsistent entity_slug. '
f'Provided {entity_slug} does not match actual {self.slug}')
if unit_slug:
txs_queryset = TransactionModel.objects.for_unit(
user_model=user_model,
entity_slug=entity_slug or self.slug,
unit_slug=unit_slug
)
else:
txs_queryset = TransactionModel.objects.for_entity(
user_model=user_model,
entity_slug=self
)
elif self.is_ledger_model():
if not entity_slug:
raise IOValidationError(
'Calling digest from Ledger Model requires entity_slug explicitly for safety')
txs_queryset = TransactionModel.objects.for_ledger(
user_model=user_model,
entity_slug=entity_slug,
ledger_model=self
)
elif self.is_entity_unit_model():
if not entity_slug:
raise IOValidationError(
'Calling digest from Entity Unit requires entity_slug explicitly for safety')
txs_queryset = TransactionModel.objects.for_unit(
user_model=user_model,
entity_slug=entity_slug,
unit_slug=unit_slug or self
)
else:
txs_queryset = TransactionModel.objects.none()
txs_queryset = txs_queryset.not_closing_entry()
if exclude_zero_bal:
txs_queryset = txs_queryset.filter(amount__gt=0)
if posted:
txs_queryset = txs_queryset.posted()
if from_date:
txs_queryset = txs_queryset.from_date(from_date=from_date)
if to_date:
txs_queryset = txs_queryset.to_date(to_date=to_date)
if accounts:
if not isinstance(accounts, str):
accounts = [accounts]
txs_queryset = txs_queryset.for_accounts(account_list=accounts)
if activity:
if isinstance(activity, str):
activity = [activity]
txs_queryset = txs_queryset.for_activity(activity_list=activity)
if role:
txs_queryset = txs_queryset.for_roles(role_list=role)
VALUES = [
'account__uuid',
'account__balance_type',
'tx_type',
'account__code',
'account__name',
'account__role',
]
ANNOTATE = {'balance': Sum('amount')}
ORDER_BY = ['account__uuid']
if by_unit:
ORDER_BY.append('journal_entry__entity_unit__uuid')
VALUES += ['journal_entry__entity_unit__uuid', 'journal_entry__entity_unit__name']
if by_period:
ORDER_BY.append('journal_entry__timestamp')
ANNOTATE['dt_idx'] = TruncMonth('journal_entry__timestamp')
if by_activity:
ORDER_BY.append('journal_entry__activity')
VALUES.append('journal_entry__activity')
if by_tx_type:
ORDER_BY.append('tx_type')
VALUES.append('tx_type')
return txs_queryset.values(*VALUES).annotate(**ANNOTATE).order_by(*ORDER_BY)
def python_digest(self,
txs_queryset: Optional[QuerySet] = None,
user_model: Optional[UserModel] = None,
to_date: date = None,
from_date: date = None,
equity_only: bool = False,
activity: str = None,
entity_slug: str = None,
unit_slug: str = None,
role: Optional[Union[Set[str], List[str]]] = None,
accounts: Optional[Union[Set[str], List[str]]] = None,
signs: bool = False,
by_unit: bool = False,
by_activity: bool = False,
by_tx_type: bool = False,
by_period: bool = False,
**kwargs) -> list or tuple:
if equity_only:
role = roles_module.GROUP_EARNINGS
txs_queryset = self.database_digest(
user_model=user_model,
txs_queryset=txs_queryset,
to_date=to_date,
from_date=from_date,
entity_slug=entity_slug,
unit_slug=unit_slug,
activity=activity,
role=role,
accounts=accounts,
by_unit=by_unit,
by_activity=by_activity,
by_tx_type=by_tx_type,
by_period=by_period,
**kwargs)
for tx_model in txs_queryset:
if tx_model['account__balance_type'] != tx_model['tx_type']:
tx_model['balance'] = -tx_model['balance']
# txs_list = list(txs_queryset)
# txs_list.sort(key=lambda a: (
# a['account__uuid'],
# str(a.get('journal_entry__entity_unit__uuid', '')) if by_unit else '',
# a['dt_idx'].year if by_period else 0,
# a['dt_idx'].month if by_period else 0,
# str(a['journal_entry__activity']) if by_activity else None,
# a['tx_type'] if by_tx_type else '',
# ))
accounts_gb_code = groupby(txs_queryset,
key=lambda a: (
a['account__uuid'],
a.get('journal_entry__entity_unit__uuid') if by_unit else None,
a.get('dt_idx').year if by_period else None,
a.get('dt_idx').month if by_period else None,
a.get('journal_entry__activity') if by_activity else None,
a.get('tx_type') if by_tx_type else None,
))
gb_digest = [self.aggregate_balances(k, g) for k, g in accounts_gb_code]
for acc in gb_digest:
acc['balance_abs'] = abs(acc['balance'])
if signs:
TransactionModel = lazy_loader.get_txs_model()
for acc in gb_digest:
if any([
all([acc['role_bs'] == roles_module.BS_ASSET_ROLE,
acc['balance_type'] == TransactionModel.CREDIT]),
all([acc['role_bs'] in (
roles_module.BS_LIABILITIES_ROLE,
roles_module.BS_EQUITY_ROLE
),
acc['balance_type'] == TransactionModel.DEBIT])
]):
acc['balance'] = -acc['balance']
return txs_queryset, gb_digest
@staticmethod
def aggregate_balances(k, g):
gl = list(g)
return {
'account_uuid': k[0],
'unit_uuid': k[1],
'unit_name': gl[0].get('journal_entry__entity_unit__name'),
'activity': gl[0].get('journal_entry__activity'),
'period_year': k[2],
'period_month': k[3],
'role_bs': roles_module.BS_ROLES.get(gl[0]['account__role']),
'role': gl[0]['account__role'],
'code': gl[0]['account__code'],
'name': gl[0]['account__name'],
'balance_type': gl[0]['account__balance_type'],
'tx_type': k[5],
'balance': sum(a['balance'] for a in gl),
}
def digest(self,
entity_slug: str = None,
unit_slug: str = None,
user_model: UserModel = None,
txs_queryset: QuerySet = None,
as_io_digest: bool = False,
accounts: Optional[Union[Set[str], List[str]]] = None,
role: Optional[Union[Set[str], List[str]]] = None,
activity: str = None,
signs: bool = True,
to_date: Union[str, datetime, date] = None,
from_date: Union[str, datetime, date] = None,
process_roles: bool = False,
process_groups: bool = False,
process_ratios: bool = False,
process_activity: bool = False,
equity_only: bool = False,
by_period: bool = False,
by_unit: bool = False,
by_activity: bool = False,
by_tx_type: bool = False,
digest_name: str = None,
balance_sheet_statement: bool = False,
income_statement: bool = False,
cash_flow_statement: bool = False,
**kwargs) -> Union[Tuple, IODigestContextManager]:
if balance_sheet_statement:
from_date = None
if cash_flow_statement:
by_activity = True
if activity:
activity = validate_activity(activity)
if role:
role = roles_module.validate_roles(role)
from_date, to_date = validate_dates(from_date, to_date)
io_data = defaultdict(lambda: dict())
io_data['io_model'] = self
io_data['from_date'] = from_date
io_data['to_date'] = to_date
io_data['by_unit'] = by_unit
io_data['by_period'] = by_period
io_data['by_activity'] = by_activity
io_data['by_tx_type'] = by_tx_type
txs_qs, accounts_digest = self.python_digest(
txs_queryset=txs_queryset,
user_model=user_model,
accounts=accounts,
role=role,
activity=activity,
entity_slug=entity_slug,
unit_slug=unit_slug,
to_date=to_date,
from_date=from_date,
signs=signs,
equity_only=equity_only,
by_period=by_period,
by_unit=by_unit,
by_activity=by_activity,
by_tx_type=by_tx_type,
**kwargs
)
io_data['txs_qs'] = txs_qs
io_data['accounts'] = accounts_digest
if process_roles:
roles_mgr = RoleContextManager(
io_data=io_data,
by_period=by_period,
by_unit=by_unit
)
# idea: change digest() name to something else? maybe aggregate, calculate?...
io_data = roles_mgr.digest()
if any([
process_groups,
balance_sheet_statement,
income_statement,
cash_flow_statement
]): | group_mgr = GroupContextManager( | 5 | 2023-10-20 01:07:20+00:00 | 24k |
acolas1/KGSimple | simplify.py | [
{
"identifier": "FluencyScorer",
"path": "scoring/fluency_scorer.py",
"snippet": "class FluencyScorer:\n def __init__(self, batch_size=1, reduce=\"mean\", log=True, laplace_smooth=False, prob_dict_path=None):\n self.device = \"cuda:1\" if torch.cuda.is_available() else \"cpu\"\n self.ba... | import os
import json
import numpy as np
import pandas as pd
import torch
import random
from collections import defaultdict
from transformers import BartTokenizer, T5Tokenizer
from transformers import AdamW, get_linear_schedule_with_warmup
from utils import *
from scoring.fluency_scorer import FluencyScorer
from scoring.saliency_scorer import SaliencyBERTScore
from scoring.simplicity_scorer import SimplicityTextScore
from scoring.guardrails import *
from scoring.aggregate_scorer import ScorerWrapper
from GAP.data_relations_as_nodes import GAPDataloader, EventDataset, WebNLGDataset
from GAP.data_relations_as_nodes import evaluate_bleu, get_t_emb_dim
from tqdm import tqdm, trange
from rake_nltk import Rake
from evaluate import load
from sentence_similarity import sentence_similarity
from GAP.modeling_gap_type import GAPBartForConditionalGeneration as GAP_Type_model
from GAP.modeling_gap import GAPBartForConditionalGeneration as GAP_model
| 21,336 |
# import yake
bertscore = load("bertscore")
## sentence model for merge
phrase_model = sentence_similarity(model_name='distilbert-base-uncased',embedding_type='cls_token_embedding')
## for sentence checking
ner_check = NERInaccuracyPenalty()
def run(args, logger):
#load in model for graph-to-text and tokenizer
checkpoint = args.model_path
tokenizer_path = args.tokenizer_path
tokenizer = BartTokenizer.from_pretrained(tokenizer_path)
n_gpu = torch.cuda.device_count()
if n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
if args.type_encoding:
t_emb_dim = get_t_emb_dim(args)
|
# import yake
bertscore = load("bertscore")
## sentence model for merge
phrase_model = sentence_similarity(model_name='distilbert-base-uncased',embedding_type='cls_token_embedding')
## for sentence checking
ner_check = NERInaccuracyPenalty()
def run(args, logger):
#load in model for graph-to-text and tokenizer
checkpoint = args.model_path
tokenizer_path = args.tokenizer_path
tokenizer = BartTokenizer.from_pretrained(tokenizer_path)
n_gpu = torch.cuda.device_count()
if n_gpu > 0:
torch.cuda.manual_seed_all(args.seed)
if args.type_encoding:
t_emb_dim = get_t_emb_dim(args)
| model = GAP_Type_model.from_pretrained(checkpoint,t_emb_dim=t_emb_dim)
| 8 | 2023-10-24 13:24:23+00:00 | 24k |
ForceFledgling/proxyhub | proxyhub/api.py | [
{
"identifier": "Checker",
"path": "proxyhub/checker.py",
"snippet": "class Checker:\n \"\"\"Proxy checker.\"\"\"\n\n def __init__(\n self,\n judges,\n max_tries=3,\n timeout=8,\n verify_ssl=False,\n strict=False,\n dnsbl=None,\n real_ext_ip=... | import asyncio
import io
import signal
import warnings
from collections import Counter, defaultdict
from functools import partial
from pprint import pprint
from .checker import Checker
from .errors import ResolveError
from .providers import PROVIDERS, Provider
from .proxy import Proxy
from .resolver import Resolver
from .server import Server
from .utils import IPPortPatternLine, log | 14,879 | strict=strict,
dnsbl=dnsbl,
loop=self._loop,
)
self._countries = countries
self._limit = limit
tasks = [asyncio.ensure_future(self._checker.check_judges())]
if data:
task = asyncio.ensure_future(self._load(data, check=True))
else:
task = asyncio.ensure_future(self._grab(types, check=True))
tasks.append(task)
self._all_tasks.extend(tasks)
def serve(self, host='127.0.0.1', port=8888, limit=100, **kwargs):
"""Start a local proxy server.
The server distributes incoming requests to a pool of found proxies.
When the server receives an incoming request, it chooses the optimal
proxy (based on the percentage of errors and average response time)
and passes to it the incoming request.
In addition to the parameters listed below are also accept all the
parameters of the :meth:`.find` method and passed it to gather proxies
to a pool.
:ref:`Example of usage <proxyhub-examples-server>`.
:param str host: (optional) Host of local proxy server
:param int port: (optional) Port of local proxy server
:param int limit:
(optional) When will be found a requested number of working
proxies, checking of new proxies will be lazily paused.
Checking will be resumed if all the found proxies will be discarded
in the process of working with them (see :attr:`max_error_rate`,
:attr:`max_resp_time`). And will continue until it finds one
working proxy and paused again. The default value is 100
:param int max_tries:
(optional) The maximum number of attempts to handle an incoming
request. If not specified, it will use the value specified during
the creation of the :class:`Broker` object. Attempts can be made
with different proxies. The default value is 3
:param int strategy:
(optional) The strategy used for picking proxy from pool.
The default value is 'best'
:param int min_queue:
(optional) The minimum number of proxies to choose from
before deciding which is the most suitable to use.
The default value is 5
:param int min_req_proxy:
(optional) The minimum number of processed requests to estimate the
quality of proxy (in accordance with :attr:`max_error_rate` and
:attr:`max_resp_time`). The default value is 5
:param int max_error_rate:
(optional) The maximum percentage of requests that ended with
an error. For example: 0.5 = 50%. If proxy.error_rate exceeds this
value, proxy will be removed from the pool.
The default value is 0.5
:param int max_resp_time:
(optional) The maximum response time in seconds.
If proxy.avg_resp_time exceeds this value, proxy will be removed
from the pool. The default value is 8
:param bool prefer_connect:
(optional) Flag that indicates whether to use the CONNECT method
if possible. For example: If is set to True and a proxy supports
HTTP proto (GET or POST requests) and CONNECT method, the server
will try to use CONNECT method and only after that send the
original request. The default value is False
:param list http_allowed_codes:
(optional) Acceptable HTTP codes returned by proxy on requests.
If a proxy return code, not included in this list, it will be
considered as a proxy error, not a wrong/unavailable address.
For example, if a proxy will return a ``404 Not Found`` response -
this will be considered as an error of a proxy.
Checks only for HTTP protocol, HTTPS not supported at the moment.
By default the list is empty and the response code is not verified
:param int backlog:
(optional) The maximum number of queued connections passed to
listen. The default value is 100
:raises ValueError:
If :attr:`limit` is less than or equal to zero.
Because a parsing of providers will be endless
.. versionadded:: 0.2.0
"""
if limit <= 0:
raise ValueError(
'In serve mode value of the limit cannot be less than or '
'equal to zero. Otherwise, a parsing of providers will be '
'endless'
)
self._server = Server(
host=host,
port=port,
proxies=self._proxies,
timeout=self._timeout,
max_tries=kwargs.pop('max_tries', self._max_tries),
loop=self._loop,
**kwargs,
)
self._server.start()
task = asyncio.ensure_future(self.find(limit=limit, **kwargs))
self._all_tasks.append(task)
async def _load(self, data, check=True):
"""Looking for proxies in the passed data.
Transform the passed data from [raw string | file-like object | list]
to set {(host, port), ...}: {('192.168.0.1', '80'), }
"""
log.debug('Load proxies from the raw data')
if isinstance(data, io.TextIOWrapper):
data = data.read()
if isinstance(data, str):
|
# Pause between grabbing cycles; in seconds.
GRAB_PAUSE = 180
# The maximum number of providers that are parsed concurrently
MAX_CONCURRENT_PROVIDERS = 3
class Broker:
"""The Broker.
| One broker to rule them all, one broker to find them,
| One broker to bring them all and in the darkness bind them.
:param asyncio.Queue queue: (optional) Queue of found/checked proxies
:param int timeout: (optional) Timeout of a request in seconds
:param int max_conn:
(optional) The maximum number of concurrent checks of proxies
:param int max_tries:
(optional) The maximum number of attempts to check a proxy
:param list judges:
(optional) Urls of pages that show HTTP headers and IP address.
Or :class:`~proxyhub.judge.Judge` objects
:param list providers:
(optional) Urls of pages where to find proxies.
Or :class:`~proxyhub.providers.Provider` objects
:param bool verify_ssl:
(optional) Flag indicating whether to check the SSL certificates.
Set to True to check ssl certifications
:param loop: (optional) asyncio compatible event loop
:param stop_broker_on_sigint: (optional) whether set SIGINT signal on broker object.
Useful for a thread other than main thread.
.. deprecated:: 0.2.0
Use :attr:`max_conn` and :attr:`max_tries` instead of
:attr:`max_concurrent_conn` and :attr:`attempts_conn`.
"""
def __init__(
self,
queue=None,
timeout=8,
max_conn=200,
max_tries=3,
judges=None,
providers=None,
verify_ssl=False,
loop=None,
stop_broker_on_sigint=True,
**kwargs,
):
self._loop = loop or asyncio.get_event_loop_policy().get_event_loop()
self._proxies = queue or asyncio.Queue()
self._resolver = Resolver(loop=self._loop)
self._timeout = timeout
self._verify_ssl = verify_ssl
self.unique_proxies = {}
self._all_tasks = []
self._checker = None
self._server = None
self._limit = 0 # not limited
self._countries = None
max_concurrent_conn = kwargs.get('max_concurrent_conn')
if max_concurrent_conn:
warnings.warn(
'`max_concurrent_conn` is deprecated, use `max_conn` instead',
DeprecationWarning,
)
if isinstance(max_concurrent_conn, asyncio.Semaphore):
max_conn = max_concurrent_conn._value
else:
max_conn = max_concurrent_conn
attempts_conn = kwargs.get('attempts_conn')
if attempts_conn:
warnings.warn(
'`attempts_conn` is deprecated, use `max_tries` instead',
DeprecationWarning,
)
max_tries = attempts_conn
# The maximum number of concurrent checking proxies
self._on_check = asyncio.Queue(maxsize=max_conn)
self._max_tries = max_tries
self._judges = judges
self._providers = [
p if isinstance(p, Provider) else Provider(p)
for p in (providers or PROVIDERS)
]
if stop_broker_on_sigint:
try:
self._loop.add_signal_handler(signal.SIGINT, self.stop)
# add_signal_handler() is not implemented on Win
# https://docs.python.org/3.5/library/asyncio-eventloops.html#windows
except NotImplementedError:
pass
async def grab(self, *, countries=None, limit=0):
"""Gather proxies from the providers without checking.
:param list countries: (optional) List of ISO country codes
where should be located proxies
:param int limit: (optional) The maximum number of proxies
:ref:`Example of usage <proxyhub-examples-grab>`.
"""
self._countries = countries
self._limit = limit
task = asyncio.ensure_future(self._grab(check=False))
self._all_tasks.append(task)
async def find(
self,
*,
types=None,
data=None,
countries=None,
post=False,
strict=False,
dnsbl=None,
limit=0,
**kwargs,
):
"""Gather and check proxies from providers or from a passed data.
:ref:`Example of usage <proxyhub-examples-find>`.
:param list types:
Types (protocols) that need to be check on support by proxy.
Supported: HTTP, HTTPS, SOCKS4, SOCKS5, CONNECT:80, CONNECT:25
And levels of anonymity (HTTP only): Transparent, Anonymous, High
:param data:
(optional) String or list with proxies. Also can be a file-like
object supports `read()` method. Used instead of providers
:param list countries:
(optional) List of ISO country codes where should be located
proxies
:param bool post:
(optional) Flag indicating use POST instead of GET for requests
when checking proxies
:param bool strict:
(optional) Flag indicating that anonymity levels of types
(protocols) supported by a proxy must be equal to the requested
types and levels of anonymity. By default, strict mode is off and
for a successful check is enough to satisfy any one of the
requested types
:param list dnsbl:
(optional) Spam databases for proxy checking.
`Wiki <https://en.wikipedia.org/wiki/DNSBL>`_
:param int limit: (optional) The maximum number of proxies
:raises ValueError:
If :attr:`types` not given.
.. versionchanged:: 0.2.0
Added: :attr:`post`, :attr:`strict`, :attr:`dnsbl`.
Changed: :attr:`types` is required.
"""
ip = await self._resolver.get_real_ext_ip()
types = _update_types(types)
if not types:
raise ValueError('`types` is required')
self._checker = Checker(
judges=self._judges,
timeout=self._timeout,
verify_ssl=self._verify_ssl,
max_tries=self._max_tries,
real_ext_ip=ip,
types=types,
post=post,
strict=strict,
dnsbl=dnsbl,
loop=self._loop,
)
self._countries = countries
self._limit = limit
tasks = [asyncio.ensure_future(self._checker.check_judges())]
if data:
task = asyncio.ensure_future(self._load(data, check=True))
else:
task = asyncio.ensure_future(self._grab(types, check=True))
tasks.append(task)
self._all_tasks.extend(tasks)
def serve(self, host='127.0.0.1', port=8888, limit=100, **kwargs):
"""Start a local proxy server.
The server distributes incoming requests to a pool of found proxies.
When the server receives an incoming request, it chooses the optimal
proxy (based on the percentage of errors and average response time)
and passes to it the incoming request.
In addition to the parameters listed below are also accept all the
parameters of the :meth:`.find` method and passed it to gather proxies
to a pool.
:ref:`Example of usage <proxyhub-examples-server>`.
:param str host: (optional) Host of local proxy server
:param int port: (optional) Port of local proxy server
:param int limit:
(optional) When will be found a requested number of working
proxies, checking of new proxies will be lazily paused.
Checking will be resumed if all the found proxies will be discarded
in the process of working with them (see :attr:`max_error_rate`,
:attr:`max_resp_time`). And will continue until it finds one
working proxy and paused again. The default value is 100
:param int max_tries:
(optional) The maximum number of attempts to handle an incoming
request. If not specified, it will use the value specified during
the creation of the :class:`Broker` object. Attempts can be made
with different proxies. The default value is 3
:param int strategy:
(optional) The strategy used for picking proxy from pool.
The default value is 'best'
:param int min_queue:
(optional) The minimum number of proxies to choose from
before deciding which is the most suitable to use.
The default value is 5
:param int min_req_proxy:
(optional) The minimum number of processed requests to estimate the
quality of proxy (in accordance with :attr:`max_error_rate` and
:attr:`max_resp_time`). The default value is 5
:param int max_error_rate:
(optional) The maximum percentage of requests that ended with
an error. For example: 0.5 = 50%. If proxy.error_rate exceeds this
value, proxy will be removed from the pool.
The default value is 0.5
:param int max_resp_time:
(optional) The maximum response time in seconds.
If proxy.avg_resp_time exceeds this value, proxy will be removed
from the pool. The default value is 8
:param bool prefer_connect:
(optional) Flag that indicates whether to use the CONNECT method
if possible. For example: If is set to True and a proxy supports
HTTP proto (GET or POST requests) and CONNECT method, the server
will try to use CONNECT method and only after that send the
original request. The default value is False
:param list http_allowed_codes:
(optional) Acceptable HTTP codes returned by proxy on requests.
If a proxy return code, not included in this list, it will be
considered as a proxy error, not a wrong/unavailable address.
For example, if a proxy will return a ``404 Not Found`` response -
this will be considered as an error of a proxy.
Checks only for HTTP protocol, HTTPS not supported at the moment.
By default the list is empty and the response code is not verified
:param int backlog:
(optional) The maximum number of queued connections passed to
listen. The default value is 100
:raises ValueError:
If :attr:`limit` is less than or equal to zero.
Because a parsing of providers will be endless
.. versionadded:: 0.2.0
"""
if limit <= 0:
raise ValueError(
'In serve mode value of the limit cannot be less than or '
'equal to zero. Otherwise, a parsing of providers will be '
'endless'
)
self._server = Server(
host=host,
port=port,
proxies=self._proxies,
timeout=self._timeout,
max_tries=kwargs.pop('max_tries', self._max_tries),
loop=self._loop,
**kwargs,
)
self._server.start()
task = asyncio.ensure_future(self.find(limit=limit, **kwargs))
self._all_tasks.append(task)
async def _load(self, data, check=True):
"""Looking for proxies in the passed data.
Transform the passed data from [raw string | file-like object | list]
to set {(host, port), ...}: {('192.168.0.1', '80'), }
"""
log.debug('Load proxies from the raw data')
if isinstance(data, io.TextIOWrapper):
data = data.read()
if isinstance(data, str): | data = IPPortPatternLine.findall(data) | 7 | 2023-11-05 13:28:57+00:00 | 24k |
TheFunny/ArisuAutoSweeper | module/webui/app.py | [
{
"identifier": "AzurLaneConfig",
"path": "module/config/config.py",
"snippet": "class AzurLaneConfig(ConfigUpdater, ManualConfig, GeneratedConfig, ConfigWatcher):\n stop_event: threading.Event = None\n bound = {}\n\n # Class property\n is_hoarding_task = True\n\n def __setattr__(self, ke... | import argparse
import queue
import threading
import time
import module.webui.lang as lang
from datetime import datetime
from functools import partial
from typing import Dict, List, Optional
from pywebio import config as webconfig
from pywebio.output import (
Output,
clear,
close_popup,
popup,
put_button,
put_buttons,
put_collapse,
put_column,
put_error,
put_html,
put_link,
put_loading,
put_markdown,
put_row,
put_scope,
put_table,
put_text,
put_warning,
toast,
use_scope,
)
from pywebio.pin import pin, pin_on_change
from pywebio.session import go_app, info, local, register_thread, run_js, set_env
from module.config.config import AzurLaneConfig, Function
from module.config.utils import (
alas_instance,
alas_template,
deep_get,
deep_iter,
deep_set,
dict_to_kv,
filepath_args,
filepath_config,
read_file,
)
from module.logger import logger
from module.webui.base import Frame
from module.webui.fake import (
get_config_mod,
load_config,
)
from module.webui.fastapi import asgi_app
from module.webui.lang import _t, t
from module.webui.pin import put_input, put_select
from module.webui.process_manager import ProcessManager
from module.webui.remote_access import RemoteAccess
from module.webui.setting import State
from module.webui.updater import updater
from module.webui.utils import (
Icon,
Switch,
TaskHandler,
add_css,
filepath_css,
get_alas_config_listen_path,
get_localstorage,
get_window_visibility_state,
login,
parse_pin_value,
raise_exception,
re_fullmatch,
)
from module.webui.widgets import (
BinarySwitchButton,
RichLog,
T_Output_Kwargs,
put_icon_buttons,
put_loading_text,
put_none,
put_output,
) | 15,264 |
log = RichLog("log")
with use_scope("logs"):
put_scope("log-bar", [
put_scope("log-title", [
put_text(t("Gui.Overview.Log")).style("font-size: 1.25rem; margin: auto .5rem auto;"),
put_scope("log-title-btns", [
put_scope("log_scroll_btn"),
]),
]),
put_html('<hr class="hr-group">'),
put_scope("dashboard", [
# Empty dashboard, values will be updated in alas_update_overview_task()
put_scope(f"dashboard-row-{arg}", [])
for arg in self.ALAS_STORED.keys() if deep_get(self.ALAS_STORED, keys=[arg, "order"], default=0)
# Empty content to left-align last row
] + [put_html("<i></i>")] * min(len(self.ALAS_STORED), 4))
])
put_scope("log", [put_html("")])
log.console.width = log.get_width()
switch_log_scroll = BinarySwitchButton(
label_on=t("Gui.Button.ScrollON"),
label_off=t("Gui.Button.ScrollOFF"),
onclick_on=lambda: log.set_scroll(False),
onclick_off=lambda: log.set_scroll(True),
get_state=lambda: log.keep_bottom,
color_on="on",
color_off="off",
scope="log_scroll_btn",
)
self.task_handler.add(switch_scheduler.g(), 1, True)
self.task_handler.add(switch_log_scroll.g(), 1, True)
self.task_handler.add(self.alas_update_overview_task, 10, True)
self.task_handler.add(log.put_log(self.alas), 0.25, True)
def _init_alas_config_watcher(self) -> None:
def put_queue(path, value):
self.modified_config_queue.put({"name": path, "value": value})
for path in get_alas_config_listen_path(self.ALAS_ARGS):
pin_on_change(
name="_".join(path), onchange=partial(put_queue, ".".join(path))
)
logger.info("Init config watcher done.")
def _alas_thread_update_config(self) -> None:
modified = {}
while self.alive:
try:
d = self.modified_config_queue.get(timeout=10)
config_name = self.alas_name
read = self.alas_config.read_file
write = self.alas_config.write_file
except queue.Empty:
continue
modified[d["name"]] = d["value"]
while True:
try:
d = self.modified_config_queue.get(timeout=1)
modified[d["name"]] = d["value"]
except queue.Empty:
self._save_config(modified, config_name, read, write)
modified.clear()
break
def _save_config(
self,
modified: Dict[str, str],
config_name: str,
read=State.config_updater.read_file,
write=State.config_updater.write_file,
) -> None:
try:
valid = []
invalid = []
config = read(config_name)
for k, v in modified.copy().items():
valuetype = deep_get(self.ALAS_ARGS, k + ".valuetype")
v = parse_pin_value(v, valuetype)
validate = deep_get(self.ALAS_ARGS, k + ".validate")
if not len(str(v)):
default = deep_get(self.ALAS_ARGS, k + ".value")
modified[k] = default
deep_set(config, k, default)
valid.append(k)
pin["_".join(k.split("."))] = default
elif not validate or re_fullmatch(validate, v):
deep_set(config, k, v)
modified[k] = v
valid.append(k)
# update Emotion Record if Emotion Value is changed
if "Emotion" in k and "Value" in k:
k = k.split(".")
k[-1] = k[-1].replace("Value", "Record")
k = ".".join(k)
v = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
modified[k] = v
deep_set(config, k, v)
valid.append(k)
pin["_".join(k.split("."))] = v
else:
modified.pop(k)
invalid.append(k)
logger.warning(f"Invalid value {v} for key {k}, skip saving.")
self.pin_remove_invalid_mark(valid)
self.pin_set_invalid_mark(invalid)
if modified:
toast(
t("Gui.Toast.ConfigSaved"),
duration=1,
position="right",
color="success",
)
logger.info(
|
task_handler = TaskHandler()
class AlasGUI(Frame):
ALAS_MENU: Dict[str, Dict[str, List[str]]]
ALAS_ARGS: Dict[str, Dict[str, Dict[str, Dict[str, str]]]]
ALAS_STORED: Dict[str, Dict[str, Dict[str, str]]]
theme = "default"
def initial(self) -> None:
self.ALAS_MENU = read_file(filepath_args("menu", self.alas_mod))
self.ALAS_ARGS = read_file(filepath_args("args", self.alas_mod))
self.ALAS_STORED = read_file(filepath_args("stored", self.alas_mod))
self._init_alas_config_watcher()
def __init__(self) -> None:
super().__init__()
# modified keys, return values of pin_wait_change()
self.modified_config_queue = queue.Queue()
# alas config name
self.alas_name = ""
self.alas_mod = "alas"
self.alas_config = AzurLaneConfig("template")
self.initial()
@use_scope("aside", clear=True)
def set_aside(self) -> None:
# TODO: update put_icon_buttons()
put_icon_buttons(
Icon.DEVELOP,
buttons=[
{"label": t("Gui.Aside.Home"), "value": "Home", "color": "aside"}
],
onclick=[self.ui_develop],
),
for name in alas_instance():
put_icon_buttons(
Icon.RUN,
buttons=[{"label": name, "value": name, "color": "aside"}],
onclick=self.ui_alas,
)
put_icon_buttons(
Icon.ADD,
buttons=[
{"label": t("Gui.Aside.AddAlas"), "value": "AddAlas", "color": "aside"}
],
onclick=[self.ui_add_alas],
),
@use_scope("header_status")
def set_status(self, state: int) -> None:
"""
Args:
state (int):
1 (running)
2 (not running)
3 (warning, stop unexpectedly)
4 (stop for update)
0 (hide)
-1 (*state not changed)
"""
if state == -1:
return
clear()
if state == 1:
put_loading_text(t("Gui.Status.Running"), color="success")
elif state == 2:
put_loading_text(t("Gui.Status.Inactive"), color="secondary", fill=True)
elif state == 3:
put_loading_text(t("Gui.Status.Warning"), shape="grow", color="warning")
elif state == 4:
put_loading_text(t("Gui.Status.Updating"), shape="grow", color="success")
@classmethod
def set_theme(cls, theme="default") -> None:
cls.theme = theme
State.deploy_config.Theme = theme
State.theme = theme
webconfig(theme=theme)
@use_scope("menu", clear=True)
def alas_set_menu(self) -> None:
"""
Set menu
"""
put_buttons(
[{
"label": t("Gui.MenuAlas.Overview"),
"value": "Overview",
"color": "menu",
}],
onclick=[self.alas_overview],
).style(f"--menu-Overview--")
for menu, task_data in self.ALAS_MENU.items():
if task_data.get("page") == "tool":
_onclick = self.alas_daemon_overview
else:
_onclick = self.alas_set_group
if task_data.get("menu") == "collapse":
task_btn_list = [
put_buttons(
[{
"label": t(f"Task.{task}.name"),
"value": task,
"color": "menu",
}],
onclick=_onclick,
).style(f"--menu-{task}--")
for task in task_data.get("tasks", [])
]
put_collapse(title=t(f"Menu.{menu}.name"), content=task_btn_list)
else:
title = t(f"Menu.{menu}.name")
put_html('<div class="hr-task-group-box">'
'<span class="hr-task-group-line"></span>'
f'<span class="hr-task-group-text">{title}</span>'
'<span class="hr-task-group-line"></span>'
'</div>'
)
for task in task_data.get("tasks", []):
put_buttons(
[{
"label": t(f"Task.{task}.name"),
"value": task,
"color": "menu",
}],
onclick=_onclick,
).style(f"--menu-{task}--").style(f"padding-left: 0.75rem")
self.alas_overview()
@use_scope("content", clear=True)
def alas_set_group(self, task: str) -> None:
"""
Set arg groups from dict
"""
self.init_menu(name=task)
self.set_title(t(f"Task.{task}.name"))
put_scope("_groups", [put_none(), put_scope("groups"), put_scope("navigator")])
task_help: str = t(f"Task.{task}.help")
if task_help:
put_scope(
"group__info",
scope="groups",
content=[put_text(task_help).style("font-size: 1rem")],
)
config = self.alas_config.read_file(self.alas_name)
for group, arg_dict in deep_iter(self.ALAS_ARGS[task], depth=1):
if self.set_group(group, arg_dict, config, task):
self.set_navigator(group)
@use_scope("groups")
def set_group(self, group, arg_dict, config, task):
group_name = group[0]
output_list: List[Output] = []
for arg, arg_dict in deep_iter(arg_dict, depth=1):
output_kwargs: T_Output_Kwargs = arg_dict.copy()
# Skip hide
display: Optional[str] = output_kwargs.pop("display", None)
if display == "hide":
continue
# Disable
elif display == "disabled":
output_kwargs["disabled"] = True
# Output type
output_kwargs["widget_type"] = output_kwargs.pop("type")
arg_name = arg[0] # [arg_name,]
# Internal pin widget name
output_kwargs["name"] = f"{task}_{group_name}_{arg_name}"
# Display title
output_kwargs["title"] = t(f"{group_name}.{arg_name}.name")
# Get value from config
value = deep_get(
config, [task, group_name, arg_name], output_kwargs["value"]
)
# idk
value = str(value) if isinstance(value, datetime) else value
# Default value
output_kwargs["value"] = value
# Options
output_kwargs["options"] = options = output_kwargs.pop("option", [])
# Options label
options_label = []
for opt in options:
options_label.append(t(f"{group_name}.{arg_name}.{opt}"))
output_kwargs["options_label"] = options_label
# Help
arg_help = t(f"{group_name}.{arg_name}.help")
if arg_help == "" or not arg_help:
arg_help = None
output_kwargs["help"] = arg_help
# Invalid feedback
output_kwargs["invalid_feedback"] = t("Gui.Text.InvalidFeedBack", value)
o = put_output(output_kwargs)
if o is not None:
# output will inherit current scope when created, override here
o.spec["scope"] = f"#pywebio-scope-group_{group_name}"
output_list.append(o)
if not output_list:
return 0
with use_scope(f"group_{group_name}"):
put_text(t(f"{group_name}._info.name"))
group_help = t(f"{group_name}._info.help")
if group_help != "":
put_text(group_help)
put_html('<hr class="hr-group">')
for output in output_list:
output.show()
return len(output_list)
@use_scope("navigator")
def set_navigator(self, group):
js = f"""
$("#pywebio-scope-groups").scrollTop(
$("#pywebio-scope-group_{group[0]}").position().top
+ $("#pywebio-scope-groups").scrollTop() - 59
)
"""
put_button(
label=t(f"{group[0]}._info.name"),
onclick=lambda: run_js(js),
color="navigator",
)
def set_dashboard(self, arg, arg_dict, config):
i18n = arg_dict.get('i18n')
if i18n:
name = t(i18n)
else:
name = arg
color = arg_dict.get("color", "#777777")
nodata = t("Gui.Dashboard.NoData")
def set_value(dic):
if "total" in dic.get("attrs", []) and config.get("total") is not None:
return [
put_text(config.get("value", nodata)).style("--dashboard-value--"),
put_text(f' / {config.get("total", "")}').style("--dashboard-time--"),
]
else:
return [
put_text(config.get("value", nodata)).style("--dashboard-value--"),
]
with use_scope(f"dashboard-row-{arg}", clear=True):
put_html(f'<div><div class="dashboard-icon" style="background-color:{color}"></div>'),
put_scope(f"dashboard-content-{arg}", [
put_scope(f"dashboard-value-{arg}", set_value(arg_dict)),
put_scope(f"dashboard-time-{arg}", [
put_text(f"{name} - {lang.readable_time(config.get('time', ''))}").style("--dashboard-time--"),
])
])
@use_scope("content", clear=True)
def alas_overview(self) -> None:
self.init_menu(name="Overview")
self.set_title(t(f"Gui.MenuAlas.Overview"))
put_scope("overview", [put_scope("schedulers"), put_scope("logs")])
with use_scope("schedulers"):
put_scope(
"scheduler-bar",
[
put_text(t("Gui.Overview.Scheduler")).style(
"font-size: 1.25rem; margin: auto .5rem auto;"
),
put_scope("scheduler_btn"),
],
)
put_scope(
"running",
[
put_text(t("Gui.Overview.Running")),
put_html('<hr class="hr-group">'),
put_scope("running_tasks"),
],
)
put_scope(
"pending",
[
put_text(t("Gui.Overview.Pending")),
put_html('<hr class="hr-group">'),
put_scope("pending_tasks"),
],
)
put_scope(
"waiting",
[
put_text(t("Gui.Overview.Waiting")),
put_html('<hr class="hr-group">'),
put_scope("waiting_tasks"),
],
)
switch_scheduler = BinarySwitchButton(
label_on=t("Gui.Button.Stop"),
label_off=t("Gui.Button.Start"),
onclick_on=lambda: self.alas.stop(),
onclick_off=lambda: self.alas.start(None, updater.event),
get_state=lambda: self.alas.alive,
color_on="off",
color_off="on",
scope="scheduler_btn",
)
log = RichLog("log")
with use_scope("logs"):
put_scope("log-bar", [
put_scope("log-title", [
put_text(t("Gui.Overview.Log")).style("font-size: 1.25rem; margin: auto .5rem auto;"),
put_scope("log-title-btns", [
put_scope("log_scroll_btn"),
]),
]),
put_html('<hr class="hr-group">'),
put_scope("dashboard", [
# Empty dashboard, values will be updated in alas_update_overview_task()
put_scope(f"dashboard-row-{arg}", [])
for arg in self.ALAS_STORED.keys() if deep_get(self.ALAS_STORED, keys=[arg, "order"], default=0)
# Empty content to left-align last row
] + [put_html("<i></i>")] * min(len(self.ALAS_STORED), 4))
])
put_scope("log", [put_html("")])
log.console.width = log.get_width()
switch_log_scroll = BinarySwitchButton(
label_on=t("Gui.Button.ScrollON"),
label_off=t("Gui.Button.ScrollOFF"),
onclick_on=lambda: log.set_scroll(False),
onclick_off=lambda: log.set_scroll(True),
get_state=lambda: log.keep_bottom,
color_on="on",
color_off="off",
scope="log_scroll_btn",
)
self.task_handler.add(switch_scheduler.g(), 1, True)
self.task_handler.add(switch_log_scroll.g(), 1, True)
self.task_handler.add(self.alas_update_overview_task, 10, True)
self.task_handler.add(log.put_log(self.alas), 0.25, True)
def _init_alas_config_watcher(self) -> None:
def put_queue(path, value):
self.modified_config_queue.put({"name": path, "value": value})
for path in get_alas_config_listen_path(self.ALAS_ARGS):
pin_on_change(
name="_".join(path), onchange=partial(put_queue, ".".join(path))
)
logger.info("Init config watcher done.")
def _alas_thread_update_config(self) -> None:
modified = {}
while self.alive:
try:
d = self.modified_config_queue.get(timeout=10)
config_name = self.alas_name
read = self.alas_config.read_file
write = self.alas_config.write_file
except queue.Empty:
continue
modified[d["name"]] = d["value"]
while True:
try:
d = self.modified_config_queue.get(timeout=1)
modified[d["name"]] = d["value"]
except queue.Empty:
self._save_config(modified, config_name, read, write)
modified.clear()
break
def _save_config(
self,
modified: Dict[str, str],
config_name: str,
read=State.config_updater.read_file,
write=State.config_updater.write_file,
) -> None:
try:
valid = []
invalid = []
config = read(config_name)
for k, v in modified.copy().items():
valuetype = deep_get(self.ALAS_ARGS, k + ".valuetype")
v = parse_pin_value(v, valuetype)
validate = deep_get(self.ALAS_ARGS, k + ".validate")
if not len(str(v)):
default = deep_get(self.ALAS_ARGS, k + ".value")
modified[k] = default
deep_set(config, k, default)
valid.append(k)
pin["_".join(k.split("."))] = default
elif not validate or re_fullmatch(validate, v):
deep_set(config, k, v)
modified[k] = v
valid.append(k)
# update Emotion Record if Emotion Value is changed
if "Emotion" in k and "Value" in k:
k = k.split(".")
k[-1] = k[-1].replace("Value", "Record")
k = ".".join(k)
v = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
modified[k] = v
deep_set(config, k, v)
valid.append(k)
pin["_".join(k.split("."))] = v
else:
modified.pop(k)
invalid.append(k)
logger.warning(f"Invalid value {v} for key {k}, skip saving.")
self.pin_remove_invalid_mark(valid)
self.pin_set_invalid_mark(invalid)
if modified:
toast(
t("Gui.Toast.ConfigSaved"),
duration=1,
position="right",
color="success",
)
logger.info( | f"Save config {filepath_config(config_name)}, {dict_to_kv(modified)}" | 9 | 2023-11-01 07:09:45+00:00 | 24k |
radekd91/inferno | inferno/models/DECA.py | [
{
"identifier": "EmoNetLoss",
"path": "inferno/layers/losses/EmoNetLoss.py",
"snippet": "class EmoNetLoss(EmoLossBase):\n# class EmoNetLoss(object):\n\n def __init__(self, device, emonet=None, trainable=False, normalize_features=False, emo_feat_loss=None, au_loss=None):\n if emonet is None:\n ... | import os, sys
import torch
import torchvision
import torch.nn.functional as F
import torchvision.transforms.functional as F_v
import numpy as np
import cv2
import inferno.layers.losses.DecaLosses as lossfunc
import inferno.layers.losses.MediaPipeLandmarkLosses as lossfunc_mp
import inferno.utils.DecaUtils as util
import pytorch_lightning.plugins.environments.lightning_environment as le
import psutil
import adabound
import copy
from pytorch_lightning import LightningModule
from pytorch_lightning.loggers import WandbLogger
from inferno.layers.losses.EmoNetLoss import EmoNetLoss, create_emo_loss, create_au_loss
from skimage.io import imread
from skimage.transform import resize
from pathlib import Path
from inferno.models.Renderer import SRenderY
from inferno.models.DecaEncoder import ResnetEncoder, SecondHeadResnet, SwinEncoder
from inferno.models.DecaDecoder import Generator, GeneratorAdaIn
from inferno.models.DecaFLAME import FLAME, FLAMETex, FLAME_mediapipe
from inferno.models.EmotionMLP import EmotionMLP
from inferno.datasets.AffWild2Dataset import Expression7
from inferno.datasets.AffectNetDataModule import AffectNetExpressions
from inferno.utils.lightning_logging import _log_array_image, _log_wandb_image, _torch_image2np
from enum import Enum
from inferno.utils.other import class_from_str, get_path_to_assets
from inferno.layers.losses.VGGLoss import VGG19Loss
from omegaconf import OmegaConf, open_dict
from inferno.models.temporal.external.LipReadingLoss import LipReadingLoss
from .StarGAN import StarGANWrapper
from inferno.models.EmoNetRegressor import EmoNetRegressor, EmonetRegressorStatic
from .mica.config import get_cfg_defaults
from .mica.mica import MICA
from .mica.MicaInputProcessing import MicaInputProcessor
from inferno.utils.other import get_path_to_assets
from inferno.models.IO import locate_checkpoint | 19,545 | uv_z = uv_z * self.uv_face_eye_mask
# detail vertices = coarse vertice + predicted displacement*normals + fixed displacement*normals
uv_detail_vertices = uv_coarse_vertices + \
uv_z * uv_coarse_normals + \
self.fixed_uv_dis[None, None, :,:] * uv_coarse_normals #.detach()
dense_vertices = uv_detail_vertices.permute(0, 2, 3, 1).reshape([batch_size, -1, 3])
uv_detail_normals = util.vertex_normals(dense_vertices, self.render.dense_faces.expand(batch_size, -1, -1))
uv_detail_normals = uv_detail_normals.reshape(
[batch_size, uv_coarse_vertices.shape[2], uv_coarse_vertices.shape[3], 3]).permute(0, 3, 1, 2)
# uv_detail_normals = uv_detail_normals*self.uv_face_eye_mask + uv_coarse_normals*(1-self.uv_face_eye_mask)
# uv_detail_normals = util.gaussian_blur(uv_detail_normals)
return uv_detail_normals, uv_coarse_vertices
def visualize(self, visdict, savepath, catdim=1):
grids = {}
for key in visdict:
# print(key)
if visdict[key] is None:
continue
grids[key] = torchvision.utils.make_grid(
F.interpolate(visdict[key], [self.config.image_size, self.config.image_size])).detach().cpu()
grid = torch.cat(list(grids.values()), catdim)
grid_image = (grid.numpy().transpose(1, 2, 0).copy() * 255)[:, :, [2, 1, 0]]
grid_image = np.minimum(np.maximum(grid_image, 0), 255).astype(np.uint8)
if savepath is not None:
cv2.imwrite(savepath, grid_image)
return grid_image
def create_mesh(self, opdict, dense_template):
'''
vertices: [nv, 3], tensor
texture: [3, h, w], tensor
'''
i = 0
vertices = opdict['verts'][i].cpu().numpy()
faces = self.render.faces[0].cpu().numpy()
if 'uv_texture_gt' in opdict.keys():
texture = util.tensor2image(opdict['uv_texture_gt'][i])
else:
texture = None
uvcoords = self.render.raw_uvcoords[0].cpu().numpy()
uvfaces = self.render.uvfaces[0].cpu().numpy()
# save coarse mesh, with texture and normal map
if 'uv_detail_normals' in opdict.keys():
normal_map = util.tensor2image(opdict['uv_detail_normals'][i]*0.5 + 0.5)
# upsample mesh, save detailed mesh
texture = texture[:, :, [2, 1, 0]]
normals = opdict['normals'][i].cpu().numpy()
displacement_map = opdict['displacement_map'][i].detach().cpu().numpy().squeeze()
dense_vertices, dense_colors, dense_faces = util.upsample_mesh(vertices, normals, faces,
displacement_map, texture, dense_template)
else:
normal_map = None
dense_vertices = None
dense_colors = None
dense_faces = None
return vertices, faces, texture, uvcoords, uvfaces, normal_map, dense_vertices, dense_faces, dense_colors
def save_obj(self, filename, opdict, dense_template, mode ='detail'):
if mode not in ['coarse', 'detail', 'both']:
raise ValueError(f"Invalid mode '{mode}. Expected modes are: 'coarse', 'detail', 'both'")
vertices, faces, texture, uvcoords, uvfaces, normal_map, dense_vertices, dense_faces, dense_colors \
= self.create_mesh(opdict, dense_template)
if mode == 'both':
if isinstance(filename, list):
filename_coarse = filename[0]
filename_detail = filename[1]
else:
filename_coarse = filename
filename_detail = filename.replace('.obj', '_detail.obj')
elif mode == 'coarse':
filename_coarse = filename
else:
filename_detail = filename
if mode in ['coarse', 'both']:
util.write_obj(str(filename_coarse), vertices, faces,
texture=texture,
uvcoords=uvcoords,
uvfaces=uvfaces,
normal_map=normal_map)
if mode in ['detail', 'both']:
util.write_obj(str(filename_detail),
dense_vertices,
dense_faces,
colors = dense_colors,
inverse_face_order=True)
class ExpDECAInterface(object):
"""
This serves as an interface for EMOCA-like classes that need to use a different sub class but
retain the EMOCA functionality. See EMICA_v2 for an example.
"""
def _create_model(self):
# E_flame should be fixed for expression EMOCA
self.E_flame.requires_grad_(False)
# 2) add expression decoder
if self.config.expression_backbone == 'deca_parallel':
## a) Attach a parallel flow of FCs onto the original DECA coarse backbone. (Only the second FC head is trainable)
self.E_expression = SecondHeadResnet(self.E_flame, self.n_exp_param, 'same')
elif self.config.expression_backbone == 'deca_clone':
## b) Clones the original DECA coarse decoder (and the entire decoder will be trainable) - This is in final EMOCA.
#TODO this will only work for Resnet. Make this work for the other backbones (Swin) as well.
self.E_expression = ResnetEncoder(self.n_exp_param)
# clone parameters of the ResNet
self.E_expression.encoder.load_state_dict(self.E_flame.encoder.state_dict())
elif self.config.expression_backbone == 'emonet_trainable':
# Trainable EmoNet instead of Resnet (deprecated)
| """
Author: Radek Danecek
Copyright (c) 2022, Radek Danecek
All rights reserved.
# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
# holder of all proprietary rights on this computer program.
# Using this computer program means that you agree to the terms
# in the LICENSE file included with this software distribution.
# Any use not explicitly granted by the LICENSE is prohibited.
#
# Copyright©2022 Max-Planck-Gesellschaft zur Förderung
# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
# for Intelligent Systems. All rights reserved.
#
# For comments or questions, please email us at emoca@tue.mpg.de
# For commercial licensing contact, please contact ps-license@tuebingen.mpg.de
Parts of the code were adapted from the original DECA release:
https://github.com/YadiraF/DECA/
"""
# from time import time
torch.backends.cudnn.benchmark = True
class DecaMode(Enum):
COARSE = 1 # when switched on, only coarse part of DECA-based networks is used
DETAIL = 2 # when switched on, only coarse and detail part of DECA-based networks is used
class DecaModule(LightningModule):
"""
DecaModule is a PL module that implements DECA-inspired face reconstruction networks.
"""
def __init__(self, model_params, learning_params, inout_params, stage_name = ""):
"""
:param model_params: a DictConfig of parameters about the model itself
:param learning_params: a DictConfig of parameters corresponding to the learning process (such as optimizer, lr and others)
:param inout_params: a DictConfig of parameters about input and output (where checkpoints and visualizations are saved)
"""
super().__init__()
self.learning_params = learning_params
self.inout_params = inout_params
# detail conditioning - what is given as the conditioning input to the detail generator in detail stage training
if 'detail_conditioning' not in model_params.keys():
# jaw, expression and detail code by default
self.detail_conditioning = ['jawpose', 'expression', 'detail']
OmegaConf.set_struct(model_params, True)
with open_dict(model_params):
model_params.detail_conditioning = self.detail_conditioning
else:
self.detail_conditioning = model_params.detail_conditioning
# deprecated and is not used
if 'detailemo_conditioning' not in model_params.keys():
self.detailemo_conditioning = []
OmegaConf.set_struct(model_params, True)
with open_dict(model_params):
model_params.detailemo_conditioning = self.detailemo_conditioning
else:
self.detailemo_conditioning = model_params.detailemo_conditioning
supported_conditioning_keys = ['identity', 'jawpose', 'expression', 'detail', 'detailemo']
for c in self.detail_conditioning:
if c not in supported_conditioning_keys:
raise ValueError(f"Conditioning on '{c}' is not supported. Supported conditionings: {supported_conditioning_keys}")
for c in self.detailemo_conditioning:
if c not in supported_conditioning_keys:
raise ValueError(f"Conditioning on '{c}' is not supported. Supported conditionings: {supported_conditioning_keys}")
# which type of DECA network is used
if 'deca_class' not in model_params.keys() or model_params.deca_class is None:
print(f"Deca class is not specified. Defaulting to {str(DECA.__class__.__name__)}")
# vanilla DECA by default (not EMOCA)
deca_class = DECA
else:
# other type of DECA-inspired networks possible (such as ExpDECA, which is what EMOCA)
deca_class = class_from_str(model_params.deca_class, sys.modules[__name__])
# instantiate the network
self.deca = deca_class(config=model_params)
self.mode = DecaMode[str(model_params.mode).upper()]
self.stage_name = stage_name
if self.stage_name is None:
self.stage_name = ""
if len(self.stage_name) > 0:
self.stage_name += "_"
# initialize the emotion perceptual loss (used for EMOCA supervision)
self.emonet_loss = None
self._init_emotion_loss()
# initialize the au perceptual loss (not currently used in EMOCA)
self.au_loss = None
self._init_au_loss()
# initialize the lip reading perceptual loss (not currently used in original EMOCA)
self.lipread_loss = None
self._init_lipread_loss()
# MPL regressor from the encoded space to emotion labels (not used in EMOCA but could be used for direct emotion supervision)
if 'mlp_emotion_predictor' in self.deca.config.keys():
# self._build_emotion_mlp(self.deca.config.mlp_emotion_predictor)
self.emotion_mlp = EmotionMLP(self.deca.config.mlp_emotion_predictor, model_params)
else:
self.emotion_mlp = None
def get_input_image_size(self):
return (self.deca.config.image_size, self.deca.config.image_size)
def _instantiate_deca(self, model_params):
"""
Instantiate the DECA network.
"""
# which type of DECA network is used
if 'deca_class' not in model_params.keys() or model_params.deca_class is None:
print(f"Deca class is not specified. Defaulting to {str(DECA.__class__.__name__)}")
# vanilla DECA by default (not EMOCA)
deca_class = DECA
else:
# other type of DECA-inspired networks possible (such as ExpDECA, which is what EMOCA)
deca_class = class_from_str(model_params.deca_class, sys.modules[__name__])
# instantiate the network
self.deca = deca_class(config=model_params)
def _init_emotion_loss(self):
"""
Initialize the emotion perceptual loss (used for EMOCA supervision)
"""
if 'emonet_weight' in self.deca.config.keys() and bool(self.deca.config.get('emonet_model_path', False)):
if self.emonet_loss is not None:
emoloss_force_override = True if 'emoloss_force_override' in self.deca.config.keys() and self.deca.config.emoloss_force_override else False
if self.emonet_loss.is_trainable():
if not emoloss_force_override:
print("The old emonet loss is trainable and will not be overrided or replaced.")
return
# raise NotImplementedError("The old emonet loss was trainable. Changing a trainable loss is probably now "
# "what you want implicitly. If you need this, use the '`'emoloss_force_override' config.")
else:
print("The old emonet loss is trainable but override is set so it will be replaced.")
else:
print("The old emonet loss is not trainable. It will be replaced.")
if 'emonet_model_path' in self.deca.config.keys():
emonet_model_path = self.deca.config.emonet_model_path
else:
emonet_model_path=None
# self.emonet_loss = EmoNetLoss(self.device, emonet=emonet_model_path)
emoloss_trainable = True if 'emoloss_trainable' in self.deca.config.keys() and self.deca.config.emoloss_trainable else False
emoloss_dual = True if 'emoloss_dual' in self.deca.config.keys() and self.deca.config.emoloss_dual else False
normalize_features = self.deca.config.normalize_features if 'normalize_features' in self.deca.config.keys() else None
emo_feat_loss = self.deca.config.emo_feat_loss if 'emo_feat_loss' in self.deca.config.keys() else None
old_emonet_loss = self.emonet_loss
self.emonet_loss = create_emo_loss(self.device, emoloss=emonet_model_path, trainable=emoloss_trainable,
dual=emoloss_dual,
normalize_features=normalize_features,
emo_feat_loss=emo_feat_loss)
if old_emonet_loss is not None and type(old_emonet_loss) != self.emonet_loss:
print(f"The old emonet loss {old_emonet_loss.__class__.__name__} is replaced during reconfiguration by "
f"new emotion loss {self.emonet_loss.__class__.__name__}")
else:
self.emonet_loss = None
def _init_au_loss(self):
"""
Initialize the au perceptual loss (not currently used in EMOCA)
"""
if 'au_loss' in self.deca.config.keys():
if self.au_loss is not None:
force_override = True if 'force_override' in self.deca.config.au_loss.keys() \
and self.deca.config.au_loss.force_override else False
if self.au_loss.is_trainable():
if not force_override:
print("The old AU loss is trainable and will not be overrided or replaced.")
return
# raise NotImplementedError("The old emonet loss was trainable. Changing a trainable loss is probably now "
# "what you want implicitly. If you need this, use the '`'emoloss_force_override' config.")
else:
print("The old AU loss is trainable but override is set so it will be replaced.")
else:
print("The old AU loss is not trainable. It will be replaced.")
old_au_loss = self.emonet_loss
self.au_loss = create_au_loss(self.device, self.deca.config.au_loss)
else:
self.au_loss = None
def _init_lipread_loss(self):
"""
Initialize the au perceptual loss (not currently used in EMOCA)
"""
if 'lipread_loss' in self.deca.config.keys() and self.deca.config.lipread_loss.get('load', True):
if self.lipread_loss is not None:
force_override = True if 'force_override' in self.deca.config.lipread_loss.keys() \
and self.deca.config.lipread_loss.force_override else False
assert self.lipread_loss.is_trainable(), "Trainable lip reading loss is not supported yet."
if self.lipread_loss.is_trainable():
if not force_override:
print("The old lip reading loss is trainable and will not be overrided or replaced.")
return
# raise NotImplementedError("The old emonet loss was trainable. Changing a trainable loss is probably now "
# "what you want implicitly. If you need this, use the '`'emoloss_force_override' config.")
else:
print("The old lip reading loss is trainable but override is set so it will be replaced.")
else:
print("The old lip reading loss is not trainable. It will be replaced.")
# old_lipread_loss = self.emonet_loss
self.lipread_loss = LipReadingLoss(self.device, self.deca.config.lipread_loss.lipread_loss)
self.lipread_loss.eval()
self.lipread_loss.requires_grad_(False)
else:
self.lipread_loss = None
def reconfigure(self, model_params, inout_params, learning_params, stage_name="", downgrade_ok=False, train=True):
"""
Reconfigure the model. Usually used to switch between detail and coarse stages (which have separate configs)
"""
if (self.mode == DecaMode.DETAIL and model_params.mode != DecaMode.DETAIL) and not downgrade_ok:
raise RuntimeError("You're switching the EMOCA mode from DETAIL to COARSE. Is this really what you want?!")
self.inout_params = inout_params
self.learning_params = learning_params
if self.deca.__class__.__name__ != model_params.deca_class:
old_deca_class = self.deca.__class__.__name__
state_dict = self.deca.state_dict()
if 'deca_class' in model_params.keys():
deca_class = class_from_str(model_params.deca_class, sys.modules[__name__])
else:
deca_class = DECA
self.deca = deca_class(config=model_params)
diff = set(state_dict.keys()).difference(set(self.deca.state_dict().keys()))
if len(diff) > 0:
raise RuntimeError(f"Some values from old state dict will not be used. This is probably not what you "
f"want because it most likely means that the pretrained model's weights won't be used. "
f"Maybe you messed up backbone compatibility (i.e. SWIN vs ResNet?) {diff}")
ret = self.deca.load_state_dict(state_dict, strict=False)
if len(ret.unexpected_keys) > 0:
raise print(f"Unexpected keys: {ret.unexpected_keys}")
missing_modules = set([s.split(".")[0] for s in ret.missing_keys])
print(f"Missing modules when upgrading from {old_deca_class} to {model_params.deca_class}:")
print(missing_modules)
else:
self.deca._reconfigure(model_params)
self._init_emotion_loss()
self._init_au_loss()
self.stage_name = stage_name
if self.stage_name is None:
self.stage_name = ""
if len(self.stage_name) > 0:
self.stage_name += "_"
self.mode = DecaMode[str(model_params.mode).upper()]
self.train(mode=train)
print(f"EMOCA MODE RECONFIGURED TO: {self.mode}")
if 'shape_contrain_type' in self.deca.config.keys() and str(self.deca.config.shape_constrain_type).lower() != 'none':
shape_constraint = self.deca.config.shape_constrain_type
else:
shape_constraint = None
if 'expression_constrain_type' in self.deca.config.keys() and str(self.deca.config.expression_constrain_type).lower() != 'none':
expression_constraint = self.deca.config.expression_constrain_type
else:
expression_constraint = None
if shape_constraint is not None and expression_constraint is not None:
raise ValueError("Both shape constraint and expression constraint are active. This is probably not what we want.")
def uses_texture(self):
"""
Check if the model uses texture
"""
return self.deca.uses_texture()
def visualize(self, visdict, savepath, catdim=1):
return self.deca.visualize(visdict, savepath, catdim)
def train(self, mode: bool = True):
# super().train(mode) # not necessary
self.deca.train(mode)
if self.emotion_mlp is not None:
self.emotion_mlp.train(mode)
if self.emonet_loss is not None:
self.emonet_loss.eval()
if self.deca.perceptual_loss is not None:
self.deca.perceptual_loss.eval()
if self.deca.id_loss is not None:
self.deca.id_loss.eval()
return self
def to(self, *args, **kwargs):
super().to(*args, **kwargs)
return self
def cuda(self, device=None):
super().cuda(device)
return self
def cpu(self):
super().cpu()
return self
def forward(self, batch):
values = self.encode(batch, training=False)
values = self.decode(values, training=False)
return values
def _unwrap_list(self, codelist):
shapecode, texcode, expcode, posecode, cam, lightcode = codelist
return shapecode, texcode, expcode, posecode, cam, lightcode
def _unwrap_list_to_dict(self, codelist):
shapecode, texcode, expcode, posecode, cam, lightcode = codelist
return {'shape': shapecode, 'tex': texcode, 'exp': expcode, 'pose': posecode, 'cam': cam, 'light': lightcode}
# return shapecode, texcode, expcode, posecode, cam, lightcode
def _encode_flame(self, images, **kwargs):
if self.mode == DecaMode.COARSE or \
(self.mode == DecaMode.DETAIL and self.deca.config.train_coarse):
# forward pass with gradients (for coarse stage (used), or detail stage with coarse training (not used))
parameters = self.deca._encode_flame(images, **kwargs)
elif self.mode == DecaMode.DETAIL:
# in detail stage, the coarse forward pass does not need gradients
with torch.no_grad():
parameters = self.deca._encode_flame(images, **kwargs)
else:
raise ValueError(f"Invalid EMOCA Mode {self.mode}")
code_list, original_code = self.deca.decompose_code(parameters)
# shapecode, texcode, expcode, posecode, cam, lightcode = code_list
# return shapecode, texcode, expcode, posecode, cam, lightcode, original_code
return code_list, original_code
def _expression_ring_exchange(self, original_batch_size, K,
expcode, posecode, shapecode, lightcode, texcode,
images, cam, lmk, masks, va, expr7, affectnetexp,
detailcode=None, detailemocode=None, exprw=None, lmk_mp=None,
mica_images=None):
"""
Deprecated. Expression ring exchange is not used in EMOCA (nor DECA).
"""
new_order = np.array([np.random.permutation(K) + i * K for i in range(original_batch_size)])
new_order = new_order.flatten()
expcode_new = expcode[new_order]
## append new shape code data
expcode = torch.cat([expcode, expcode_new], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
shapecode = torch.cat([shapecode, shapecode], dim=0)
globpose = posecode[..., :3]
jawpose = posecode[..., 3:]
if self.deca.config.expression_constrain_use_jaw_pose:
jawpose_new = jawpose[new_order]
jawpose = torch.cat([jawpose, jawpose_new], dim=0)
else:
jawpose = torch.cat([jawpose, jawpose], dim=0)
if self.deca.config.expression_constrain_use_global_pose:
globpose_new = globpose[new_order]
globpose = torch.cat([globpose, globpose_new], dim=0)
else:
globpose = torch.cat([globpose, globpose], dim=0)
if self.deca.config.expression_constrain_use_jaw_pose or self.deca.config.expression_constrain_use_global_pose:
posecode = torch.cat([globpose, jawpose], dim=-1)
# posecode_new = torch.cat([globpose, jawpose], dim=-1)
else:
# posecode_new = posecode
# posecode_new = posecode
posecode = torch.cat([posecode, posecode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## append gt
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
if lmk_mp is not None:
lmk_mp = torch.cat([lmk_mp, lmk_mp], dim=0)
masks = torch.cat([masks, masks], dim=0)
# NOTE:
# Here we could think about what makes sense to exchange
# 1) Do we exchange all emotion GT (VA and expression) within the ring?
# 2) Do we exchange only the GT on which the ring is constructed (AffectNet ring based on binned VA or expression or Emonet feature?)
# note: if we use EmoMLP that goes from (expression, jawpose, detailcode) -> (v,a,expr) and we exchange
# ALL of these, the EmoMLP prediction will of course be the same. The output image still changes,
# so EmoNet loss (if used) would be different. Same for the photometric/landmark losses.
# TODO:
# For now I decided to exchange everything but this should probably be experimented with
# I would argue though, that exchanging the GT is the right thing to do
if va is not None:
va = torch.cat([va, va[new_order]], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7[new_order]], dim=0)
if affectnetexp is not None:
affectnetexp = torch.cat([affectnetexp, affectnetexp[new_order]], dim=0)
if exprw is not None:
exprw = torch.cat([exprw, exprw[new_order]], dim=0)
if detailcode is not None:
#TODO: to exchange or not to exchange, that is the question, the answer is probably NO
detailcode = torch.cat([detailcode, detailcode], dim=0)
# detailcode = torch.cat([detailcode, detailcode[new_order]], dim=0)
if detailemocode is not None:
# TODO: to exchange or not to exchange, that is the question, the answer is probably YES
detailemocode = torch.cat([detailemocode, detailemocode[new_order]], dim=0)
return expcode, posecode, shapecode, lightcode, texcode, images, cam, lmk, masks, va, expr7, affectnetexp, \
detailcode, detailemocode, exprw, lmk_mp, mica_images
# return expcode, posecode, shapecode, lightcode, texcode, images, cam, lmk, masks, va, expr7
def encode(self, batch, training=True) -> dict:
"""
Forward encoding pass of the model. Takes a batch of images and returns the corresponding latent codes for each image.
:param batch: Batch of images to encode. batch['image'] [batch_size, ring_size, 3, image_size, image_size].
For a training forward pass, additional corresponding data are necessery such as 'landmarks' and 'masks'.
For a testing pass, the images suffice.
:param training: Whether the forward pass is for training or testing.
"""
codedict = {}
original_batch_size = batch['image'].shape[0]
images = batch['image']
if 'mica_images' in batch.keys():
mica_images = batch['mica_images']
else:
mica_images = None
if len(images.shape) == 5:
K = images.shape[1]
elif len(images.shape) == 4:
K = 1
else:
raise RuntimeError("Invalid image batch dimensions.")
# [B, K, 3, size, size] ==> [BxK, 3, size, size]
images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = mica_images.view(-1, mica_images.shape[-3], mica_images.shape[-2], mica_images.shape[-1])
if 'landmark' in batch.keys():
lmk = batch['landmark']
lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
if 'landmark_mediapipe' in batch.keys():
lmk_mp = batch['landmark_mediapipe']
lmk_mp = lmk_mp.view(-1, lmk_mp.shape[-2], lmk_mp.shape[-1])
else:
lmk_mp = None
if 'mask' in batch.keys():
masks = batch['mask']
masks = masks.view(-1, images.shape[-2], images.shape[-1])
# valence / arousal - not necessary unless we want to use VA for supervision (not done in EMOCA)
if 'va' in batch:
va = batch['va']
va = va.view(-1, va.shape[-1])
else:
va = None
# 7 basic expression - not necessary unless we want to use expression for supervision (not done in EMOCA or DECA)
if 'expr7' in batch:
expr7 = batch['expr7']
expr7 = expr7.view(-1, expr7.shape[-1])
else:
expr7 = None
# affectnet basic expression - not necessary unless we want to use expression for supervision (not done in EMOCA or DECA)
if 'affectnetexp' in batch:
affectnetexp = batch['affectnetexp']
affectnetexp = affectnetexp.view(-1, affectnetexp.shape[-1])
else:
affectnetexp = None
# expression weights if supervising by expression is used (to balance the classification loss) - not done in EMOCA or DECA
if 'expression_weight' in batch:
exprw = batch['expression_weight']
exprw = exprw.view(-1, exprw.shape[-1])
else:
exprw = None
# 1) COARSE STAGE
# forward pass of the coarse encoder
# shapecode, texcode, expcode, posecode, cam, lightcode = self._encode_flame(images)
code, original_code = self._encode_flame(images, mica_image=mica_images)
shapecode, texcode, expcode, posecode, cam, lightcode = self._unwrap_list(code)
if original_code is not None:
original_code = self._unwrap_list_to_dict(original_code)
if training:
# If training, we employ the disentanglement strategy
if self.mode == DecaMode.COARSE:
if self.deca.config.shape_constrain_type == 'same':
## Enforce that all identity shape codes within ring are the same. The batch is duplicated
## and the duplicated part's shape codes are shuffled.
# reshape shapecode => [B, K, n_shape]
# shapecode_idK = shapecode.view(self.batch_size, self.deca.K, -1)
shapecode_idK = shapecode.view(original_batch_size, K, -1)
# get mean id
shapecode_mean = torch.mean(shapecode_idK, dim=[1])
# shapecode_new = shapecode_mean[:, None, :].repeat(1, self.deca.K, 1)
shapecode_new = shapecode_mean[:, None, :].repeat(1, K, 1)
shapecode = shapecode_new.view(-1, self.deca._get_num_shape_params())
# do the same for the original code dict
shapecode_orig = original_code['shape']
shapecode_orig_idK = shapecode_orig.view(original_batch_size, K, -1)
shapecode_orig_mean = torch.mean(shapecode_orig_idK, dim=[1])
shapecode_orig_new = shapecode_orig_mean[:, None, :].repeat(1, K, 1)
original_code['shape'] = shapecode_orig_new.view(-1, self.deca._get_num_shape_params())
elif self.deca.config.shape_constrain_type == 'exchange':
## Shuffle identitys shape codes within ring (they should correspond to the same identity)
'''
make sure s0, s1 is something to make shape close
the difference from ||so - s1|| is
the later encourage s0, s1 is cloase in l2 space, but not really ensure shape will be close
'''
# new_order = np.array([np.random.permutation(self.deca.config.train_K) + i * self.deca.config.train_K for i in range(self.deca.config.batch_size_train)])
# new_order = np.array([np.random.permutation(self.deca.config.train_K) + i * self.deca.config.train_K for i in range(original_batch_size)])
new_order = np.array([np.random.permutation(K) + i * K for i in range(original_batch_size)])
new_order = new_order.flatten()
shapecode_new = shapecode[new_order]
## append new shape code data
shapecode = torch.cat([shapecode, shapecode_new], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
expcode = torch.cat([expcode, expcode], dim=0)
posecode = torch.cat([posecode, posecode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## append gt
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
if lmk_mp is not None:
lmk_mp = torch.cat([lmk_mp, lmk_mp], dim=0)
masks = torch.cat([masks, masks], dim=0)
if va is not None:
va = torch.cat([va, va], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7], dim=0)
# do the same for the original code dict
shapecode_orig = original_code['shape']
shapecode_orig_new = shapecode_orig[new_order]
original_code['shape'] = torch.cat([shapecode_orig, shapecode_orig_new], dim=0)
original_code['tex'] = torch.cat([original_code['tex'], original_code['tex']], dim=0)
original_code['exp'] = torch.cat([original_code['exp'], original_code['exp']], dim=0)
original_code['pose'] = torch.cat([original_code['pose'], original_code['pose']], dim=0)
original_code['cam'] = torch.cat([original_code['cam'], original_code['cam']], dim=0)
original_code['light'] = torch.cat([original_code['light'], original_code['light']], dim=0)
elif self.deca.config.shape_constrain_type == 'shuffle_expression':
assert original_code is not None
## DEPRECATED, NOT USED IN EMOCA OR DECA
new_order = np.random.permutation(K*original_batch_size)
old_order = np.arange(K*original_batch_size)
while (new_order == old_order).any(): # ugly hacky way of assuring that every element is permuted
new_order = np.random.permutation(K * original_batch_size)
codedict['new_order'] = new_order
# exchange expression
expcode_new = expcode[new_order]
expcode = torch.cat([expcode, expcode_new], dim=0)
# exchange jaw pose (but not global pose)
global_pose = posecode[:, :3]
jaw_pose = posecode[:, 3:]
jaw_pose_new = jaw_pose[new_order]
jaw_pose = torch.cat([jaw_pose, jaw_pose_new], dim=0)
global_pose = torch.cat([global_pose, global_pose], dim=0)
posecode = torch.cat([global_pose, jaw_pose], dim=1)
## duplicate the rest
shapecode = torch.cat([shapecode, shapecode], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## duplicate gt if any
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
print(f"TRAINING: {training}")
if lmk is not None:
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
if lmk_mp is not None:
lmk_mp = torch.cat([lmk_mp, lmk_mp], dim=0)
masks = torch.cat([masks, masks], dim=0)
ref_images_identity_idxs = np.concatenate([old_order, old_order])
ref_images_expression_idxs = np.concatenate([old_order, new_order])
codedict["ref_images_identity_idxs"] = ref_images_identity_idxs
codedict["ref_images_expression_idxs"] = ref_images_expression_idxs
if va is not None:
va = torch.cat([va, va[new_order]], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7[new_order]], dim=0)
# do the same for the original code dict
original_code['shape'] = torch.cat([original_code['shape'], original_code['shape']], dim=0)
original_code['tex'] = torch.cat([original_code['tex'], original_code['tex']], dim=0)
original_code['exp'] = torch.cat([original_code['exp'], original_code['exp'][new_order]], dim=0)
original_global_pose = original_code['pose'][:, :3]
original_jaw_pose = original_code['pose'][:, 3:]
original_jaw_pose = torch.cat([original_jaw_pose, original_jaw_pose[new_order]], dim=0)
original_global_pose = torch.cat([original_global_pose, original_global_pose], dim=0)
original_code['pose'] = torch.cat([original_global_pose, original_jaw_pose], dim=1)
original_code['cam'] = torch.cat([original_code['cam'], original_code['cam']], dim=0)
original_code['light'] = torch.cat([original_code['light'], original_code['light']], dim=0)
elif self.deca.config.shape_constrain_type == 'shuffle_shape':
## The shape codes are shuffled without duplication
new_order = np.random.permutation(K*original_batch_size)
old_order = np.arange(K*original_batch_size)
while (new_order == old_order).any(): # ugly hacky way of assuring that every element is permuted
new_order = np.random.permutation(K * original_batch_size)
codedict['new_order'] = new_order
shapecode_new = shapecode[new_order]
## append new shape code data
shapecode = torch.cat([shapecode, shapecode_new], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
expcode = torch.cat([expcode, expcode], dim=0)
posecode = torch.cat([posecode, posecode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## append gt
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
if lmk is not None:
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
masks = torch.cat([masks, masks], dim=0)
ref_images_identity_idxs = np.concatenate([old_order, new_order])
ref_images_expression_idxs = np.concatenate([old_order, old_order])
codedict["ref_images_identity_idxs"] = ref_images_identity_idxs
codedict["ref_images_expression_idxs"] = ref_images_expression_idxs
if va is not None:
va = torch.cat([va, va], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7], dim=0)
# do the same for the original code dict
shapecode_orig = original_code['shape']
shapecode_orig_new = shapecode_orig[new_order]
original_code['shape'] = torch.cat([shapecode_orig, shapecode_orig_new], dim=0)
original_code['tex'] = torch.cat([original_code['tex'], original_code['tex']], dim=0)
original_code['exp'] = torch.cat([original_code['exp'], original_code['exp']], dim=0)
original_code['pose'] = torch.cat([original_code['pose'], original_code['pose']], dim=0)
original_code['cam'] = torch.cat([original_code['cam'], original_code['cam']], dim=0)
original_code['light'] = torch.cat([original_code['light'], original_code['light']], dim=0)
original_code['ref_images_identity_idxs'] = ref_images_identity_idxs
original_code['ref_images_expression_idxs'] = ref_images_expression_idxs
elif 'expression_constrain_type' in self.deca.config.keys() and \
self.deca.config.expression_constrain_type == 'same':
## NOT USED IN EMOCA OR DECA, deprecated
# reshape shapecode => [B, K, n_shape]
# shapecode_idK = shapecode.view(self.batch_size, self.deca.K, -1)
expcode_idK = expcode.view(original_batch_size, K, -1)
# get mean id
expcode_mean = torch.mean(expcode_idK, dim=[1])
# shapecode_new = shapecode_mean[:, None, :].repeat(1, self.deca.K, 1)
expcode_new = expcode_mean[:, None, :].repeat(1, K, 1)
expcode = expcode_new.view(-1, self.deca._get_num_shape_params())
# do the same thing for the original code dict
expcode_idK = original_code['exp'].view(original_batch_size, K, -1)
expcode_mean = torch.mean(expcode_idK, dim=[1])
expcode_new = expcode_mean[:, None, :].repeat(1, K, 1)
original_code['exp'] = expcode_new.view(-1, self.deca._get_num_shape_params())
elif 'expression_constrain_type' in self.deca.config.keys() and \
self.deca.config.expression_constrain_type == 'exchange':
## NOT USED IN EMOCA OR DECA, deprecated
expcode, posecode, shapecode, lightcode, texcode, images, cam, lmk, \
masks, va, expr7, affectnetexp, _, _, exprw, lmk_mp, mica_images = \
self._expression_ring_exchange(original_batch_size, K,
expcode, posecode, shapecode, lightcode, texcode,
images, cam, lmk, masks, va, expr7, affectnetexp, None, None, exprw, lmk_mp, mica_images)
# (self, original_batch_size, K,
# expcode, posecode, shapecode, lightcode, texcode,
# images, cam, lmk, masks, va, expr7, affectnetexp,
# detailcode=None, detailemocode=None, exprw=None):
# 2) DETAIL STAGE
if self.mode == DecaMode.DETAIL:
all_detailcode = self.deca.E_detail(images)
# identity-based detail code
detailcode = all_detailcode[:, :self.deca.n_detail]
# detail emotion code is deprecated and will be empty
detailemocode = all_detailcode[:, self.deca.n_detail:(self.deca.n_detail + self.deca.n_detail_emo)]
if training:
# If training, we employ the disentanglement strategy
if self.deca.config.detail_constrain_type == 'exchange':
# Identity within the same ring should be the same, so they should have the same code.
# This can be enforced by shuffling. The batch is duplicated and the duplicated part's code shuffled
'''
make sure s0, s1 is something to make shape close
the difference from ||so - s1|| is
the later encourage s0, s1 is cloase in l2 space, but not really ensure shape will be close
'''
# this creates a per-ring random permutation. The detail exchange happens ONLY between the same
# identities (within the ring) but not outside (no cross-identity detail exchange)
new_order = np.array(
# [np.random.permutation(self.deca.config.train_K) + i * self.deca.config.train_K for i in range(original_batch_size)])
[np.random.permutation(K) + i * K for i in range(original_batch_size)])
new_order = new_order.flatten()
detailcode_new = detailcode[new_order]
detailcode = torch.cat([detailcode, detailcode_new], dim=0)
detailemocode = torch.cat([detailemocode, detailemocode], dim=0)
## append new shape code data
shapecode = torch.cat([shapecode, shapecode], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
expcode = torch.cat([expcode, expcode], dim=0)
posecode = torch.cat([posecode, posecode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## append gt
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
masks = torch.cat([masks, masks], dim=0)
if va is not None:
va = torch.cat([va, va], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7], dim=0)
elif self.deca.config.detail_constrain_type == 'shuffle_expression':
## Deprecated and not used in EMOCA or DECA
new_order = np.random.permutation(K*original_batch_size)
old_order = np.arange(K*original_batch_size)
while (new_order == old_order).any(): # ugly hacky way of assuring that every element is permuted
new_order = np.random.permutation(K * original_batch_size)
codedict['new_order'] = new_order
# exchange expression
expcode_new = expcode[new_order]
expcode = torch.cat([expcode, expcode_new], dim=0)
# exchange emotion code, but not (identity-based) detailcode
detailemocode_new = detailemocode[new_order]
detailemocode = torch.cat([detailemocode, detailemocode_new], dim=0)
detailcode = torch.cat([detailcode, detailcode], dim=0)
# exchange jaw pose (but not global pose)
global_pose = posecode[:, :3]
jaw_pose = posecode[:, 3:]
jaw_pose_new = jaw_pose[new_order]
jaw_pose = torch.cat([jaw_pose, jaw_pose_new], dim=0)
global_pose = torch.cat([global_pose, global_pose], dim=0)
posecode = torch.cat([global_pose, jaw_pose], dim=1)
## duplicate the rest
shapecode = torch.cat([shapecode, shapecode], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## duplicate gt if any
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
print(f"TRAINING: {training}")
if lmk is not None:
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
masks = torch.cat([masks, masks], dim=0)
ref_images_identity_idxs = np.concatenate([old_order, old_order])
ref_images_expression_idxs = np.concatenate([old_order, new_order])
codedict["ref_images_identity_idxs"] = ref_images_identity_idxs
codedict["ref_images_expression_idxs"] = ref_images_expression_idxs
if va is not None:
va = torch.cat([va, va[new_order]], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7[new_order]], dim=0)
elif self.deca.config.detail_constrain_type == 'shuffle_shape':
## Shuffles teh shape code without duplicating the batch
new_order = np.random.permutation(K*original_batch_size)
old_order = np.arange(K*original_batch_size)
while (new_order == old_order).any(): # ugly hacky way of assuring that every element is permuted
new_order = np.random.permutation(K * original_batch_size)
codedict['new_order'] = new_order
shapecode_new = shapecode[new_order]
## append new shape code data
shapecode = torch.cat([shapecode, shapecode_new], dim=0)
# exchange (identity-based) detailcode, but not emotion code
detailcode_new = detailcode[new_order]
detailcode = torch.cat([detailcode, detailcode_new], dim=0)
detailemocode = torch.cat([detailemocode, detailemocode], dim=0)
texcode = torch.cat([texcode, texcode], dim=0)
expcode = torch.cat([expcode, expcode], dim=0)
posecode = torch.cat([posecode, posecode], dim=0)
cam = torch.cat([cam, cam], dim=0)
lightcode = torch.cat([lightcode, lightcode], dim=0)
## append gt
images = torch.cat([images, images],
dim=0) # images = images.view(-1, images.shape[-3], images.shape[-2], images.shape[-1])
if mica_images is not None:
mica_images = torch.cat([mica_images, mica_images], dim=0)
if lmk is not None:
lmk = torch.cat([lmk, lmk], dim=0) # lmk = lmk.view(-1, lmk.shape[-2], lmk.shape[-1])
masks = torch.cat([masks, masks], dim=0)
ref_images_identity_idxs = np.concatenate([old_order, new_order])
ref_images_expression_idxs = np.concatenate([old_order, old_order])
codedict["ref_images_identity_idxs"] = ref_images_identity_idxs
codedict["ref_images_expression_idxs"] = ref_images_expression_idxs
if va is not None:
va = torch.cat([va, va], dim=0)
if expr7 is not None:
expr7 = torch.cat([expr7, expr7], dim=0)
elif 'expression_constrain_type' in self.deca.config.keys() and \
self.deca.config.expression_constrain_type == 'exchange':
expcode, posecode, shapecode, lightcode, texcode, images, cam, lmk, masks, va, expr7, affectnetexp, detailcode, detailemocode, exprw, lmk_mp, mica_images = \
self._expression_ring_exchange(original_batch_size, K,
expcode, posecode, shapecode, lightcode, texcode,
images, cam, lmk, masks, va, expr7, affectnetexp, detailcode, detailemocode, exprw, lmk_mp, mica_images)
codedict['shapecode'] = shapecode
codedict['texcode'] = texcode
codedict['expcode'] = expcode
codedict['posecode'] = posecode
codedict['cam'] = cam
codedict['lightcode'] = lightcode
if self.mode == DecaMode.DETAIL:
codedict['detailcode'] = detailcode
codedict['detailemocode'] = detailemocode
codedict['images'] = images
if mica_images is not None:
codedict['mica_images'] = mica_images
if 'mask' in batch.keys():
codedict['masks'] = masks
if 'landmark' in batch.keys():
codedict['lmk'] = lmk
if lmk_mp is not None:
codedict['lmk_mp'] = lmk_mp
if 'va' in batch.keys():
codedict['va'] = va
if 'expr7' in batch.keys():
codedict['expr7'] = expr7
if 'affectnetexp' in batch.keys():
codedict['affectnetexp'] = affectnetexp
if 'expression_weight' in batch.keys():
codedict['expression_weight'] = exprw
if original_code is not None:
codedict['original_code'] = original_code
return codedict
def _create_conditioning_lists(self, codedict, condition_list):
detail_conditioning_list = []
if 'globalpose' in condition_list:
detail_conditioning_list += [codedict["posecode"][:, :3]]
if 'jawpose' in condition_list:
detail_conditioning_list += [codedict["posecode"][:, 3:]]
if 'identity' in condition_list:
detail_conditioning_list += [codedict["shapecode"]]
if 'expression' in condition_list:
detail_conditioning_list += [codedict["expcode"]]
if isinstance(self.deca.D_detail, Generator):
# the detail codes might be excluded from conditioning based on the Generator architecture (for instance
# for AdaIn Generator)
if 'detail' in condition_list:
detail_conditioning_list += [codedict["detailcode"]]
if 'detailemo' in condition_list:
detail_conditioning_list += [codedict["detailemocode"]]
return detail_conditioning_list
def decode(self, codedict, training=True, render=True, **kwargs) -> dict:
"""
Forward decoding pass of the model. Takes the latent code predicted by the encoding stage and reconstructs and renders the shape.
:param codedict: Batch dict of the predicted latent codes
:param training: Whether the forward pass is for training or testing.
"""
shapecode = codedict['shapecode']
expcode = codedict['expcode']
posecode = codedict['posecode']
texcode = codedict['texcode']
cam = codedict['cam']
lightcode = codedict['lightcode']
images = codedict['images']
if 'masks' in codedict.keys():
masks = codedict['masks']
else:
masks = None
effective_batch_size = images.shape[0] # this is the current batch size after all training augmentations modifications
# 1) Reconstruct the face mesh
# FLAME - world space
if not isinstance(self.deca.flame, FLAME_mediapipe):
verts, landmarks2d, landmarks3d = self.deca.flame(shape_params=shapecode, expression_params=expcode,
pose_params=posecode)
landmarks2d_mediapipe = None
else:
verts, landmarks2d, landmarks3d, landmarks2d_mediapipe = self.deca.flame(shapecode, expcode, posecode)
# world to camera
trans_verts = util.batch_orth_proj(verts, cam)
predicted_landmarks = util.batch_orth_proj(landmarks2d, cam)[:, :, :2]
# camera to image space
trans_verts[:, :, 1:] = -trans_verts[:, :, 1:]
predicted_landmarks[:, :, 1:] = - predicted_landmarks[:, :, 1:]
if landmarks2d_mediapipe is not None:
predicted_landmarks_mediapipe = util.batch_orth_proj(landmarks2d_mediapipe, cam)[:, :, :2]
predicted_landmarks_mediapipe[:, :, 1:] = - predicted_landmarks_mediapipe[:, :, 1:]
if self.uses_texture():
albedo = self.deca.flametex(texcode)
else:
# if not using texture, default to gray
albedo = torch.ones([effective_batch_size, 3, self.deca.config.uv_size, self.deca.config.uv_size], device=images.device) * 0.5
# 2) Render the coarse image
if render:
ops = self.deca.render(verts, trans_verts, albedo, lightcode)
# mask
mask_face_eye = F.grid_sample(self.deca.uv_face_eye_mask.expand(effective_batch_size, -1, -1, -1),
ops['grid'].detach(),
align_corners=False)
# images
predicted_images = ops['images']
# predicted_images = ops['images'] * mask_face_eye * ops['alpha_images']
# predicted_images_no_mask = ops['images'] #* mask_face_eye * ops['alpha_images']
segmentation_type = None
if isinstance(self.deca.config.useSeg, bool):
if self.deca.config.useSeg:
segmentation_type = 'gt'
else:
segmentation_type = 'rend'
elif isinstance(self.deca.config.useSeg, str):
segmentation_type = self.deca.config.useSeg
else:
raise RuntimeError(f"Invalid 'useSeg' type: '{type(self.deca.config.useSeg)}'")
if segmentation_type not in ["gt", "rend", "intersection", "union"]:
raise ValueError(f"Invalid segmentation type for masking '{segmentation_type}'")
if masks is None: # if mask not provided, the only mask available is the rendered one
segmentation_type = 'rend'
elif masks.shape[-1] != predicted_images.shape[-1] or masks.shape[-2] != predicted_images.shape[-2]:
# resize masks if need be (this is only done if configuration was changed at some point after training)
dims = masks.ndim == 3
if dims:
masks = masks[:, None, :, :]
masks = F.interpolate(masks, size=predicted_images.shape[-2:], mode='bilinear')
if dims:
masks = masks[:, 0, ...]
# resize images if need be (this is only done if configuration was changed at some point after training)
if images.shape[-1] != predicted_images.shape[-1] or images.shape[-2] != predicted_images.shape[-2]:
## special case only for inference time if the rendering image sizes have been changed
images_resized = F.interpolate(images, size=predicted_images.shape[-2:], mode='bilinear')
else:
images_resized = images
# what type of segmentation we use
if segmentation_type == "gt": # GT stands for external segmetnation predicted by face parsing or similar
masks = masks[:, None, :, :]
elif segmentation_type == "rend": # mask rendered as a silhouette of the face mesh
masks = mask_face_eye * ops['alpha_images']
elif segmentation_type == "intersection": # intersection of the two above
masks = masks[:, None, :, :] * mask_face_eye * ops['alpha_images']
elif segmentation_type == "union": # union of the first two options
masks = torch.max(masks[:, None, :, :], mask_face_eye * ops['alpha_images'])
else:
raise RuntimeError(f"Invalid segmentation type for masking '{segmentation_type}'")
if self.deca.config.background_from_input in [True, "input"]:
if images.shape[-1] != predicted_images.shape[-1] or images.shape[-2] != predicted_images.shape[-2]:
## special case only for inference time if the rendering image sizes have been changed
predicted_images = (1. - masks) * images_resized + masks * predicted_images
else:
predicted_images = (1. - masks) * images + masks * predicted_images
elif self.deca.config.background_from_input in [False, "black"]:
predicted_images = masks * predicted_images
elif self.deca.config.background_from_input in ["none"]:
predicted_images = predicted_images
else:
raise ValueError(f"Invalid type of background modification {self.deca.config.background_from_input}")
# 3) Render the detail image
if self.mode == DecaMode.DETAIL:
detailcode = codedict['detailcode']
detailemocode = codedict['detailemocode']
# a) Create the detail conditioning lists
detail_conditioning_list = self._create_conditioning_lists(codedict, self.detail_conditioning)
detailemo_conditioning_list = self._create_conditioning_lists(codedict, self.detailemo_conditioning)
final_detail_conditioning_list = detail_conditioning_list + detailemo_conditioning_list
# b) Pass the detail code and the conditions through the detail generator to get displacement UV map
if isinstance(self.deca.D_detail, Generator):
uv_z = self.deca.D_detail(torch.cat(final_detail_conditioning_list, dim=1))
elif isinstance(self.deca.D_detail, GeneratorAdaIn):
uv_z = self.deca.D_detail(z=torch.cat([detailcode, detailemocode], dim=1),
cond=torch.cat(final_detail_conditioning_list, dim=1))
else:
raise ValueError(f"This class of generarator is not supported: '{self.deca.D_detail.__class__.__name__}'")
# if there is a displacement mask, apply it (DEPRECATED and not USED in DECA or EMOCA)
if hasattr(self.deca, 'displacement_mask') and self.deca.displacement_mask is not None:
if 'apply_displacement_masks' in self.deca.config.keys() and self.deca.config.apply_displacement_masks:
uv_z = uv_z * self.deca.displacement_mask
# uv_z = self.deca.D_detail(torch.cat([posecode[:, 3:], expcode, detailcode], dim=1))
# render detail
if render:
detach_from_coarse_geometry = not self.deca.config.train_coarse
uv_detail_normals, uv_coarse_vertices = self.deca.displacement2normal(uv_z, verts, ops['normals'],
detach=detach_from_coarse_geometry)
uv_shading = self.deca.render.add_SHlight(uv_detail_normals, lightcode.detach())
uv_texture = albedo.detach() * uv_shading
# batch size X image_rows X image_cols X 2
# you can query the grid for UV values of the face mesh at pixel locations
grid = ops['grid']
if detach_from_coarse_geometry:
# if the grid is detached, the gradient of the positions of UV-values in image space won't flow back to the geometry
grid = grid.detach()
predicted_detailed_image = F.grid_sample(uv_texture, grid, align_corners=False)
if self.deca.config.background_from_input in [True, "input"]:
if images.shape[-1] != predicted_images.shape[-1] or images.shape[-2] != predicted_images.shape[-2]:
## special case only for inference time if the rendering image sizes have been changed
# images_resized = F.interpolate(images, size=predicted_images.shape[-2:], mode='bilinear')
## before bugfix
# predicted_images = (1. - masks) * images_resized + masks * predicted_images
## after bugfix
predicted_detailed_image = (1. - masks) * images_resized + masks * predicted_detailed_image
else:
predicted_detailed_image = (1. - masks) * images + masks * predicted_detailed_image
elif self.deca.config.background_from_input in [False, "black"]:
predicted_detailed_image = masks * predicted_detailed_image
elif self.deca.config.background_from_input in ["none"]:
predicted_detailed_image = predicted_detailed_image
else:
raise ValueError(f"Invalid type of background modification {self.deca.config.background_from_input}")
# --- extract texture
uv_pverts = self.deca.render.world2uv(trans_verts).detach()
uv_gt = F.grid_sample(torch.cat([images_resized, masks], dim=1), uv_pverts.permute(0, 2, 3, 1)[:, :, :, :2],
mode='bilinear')
uv_texture_gt = uv_gt[:, :3, :, :].detach()
uv_mask_gt = uv_gt[:, 3:, :, :].detach()
# self-occlusion
normals = util.vertex_normals(trans_verts, self.deca.render.faces.expand(effective_batch_size, -1, -1))
uv_pnorm = self.deca.render.world2uv(normals)
uv_mask = (uv_pnorm[:, -1, :, :] < -0.05).float().detach()
uv_mask = uv_mask[:, None, :, :]
## combine masks
uv_vis_mask = uv_mask_gt * uv_mask * self.deca.uv_face_eye_mask
else:
uv_detail_normals = None
predicted_detailed_image = None
## 4) (Optional) NEURAL RENDERING - not used in neither DECA nor EMOCA
# If neural rendering is enabled, the differentiable rendered synthetic images are translated using an image translation net (such as StarGan)
predicted_translated_image = None
predicted_detailed_translated_image = None
translated_uv_texture = None
if render:
if self.deca._has_neural_rendering():
predicted_translated_image = self.deca.image_translator(
{
"input_image" : predicted_images,
"ref_image" : images,
"target_domain" : torch.tensor([0]*predicted_images.shape[0],
dtype=torch.int64, device=predicted_images.device)
}
)
if self.mode == DecaMode.DETAIL:
predicted_detailed_translated_image = self.deca.image_translator(
{
"input_image" : predicted_detailed_image,
"ref_image" : images,
"target_domain" : torch.tensor([0]*predicted_detailed_image.shape[0],
dtype=torch.int64, device=predicted_detailed_image.device)
}
)
translated_uv = F.grid_sample(torch.cat([predicted_detailed_translated_image, masks], dim=1), uv_pverts.permute(0, 2, 3, 1)[:, :, :, :2],
mode='bilinear')
translated_uv_texture = translated_uv[:, :3, :, :].detach()
else:
predicted_detailed_translated_image = None
translated_uv_texture = None
# no need in coarse mode
# translated_uv = F.grid_sample(torch.cat([predicted_translated_image, masks], dim=1), uv_pverts.permute(0, 2, 3, 1)[:, :, :, :2],
# mode='bilinear')
# translated_uv_texture = translated_uv_gt[:, :3, :, :].detach()
if self.emotion_mlp is not None:
codedict = self.emotion_mlp(codedict, "emo_mlp_")
# populate the value dict for metric computation/visualization
if render:
codedict['predicted_images'] = predicted_images
codedict['predicted_detailed_image'] = predicted_detailed_image
codedict['predicted_translated_image'] = predicted_translated_image
codedict['ops'] = ops
codedict['normals'] = ops['normals']
codedict['mask_face_eye'] = mask_face_eye
codedict['verts'] = verts
codedict['albedo'] = albedo
codedict['landmarks2d'] = landmarks2d
codedict['landmarks3d'] = landmarks3d
codedict['predicted_landmarks'] = predicted_landmarks
if landmarks2d_mediapipe is not None:
codedict['predicted_landmarks_mediapipe'] = predicted_landmarks_mediapipe
codedict['trans_verts'] = trans_verts
codedict['masks'] = masks
if self.mode == DecaMode.DETAIL:
if render:
codedict['predicted_detailed_translated_image'] = predicted_detailed_translated_image
codedict['translated_uv_texture'] = translated_uv_texture
codedict['uv_texture_gt'] = uv_texture_gt
codedict['uv_texture'] = uv_texture
codedict['uv_detail_normals'] = uv_detail_normals
codedict['uv_shading'] = uv_shading
codedict['uv_vis_mask'] = uv_vis_mask
codedict['uv_mask'] = uv_mask
codedict['uv_z'] = uv_z
codedict['displacement_map'] = uv_z + self.deca.fixed_uv_dis[None, None, :, :]
return codedict
def _compute_emotion_loss(self, images, predicted_images, loss_dict, metric_dict, prefix, va=None, expr7=None, with_grad=True,
batch_size=None, ring_size=None):
def loss_or_metric(name, loss, is_loss):
if not is_loss:
metric_dict[name] = loss
else:
loss_dict[name] = loss
# if self.deca.config.use_emonet_loss:
if with_grad:
d = loss_dict
emo_feat_loss_1, emo_feat_loss_2, valence_loss, arousal_loss, expression_loss, au_loss = \
self.emonet_loss.compute_loss(images, predicted_images, batch_size=batch_size, ring_size=ring_size)
else:
d = metric_dict
with torch.no_grad():
emo_feat_loss_1, emo_feat_loss_2, valence_loss, arousal_loss, expression_loss, au_loss = \
self.emonet_loss.compute_loss(images, predicted_images, batch_size=batch_size, ring_size=ring_size)
# EmoNet self-consistency loss terms
if emo_feat_loss_1 is not None:
loss_or_metric(prefix + '_emonet_feat_1_L1', emo_feat_loss_1 * self.deca.config.emonet_weight,
self.deca.config.use_emonet_feat_1 and self.deca.config.use_emonet_loss)
loss_or_metric(prefix + '_emonet_feat_2_L1', emo_feat_loss_2 * self.deca.config.emonet_weight,
self.deca.config.use_emonet_feat_2 and self.deca.config.use_emonet_loss)
loss_or_metric(prefix + '_emonet_valence_L1', valence_loss * self.deca.config.emonet_weight,
self.deca.config.use_emonet_valence and self.deca.config.use_emonet_loss)
loss_or_metric(prefix + '_emonet_arousal_L1', arousal_loss * self.deca.config.emonet_weight,
self.deca.config.use_emonet_arousal and self.deca.config.use_emonet_loss)
# loss_or_metric(prefix + 'emonet_expression_KL', expression_loss * self.deca.config.emonet_weight) # KL seems to be causing NaN's
loss_or_metric(prefix + '_emonet_expression_L1',expression_loss * self.deca.config.emonet_weight,
self.deca.config.use_emonet_expression and self.deca.config.use_emonet_loss)
loss_or_metric(prefix + '_emonet_combined', ((emo_feat_loss_1 if emo_feat_loss_1 is not None else 0)
+ emo_feat_loss_2 + valence_loss + arousal_loss + expression_loss) * self.deca.config.emonet_weight,
self.deca.config.use_emonet_combined and self.deca.config.use_emonet_loss)
# Log also the VA
metric_dict[prefix + "_valence_input"] = self.emonet_loss.input_emotion['valence'].mean().detach()
metric_dict[prefix + "_valence_output"] = self.emonet_loss.output_emotion['valence'].mean().detach()
metric_dict[prefix + "_arousal_input"] = self.emonet_loss.input_emotion['arousal'].mean().detach()
metric_dict[prefix + "_arousal_output"] = self.emonet_loss.output_emotion['arousal'].mean().detach()
input_ex = self.emonet_loss.input_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification'].detach().cpu().numpy()
input_ex = np.argmax(input_ex, axis=1).mean()
output_ex = self.emonet_loss.output_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification'].detach().cpu().numpy()
output_ex = np.argmax(output_ex, axis=1).mean()
metric_dict[prefix + "_expression_input"] = torch.tensor(input_ex, device=self.device)
metric_dict[prefix + "_expression_output"] = torch.tensor(output_ex, device=self.device)
# # GT emotion loss terms
# if self.deca.config.use_gt_emotion_loss:
# d = loss_dict
# else:
# d = metric_dict
# TODO: uncomment this after you handle the case when certain entries are NaN (GT missing, not a bug)
# if va is not None:
# d[prefix + 'emo_sup_val_L1'] = F.l1_loss(self.emonet_loss.output_emotion['valence'], va[:, 0]) \
# * self.deca.config.gt_emotion_reg
# d[prefix + 'emo_sup_ar_L1'] = F.l1_loss(self.emonet_loss.output_emotion['arousal'], va[:, 1]) \
# * self.deca.config.gt_emotion_reg
#
# metric_dict[prefix + "_valence_gt"] = va[:, 0].mean().detach()
# metric_dict[prefix + "_arousal_gt"] = va[:, 1].mean().detach()
#
# if expr7 is not None:
# affectnet_gt = [expr7_to_affect_net(int(expr7[i])).value for i in range(len(expr7))]
# affectnet_gt = torch.tensor(np.array(affectnet_gt), device=self.device, dtype=torch.long)
# d[prefix + '_emo_sup_expr_CE'] = F.cross_entropy(self.emonet_loss.output_emotion['expression'], affectnet_gt) * self.deca.config.gt_emotion_reg
# metric_dict[prefix + "_expr_gt"] = affectnet_gt.mean().detach()
def _compute_au_loss(self, images, predicted_images, loss_dict, metric_dict, prefix, au=None, with_grad=True):
def loss_or_metric(name, loss, is_loss):
if not is_loss:
metric_dict[name] = loss
else:
loss_dict[name] = loss
# if self.deca.config.use_emonet_loss:
if with_grad:
d = loss_dict
au_feat_loss_1, au_feat_loss_2, _, _, _, au_loss = \
self.au_loss.compute_loss(images, predicted_images)
else:
d = metric_dict
with torch.no_grad():
au_feat_loss_1, au_feat_loss_2, _, _, _, au_loss = \
self.au_loss.compute_loss(images, predicted_images)
# EmoNet self-consistency loss terms
if au_feat_loss_1 is not None:
loss_or_metric(prefix + '_au_feat_1_L1', au_feat_loss_1 * self.deca.config.au_loss.au_weight,
self.deca.config.au_loss.use_feat_1 and self.deca.config.au_loss.use_as_loss)
loss_or_metric(prefix + '_au_feat_2_L1', au_feat_loss_2 * self.deca.config.au_loss.au_weight,
self.deca.config.au_loss.use_feat_2 and self.deca.config.au_loss.use_as_loss)
loss_or_metric(prefix + '_au_loss', au_loss * self.deca.config.au_loss.au_weight,
self.deca.config.au_loss.use_aus and self.deca.config.au_loss.use_as_loss)
# loss_or_metric(prefix + '_au_losses_L1', arousal_loss * self.deca.config.au_loss.au_weight,
# self.deca.config.au_loss.use_emonet_arousal and self.deca.config.au_loss.use_as_loss)
# loss_or_metric(prefix + 'emonet_expression_KL', expression_loss * self.deca.config.au_loss.au_weight) # KL seems to be causing NaN's
# # Log also the VA
# metric_dict[prefix + "_valence_input"] = self.emonet_loss.input_emotion['valence'].mean().detach()
# metric_dict[prefix + "_valence_output"] = self.emonet_loss.output_emotion['valence'].mean().detach()
# metric_dict[prefix + "_arousal_input"] = self.emonet_loss.input_emotion['arousal'].mean().detach()
# metric_dict[prefix + "_arousal_output"] = self.emonet_loss.output_emotion['arousal'].mean().detach()
# input_ex = self.emonet_loss.input_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification'].detach().cpu().numpy()
# input_ex = np.argmax(input_ex, axis=1).mean()
# output_ex = self.emonet_loss.output_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification'].detach().cpu().numpy()
# output_ex = np.argmax(output_ex, axis=1).mean()
# metric_dict[prefix + "_expression_input"] = torch.tensor(input_ex, device=self.device)
# metric_dict[prefix + "_expression_output"] = torch.tensor(output_ex, device=self.device)
# # GT emotion loss terms
# if self.deca.config.use_gt_emotion_loss:
# d = loss_dict
# else:
# d = metric_dict
def _cut_mouth_vectorized(self, images, landmarks, convert_grayscale=True):
# mouth_window_margin = 12
mouth_window_margin = 1 # not temporal
mouth_crop_height = 96
mouth_crop_width = 96
mouth_landmark_start_idx = 48
mouth_landmark_stop_idx = 68
B, T = images.shape[:2]
landmarks = landmarks.to(torch.float32)
with torch.no_grad():
image_size = images.shape[-1] / 2
landmarks = landmarks * image_size + image_size
# #1) smooth the landmarks with temporal convolution
# landmarks are of shape (T, 68, 2)
# reshape to (T, 136)
landmarks_t = landmarks.reshape(*landmarks.shape[:2], -1)
# make temporal dimension last
landmarks_t = landmarks_t.permute(0, 2, 1)
# change chape to (N, 136, T)
# landmarks_t = landmarks_t.unsqueeze(0)
# smooth with temporal convolution
temporal_filter = torch.ones(mouth_window_margin, device=images.device) / mouth_window_margin
# pad the the landmarks
landmarks_t_padded = F.pad(landmarks_t, (mouth_window_margin // 2, mouth_window_margin // 2), mode='replicate')
# convolve each channel separately with the temporal filter
num_channels = landmarks_t.shape[1]
if temporal_filter.numel() > 1:
smooth_landmarks_t = F.conv1d(landmarks_t_padded,
temporal_filter.unsqueeze(0).unsqueeze(0).expand(num_channels,1,temporal_filter.numel()),
groups=num_channels, padding='valid'
)
smooth_landmarks_t = smooth_landmarks_t[..., 0:landmarks_t.shape[-1]]
else:
smooth_landmarks_t = landmarks_t
# reshape back to the original shape
smooth_landmarks_t = smooth_landmarks_t.permute(0, 2, 1).view(landmarks.shape)
smooth_landmarks_t = smooth_landmarks_t + landmarks.mean(dim=2, keepdims=True) - smooth_landmarks_t.mean(dim=2, keepdims=True)
# #2) get the mouth landmarks
mouth_landmarks_t = smooth_landmarks_t[..., mouth_landmark_start_idx:mouth_landmark_stop_idx, :]
# #3) get the mean of the mouth landmarks
mouth_landmarks_mean_t = mouth_landmarks_t.mean(dim=-2, keepdims=True)
# #4) get the center of the mouth
center_x_t = mouth_landmarks_mean_t[..., 0]
center_y_t = mouth_landmarks_mean_t[..., 1]
# #5) use grid_sample to crop the mouth in every image
# create the grid
height = mouth_crop_height//2
width = mouth_crop_width//2
torch.arange(0, mouth_crop_width, device=images.device)
grid = torch.stack(torch.meshgrid(torch.linspace(-height, height, mouth_crop_height).to(images.device) / (images.shape[-2] /2),
torch.linspace(-width, width, mouth_crop_width).to(images.device) / (images.shape[-1] /2) ),
dim=-1)
grid = grid[..., [1, 0]]
grid = grid.unsqueeze(0).unsqueeze(0).repeat(*images.shape[:2], 1, 1, 1)
center_x_t -= images.shape[-1] / 2
center_y_t -= images.shape[-2] / 2
center_x_t /= images.shape[-1] / 2
center_y_t /= images.shape[-2] / 2
grid = grid + torch.cat([center_x_t, center_y_t ], dim=-1).unsqueeze(-2).unsqueeze(-2)
images = images.view(B*T, *images.shape[2:])
grid = grid.view(B*T, *grid.shape[2:])
if convert_grayscale:
images = F_v.rgb_to_grayscale(images)
image_crops = F.grid_sample(
images,
grid,
align_corners=True,
padding_mode='zeros',
mode='bicubic'
)
image_crops = image_crops.view(B, T, *image_crops.shape[1:])
if convert_grayscale:
image_crops = image_crops#.squeeze(1)
# import matplotlib.pyplot as plt
# plt.figure()
# plt.imshow(image_crops[0, 0].permute(1,2,0).cpu().numpy())
# plt.show()
# plt.figure()
# plt.imshow(image_crops[0, 10].permute(1,2,0).cpu().numpy())
# plt.show()
# plt.figure()
# plt.imshow(image_crops[0, 20].permute(1,2,0).cpu().numpy())
# plt.show()
# plt.figure()
# plt.imshow(image_crops[1, 0].permute(1,2,0).cpu().numpy())
# plt.show()
# plt.figure()
# plt.imshow(image_crops[1, 10].permute(1,2,0).cpu().numpy())
# plt.show()
# plt.figure()
# plt.imshow(image_crops[1, 20].permute(1,2,0).cpu().numpy())
# plt.show()
return image_crops
def _compute_lipread_loss(self, images, predicted_images, landmarks, predicted_landmarks, loss_dict, metric_dict, prefix, with_grad=True):
def loss_or_metric(name, loss, is_loss):
if not is_loss:
metric_dict[name] = loss
else:
loss_dict[name] = loss
# shape of images is: (B, R, C, H, W)
# convert to (B * R, 1, H, W, C)
images = images.unsqueeze(1)
predicted_images = predicted_images.unsqueeze(1)
landmarks = landmarks.unsqueeze(1)
predicted_landmarks = predicted_landmarks.unsqueeze(1)
# cut out the mouth region
images_mouth = self._cut_mouth_vectorized(images, landmarks)
predicted_images_mouth = self._cut_mouth_vectorized(predicted_images, predicted_landmarks)
# make sure that the lip reading net interprests things with depth=1,
# if self.deca.config.use_emonet_loss:
if with_grad:
d = loss_dict
loss = self.lipread_loss.compute_loss(images_mouth, predicted_images_mouth)
else:
d = metric_dict
with torch.no_grad():
loss = self.lipread_loss.compute_loss(images_mouth, predicted_images_mouth)
d[prefix + '_lipread'] = loss * self.deca.config.lipread_loss.weight
def _metric_or_loss(self, loss_dict, metric_dict, is_loss):
if is_loss:
d = loss_dict
else:
d = metric_dict
return d
def _compute_id_loss(self, codedict, batch, training, testing, losses, batch_size,
ring_size):
# if self.deca.config.idw > 1e-3:
if self.deca.id_loss is not None:
images = codedict["images"]
ops = codedict["ops"]
mask_face_eye = codedict["mask_face_eye"]
shading_images = self.deca.render.add_SHlight(ops['normal_images'], codedict["lightcode"].detach())
albedo_images = F.grid_sample(codedict["albedo"].detach(), ops['grid'], align_corners=False)
# TODO: get to the bottom of this weird overlay thing - why is it there?
# answer: This renders the face and takes background from the image
overlay = albedo_images * shading_images * mask_face_eye + images * (1 - mask_face_eye)
if self.global_step >= self.deca.id_loss_start_step:
if 'id_metric' in self.deca.config.keys() and 'barlow_twins' in self.deca.config.id_metric:
assert ring_size == 1 or ring_size == 2
effective_bs = images.shape[0]
# losses['identity'] = self.deca.id_loss(overlay, images, batch_size=batch_size,
# ring_size=ring_size) * self.deca.config.idw
if "ref_images_identity_idxs" in codedict.keys():
# in case there was shuffling, this ensures that the proper images are used for identity loss
images_ = images[codedict["ref_images_identity_idxs"]]
else:
images_ = images
losses['identity'] = self.deca.id_loss(overlay, images_, batch_size=effective_bs,
ring_size=1) * self.deca.config.idw
if 'id_contrastive' in self.deca.config.keys() and bool(self.deca.config.id_contrastive):
if ring_size == 2:
assert effective_bs % 2 == 0
assert self.deca.id_loss.trainable
has_been_shuffled = 'new_order' in codedict.keys()
idxs_a = torch.arange(0, images.shape[0], 2) # indices of first images within the ring
idxs_b = torch.arange(1, images.shape[0], 2) # indices of second images within the ring
# WARNING - this assumes the ring is identity-based
if self.deca.config.id_contrastive in [True, "real", "both"]:
# we are taking this from the original batch dict because we do not care about the
# shuffled, duplicated samples (they don't have to be doubled)
images_0 = batch["image"][:, 0, ...]
images_1 = batch["image"][:, 1, ...]
losses['identity_contrastive_real'] = self.deca.id_loss(
images_0, # first images within the ring
images_1, # second images within the ring
batch_size=images_0.shape[0],
ring_size=1) * self.deca.config.idw * 2
if self.deca.config.id_contrastive in [True, "synth", "both"]:
if self.deca.config.shape_constrain_type in ['exchange', 'same']:
# we can take all when identity has been exchange within rings
overlay_0 = overlay[idxs_a]
overlay_1 = overlay[idxs_b]
else:
#if the batch was double otherwise (global shuffling) we only take the first half
# if batch_size * ring_size < effective_bs:
overlay_0 = overlay[0:batch_size * ring_size:2]
overlay_1 = overlay[1:batch_size * ring_size:2]
losses['identity_contrastive_synthetic'] = self.deca.id_loss(
overlay_0, # first images within the ring
overlay_1, # second images within the ring
batch_size=overlay_0.shape[0],
ring_size=1) * self.deca.config.idw
if has_been_shuffled:
new_order = codedict['new_order']
# TODO: compare the idxs to these:
# codedict["ref_images_identity_idxs"]
if self.deca.config.shape_constrain_type == 'shuffle_expression':
idxs_a_synth = np.arange(new_order.shape[0]) # first half of the batch
idxs_b_synth = np.arange(new_order.shape[0],
2 * new_order.shape[0]) # second half of the batch
elif self.deca.config.shape_constrain_type == 'shuffle_shape':
idxs_a_synth = new_order # shuffled first half of the batch
idxs_b_synth = np.arange(new_order.shape[0],
2 * new_order.shape[0]) # second half of the batch
else:
raise NotImplementedError("Unexpected shape consistency value ")
# if this doesn't go through, something went wrong with the shuffling indexations
assert codedict["shapecode"][idxs_a_synth].allclose(codedict["shapecode"][idxs_b_synth])
losses['identity_contrastive_synthetic_shuffled'] = self.deca.id_loss(
overlay[idxs_a_synth], # synthetic images of identities with reconstructed expressions
overlay[idxs_b_synth], # synthetic images of identities with shuffled expressions
batch_size=idxs_a_synth.size,
ring_size=1) * self.deca.config.idw
losses['identity_contrastive_synthetic2real_shuffled'] = self.deca.id_loss(
images[idxs_a_synth], # synthetic images of identities with reconstructed expressions
overlay[idxs_b_synth], # synthetic images of identities with shuffled expressions
batch_size=idxs_a_synth.size,
ring_size=1) * self.deca.config.idw
elif ring_size > 2:
raise NotImplementedError("Contrastive loss does not support ring sizes > 2.")
return losses
def _compute_emonet_loss_wrapper(self, codedict, batch, training, testing, losses, metrics, prefix, image_key,
with_grad, batch_size, ring_size):
if self.emonet_loss is not None:
if 'va' in codedict:
va = codedict['va']
va = va.view(-1, va.shape[-1])
else:
va = None
if 'expr7' in codedict:
expr7 = codedict['expr7']
expr7 = expr7.view(-1, expr7.shape[-1])
else:
expr7 = None
# with torch.no_grad():
# TODO: if expression shuffled, this needs to be changed, the input images no longer correspond
images = codedict["images"]
predicted_images = codedict[image_key]
effective_bs = images.shape[0]
if "ref_images_expression_idxs" in codedict.keys():
# in case there was shuffling, this ensures that the proper images are used for emotion loss
images_ = images[codedict["ref_images_expression_idxs"]]
else:
images_ = images
effective_bs = images.shape[0]
self._compute_emotion_loss(images_, predicted_images, losses, metrics, f"{prefix}",
va, expr7,
with_grad=with_grad,
batch_size=effective_bs, ring_size=1)
codedict[f"{prefix}_valence_input"] = self.emonet_loss.input_emotion['valence']
codedict[f"{prefix}_arousal_input"] = self.emonet_loss.input_emotion['arousal']
codedict[f"{prefix}_expression_input"] = self.emonet_loss.input_emotion[
'expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification']
codedict[f"{prefix}_valence_output"] = self.emonet_loss.output_emotion['valence']
codedict[f"{prefix}_arousal_output"] = self.emonet_loss.output_emotion['arousal']
codedict[f"{prefix}_expression_output"] = self.emonet_loss.output_emotion[
'expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification']
if 'emo_contrastive' in self.deca.config.keys() and self.deca.config.emo_contrastive:
assert ring_size == 2 or ring_size == 1
assert self.emonet_loss.trainable or (
hasattr(self.emonet_loss, 'clone_is_trainable') and self.emonet_lossclone_is_trainable)
has_been_shuffled = 'new_order' in codedict.keys()
# if self.deca.config.shape_constrain_type == 'shuffle_expression' and has_been_shuffled:
# new_order = codedict['new_order']
#
if self.deca.config.emo_contrastive in [True, "real", "both"]:
if ring_size == 2:
assert effective_bs % 2 == 0
if not isinstance(self.deca, ExpDECA):
raise NotImplementedError("Cross-ring emotion contrast means the ring has to be "
"expression based, not identity based. This is not guaranteed "
"for vanilla EMOCA (or its datasets).")
# we are taking this from the original batch dict because we do not care about the
# shuffled, duplicated samples (they don't have to be doubled)
images_0 = batch["image"][:, 0, ...]
images_1 = batch["image"][:, 1, ...]
self._compute_emotion_loss(images_0, # real images of first expressions in the ring
images_1, # real images of second expressions in the ring
losses, metrics, f"{prefix}_contrastive_real",
va, expr7, with_grad=self.deca.config.use_emonet_loss,
batch_size=images_0.shape[0], ring_size=1)
else:
print("[WARNING] Cannot compute real contrastive emotion loss because there is no ring!")
if self.deca.config.emo_contrastive in [True, "synth", "both"]:
if ring_size == 2:
assert effective_bs % 2 == 0
idxs_a = torch.arange(0, images.shape[0], 2) # indices of first expressions within a ring
idxs_b = torch.arange(1, images.shape[0], 2) # indices of second expressions within a ring
if 'expression_constrain_type' in self.deca.config.keys() and \
self.deca.config.expression_constrain_type in ['exchange', 'same']:
# we can take all when identity has been exchange within rings
predicted_images_0 = predicted_images[idxs_a]
predicted_images_1 = predicted_images[idxs_b]
raise RuntimeError("This should work but it was never tested or intended. Make sure this works.")
else:
# if the batch was double otherwise (global shuffling) we only take the first half
# if batch_size * ring_size < effective_bs:
predicted_images_0 = predicted_images[0:batch_size * ring_size:2]
predicted_images_1 = predicted_images[1:batch_size * ring_size:2]
if not isinstance(self.deca, ExpDECA):
raise NotImplementedError("Cross-ring emotion contrast means the ring has to be "
"expression based, not identity based. This is not guaranteed "
"for vanilla EMOCA.")
self._compute_emotion_loss(predicted_images_0,
# rec images of first expressions in the ring
predicted_images_1,
# rec images of second expressions in the ring
losses, metrics, f"{prefix}_contrastive_synth",
va, expr7, with_grad=self.deca.config.use_emonet_loss,
batch_size=predicted_images_1.shape[0], ring_size=1)
else:
print("[WARNING] Cannot compute synthetic contrastive emotion loss because there is no ring!")
if has_been_shuffled:
new_order = codedict['new_order']
if self.deca.config.shape_constrain_type == 'shuffle_expression':
# this gets tricky, in this case the images are not duplicates -> we need all, but the second
# half's order is shuffled, so we need to be careful here
idxs_a_synth = new_order # shuffled first half of the batch
idxs_b_synth = np.arange(new_order.shape[0],
2 * new_order.shape[0]) # second half of the batch
elif self.deca.config.shape_constrain_type == 'shuffle_shape':
idxs_a_synth = np.arange(new_order.shape[0]) # first half of the batch
idxs_b_synth = np.arange(new_order.shape[0],
2 * new_order.shape[0]) # second half of the batch
# if this doesn't go through, something went wrong with the shuffling indexations
assert codedict["expcode"][idxs_a_synth].allclose(codedict["expcode"][idxs_b_synth])
# the expressions at corresponding index positions of idxs_a_synth and idxs_b_synth should match now
self._compute_emotion_loss(predicted_images[idxs_a_synth],
# synthetic images of reconstructed expressions and corresponding identities
predicted_images[idxs_b_synth],
# synthetic images of reconstructed expressions and shuffled identities
losses, metrics, f"{prefix}_contrastive_synth_shuffled",
va, expr7,
with_grad=self.deca.config.use_emonet_loss and not self.deca._has_neural_rendering(),
batch_size=idxs_a_synth.size, ring_size=1)
self._compute_emotion_loss(images[idxs_a_synth],
# synthetic images of reconstructed expressions and corresponding identities
predicted_images[idxs_b_synth],
# synthetic images of reconstructed expressions and shuffled identities
losses, metrics, f"{prefix}_contrastive_synth2real_shuffled",
va, expr7,
with_grad=self.deca.config.use_emonet_loss and not self.deca._has_neural_rendering(),
batch_size=idxs_a_synth.size,
ring_size=1)
if va is not None:
codedict[f"{prefix}_valence_gt"] = va[:, 0]
codedict[f"{prefix}_arousal_gt"] = va[:, 1]
if expr7 is not None:
codedict[f"{prefix}_expression_gt"] = expr7
if self.deca._has_neural_rendering():
assert 'emo_contrastive' not in self.deca.config.keys() or self.deca.config.emo_contrastive is False
# TODO possible to make this more GPU efficient by not recomputing emotion for input image
self._compute_emotion_loss(images, predicted_translated_image, losses, metrics, f"{prefix}_translated",
va, expr7,
with_grad=self.deca.config.use_emonet_loss and self.deca._has_neural_rendering(),
batch_size=bs,
ring_size=1)
# codedict[f"{prefix}_valence_input"] = self.emonet_loss.input_emotion['valence']
# codedict[f"{prefix}_arousal_input"] = self.emonet_loss.input_emotion['arousal']
# codedict[f"{prefix}_expression_input"] = self.emonet_loss.input_emotion['expression']
codedict[f"{prefix}_translated_valence_output"] = self.emonet_loss.output_emotion['valence']
codedict[f"{prefix}_translated_arousal_output"] = self.emonet_loss.output_emotion['arousal']
codedict[f"{prefix}_translated_expression_output"] = self.emonet_loss.output_emotion[
'expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification']
return losses, metrics, codedict
def _compute_loss(self, codedict, batch, training=True, testing=False):
#### ----------------------- Losses
losses = {}
metrics = {}
predicted_landmarks = codedict["predicted_landmarks"]
predicted_landmarks_mediapipe = codedict.get("predicted_landmarks_mediapipe", None)
if "lmk" in codedict.keys():
lmk = codedict["lmk"]
else:
lmk = None
if "lmk_mp" in codedict.keys():
lmk_mp = codedict["lmk_mp"]
else:
lmk_mp = None
if "masks" in codedict.keys():
masks = codedict["masks"]
else:
masks = None
batch_size = codedict["predicted_images"].shape[0]
use_geom_losses = 'use_geometric_losses_expression_exchange' in self.deca.config.keys() and \
self.deca.config.use_geometric_losses_expression_exchange
if training and ('expression_constrain_type' in self.deca.config.keys() \
and ('expression_constrain_type' in self.deca.config.keys() and self.deca.config.expression_constrain_type == 'exchange') or
( 'shape_constrain_type' in self.deca.config.keys() and
self.deca.config.shape_constrain_type in ['shuffle_expression', 'shuffle_shape'])) \
and (self.deca.mode == DecaMode.COARSE or self.deca.config.train_coarse) \
and (not use_geom_losses):
if batch_size % 2 != 0:
raise RuntimeError("The batch size should be even because it should have "
f"got doubled in expression ring exchange. Instead it was odd: {batch_size}")
# THIS IS DONE BECAUSE LANDMARK AND PHOTOMETRIC LOSSES MAKE NO SENSE FOR EXPRESSION EXCHANGE
geom_losses_idxs = batch_size // 2
else:
geom_losses_idxs = batch_size
predicted_images = codedict["predicted_images"]
images = codedict["images"]
lightcode = codedict["lightcode"]
albedo = codedict["albedo"]
mask_face_eye = codedict["mask_face_eye"]
shapecode = codedict["shapecode"]
expcode = codedict["expcode"]
texcode = codedict["texcode"]
ops = codedict["ops"]
if self.mode == DecaMode.DETAIL:
uv_texture = codedict["uv_texture"]
uv_texture_gt = codedict["uv_texture_gt"]
# this determines the configured batch size that is currently used (training, validation or testing)
# the reason why this is important is because of potential multi-gpu training and loss functions (such as Barlow Twins)
# that might need the full size of the batch (not just the chunk of the current GPU).
if training:
bs = self.learning_params.batch_size_train
rs = self.learning_params.train_K
else:
if not testing:
bs = self.learning_params.batch_size_val
rs = self.learning_params.val_K
else:
bs = self.learning_params.batch_size_test
rs = self.learning_params.test_K
## COARSE loss only
if self.mode == DecaMode.COARSE or (self.mode == DecaMode.DETAIL and self.deca.config.train_coarse):
# landmark losses (only useful if coarse model is being trained
# if training or lmk is not None:
if lmk is not None:
# if self.deca.config.use_landmarks:
# d = losses
# else:
# d = metrics
d = self._metric_or_loss(losses, metrics, self.deca.config.use_landmarks)
if self.deca.config.useWlmk:
d['landmark'] = \
lossfunc.weighted_landmark_loss(predicted_landmarks[:geom_losses_idxs, ...], lmk[:geom_losses_idxs, ...]) * self.deca.config.lmk_weight
else:
d['landmark'] = \
lossfunc.landmark_loss(predicted_landmarks[:geom_losses_idxs, ...], lmk[:geom_losses_idxs, ...]) * self.deca.config.lmk_weight
d = self._metric_or_loss(losses, metrics, 'use_eye_distance' not in self.deca.config.keys() or
self.deca.config.use_eye_distance)
# losses['eye_distance'] = lossfunc.eyed_loss(predicted_landmarks, lmk) * self.deca.config.lmk_weight * 2
d['eye_distance'] = lossfunc.eyed_loss(predicted_landmarks[:geom_losses_idxs, ...],
lmk[:geom_losses_idxs, ...]) * self.deca.config.eyed
d = self._metric_or_loss(losses, metrics, 'use_lip_distance' not in self.deca.config.keys() or
self.deca.config.use_lip_distance)
d['lip_distance'] = lossfunc.lipd_loss(predicted_landmarks[:geom_losses_idxs, ...],
lmk[:geom_losses_idxs, ...]) * self.deca.config.lipd
d = self._metric_or_loss(losses, metrics, 'use_mouth_corner_distance' in self.deca.config.keys() and
self.deca.config.use_mouth_corner_distance)
d['mouth_corner_distance'] = lossfunc.mouth_corner_loss(predicted_landmarks[:geom_losses_idxs, ...],
lmk[:geom_losses_idxs, ...]) * self.deca.config.lipd
if predicted_landmarks_mediapipe is not None and lmk_mp is not None:
use_mediapipe_landmarks = self.deca.config.get('use_mediapipe_landmarks', False)
d = self._metric_or_loss(losses, metrics, use_mediapipe_landmarks)
d['landmark_mediapipe'] =lossfunc_mp.landmark_loss(predicted_landmarks_mediapipe[:geom_losses_idxs, ...], lmk_mp[:geom_losses_idxs, ...]) * self.deca.config.lmk_weight_mp
d = self._metric_or_loss(losses, metrics, self.deca.config.get('use_eye_distance_mediapipe', False) )
d['eye_distance_mediapipe'] = lossfunc_mp.eyed_loss(predicted_landmarks_mediapipe[:geom_losses_idxs, ...],
lmk_mp[:geom_losses_idxs, ...]) * self.deca.config.eyed_mp
d = self._metric_or_loss(losses, metrics, self.deca.config.get('use_lip_distance_mediapipe', False) )
d['lip_distance_mediapipe'] = lossfunc_mp.lipd_loss(predicted_landmarks_mediapipe[:geom_losses_idxs, ...],
lmk_mp[:geom_losses_idxs, ...]) * self.deca.config.lipd_mp
d = self._metric_or_loss(losses, metrics, self.deca.config.get('use_mouth_corner_distance_mediapipe', False))
d['mouth_corner_distance_mediapipe'] = lossfunc_mp.mouth_corner_loss(predicted_landmarks_mediapipe[:geom_losses_idxs, ...],
lmk_mp[:geom_losses_idxs, ...]) * self.deca.config.lipd_mp
#TODO: fix this on the next iteration lipd_loss
# d['lip_distance'] = lossfunc.lipd_loss(predicted_landmarks, lmk) * self.deca.config.lipd
# photometric loss
# if training or masks is not None:
if masks is not None:
# if self.deca.config.use_photometric:
# d = losses
# else:
# d = metrics
# d['photometric_texture'] = (masks * (predicted_images - images).abs()).mean() * self.deca.config.photow
photometric = masks[:geom_losses_idxs, ...] * ((predicted_images[:geom_losses_idxs, ...] - images[:geom_losses_idxs, ...]).abs())
if 'photometric_normalization' not in self.deca.config.keys() or self.deca.config.photometric_normalization == 'mean':
photometric = photometric.mean()
elif self.deca.config.photometric_normalization == 'rel_mask_value':
photometric = photometric * masks[:geom_losses_idxs, ...].mean(dim=tuple(range(1,masks.ndim)), keepdim=True)
photometric = photometric.mean()
elif self.deca.config.photometric_normalization == 'neg_rel_mask_value':
mu = 1. - masks[:geom_losses_idxs, ...].mean(dim=tuple(range(1,masks.ndim)), keepdim=True)
photometric = photometric * mu
photometric = photometric.mean()
elif self.deca.config.photometric_normalization == 'inv_rel_mask_value':
mu = 1./ masks[:geom_losses_idxs, ...].mean(dim=tuple(range(1,masks.ndim)), keepdim=True)
photometric = photometric * mu
photometric = photometric.mean()
elif self.deca.config.photometric_normalization == 'abs_mask_value':
photometric = photometric * masks[:geom_losses_idxs, ...].sum(dim=tuple(range(1,masks.ndim)), keepdim=True)
photometric = photometric.mean()
else:
raise ValueError(f"Invalid photometric loss normalization: '{self.deca.config.photometric_normalization}'")
self._metric_or_loss(losses, metrics, self.deca.config.use_photometric)['photometric_texture'] = \
photometric * self.deca.config.photow
if self.deca.vgg_loss is not None:
vggl, _ = self.deca.vgg_loss(
masks[:geom_losses_idxs, ...] * images[:geom_losses_idxs, ...], # masked input image
masks[:geom_losses_idxs, ...] * predicted_images[:geom_losses_idxs, ...], # masked output image
)
self._metric_or_loss(losses, metrics, self.deca.config.use_vgg)['vgg'] = vggl * self.deca.config.vggw
if self.deca._has_neural_rendering():
predicted_translated_image = codedict["predicted_translated_image"]
photometric_translated = (masks[:geom_losses_idxs, ...] * (
predicted_translated_image[:geom_losses_idxs, ...] -
images[:geom_losses_idxs, ...]).abs()).mean() * self.deca.config.photow
if self.deca.config.use_photometric:
losses['photometric_translated_texture'] = photometric_translated
else:
metrics['photometric_translated_texture'] = photometric_translated
if self.deca.vgg_loss is not None:
vggl, _ = self.deca.vgg_loss(
masks[:geom_losses_idxs, ...] * images[:geom_losses_idxs, ...], # masked input image
masks[:geom_losses_idxs, ...] * predicted_translated_image[:geom_losses_idxs, ...],
# masked output image
)
self._metric_or_loss(losses, metrics, self.deca.config.use_vgg)['vgg_translated'] = vggl * self.deca.config.vggw
else:
raise ValueError("Is this line ever reached?")
losses = self._compute_id_loss(codedict, batch, training, testing, losses, batch_size=bs, ring_size=rs)
losses['shape_reg'] = (torch.sum(shapecode ** 2) / 2) * self.deca.config.shape_reg
losses['expression_reg'] = (torch.sum(expcode ** 2) / 2) * self.deca.config.exp_reg
losses['tex_reg'] = (torch.sum(texcode ** 2) / 2) * self.deca.config.tex_reg
losses['light_reg'] = ((torch.mean(lightcode, dim=2)[:, :,
None] - lightcode) ** 2).mean() * self.deca.config.light_reg
if 'original_code' in codedict.keys():
# original jaw pose regularization
if self.deca.config.get('exp_deca_jaw_pose', False) and \
'deca_jaw_reg' in self.deca.config.keys() and self.deca.config.deca_jaw_reg > 0:
jaw_pose_orig = codedict['original_code']['pose'][:, 3:]
jaw_pose = codedict['posecode'][..., 3:]
deca_jaw_pose_reg = (torch.sum((jaw_pose - jaw_pose_orig) ** 2) / 2) * self.deca.config.deca_jaw_reg
losses['deca_jaw_pose_reg'] = deca_jaw_pose_reg
if self.deca.config.get('exp_deca_global_pose', False) and \
'deca_global_reg' in self.deca.config.keys() and self.deca.config.deca_global_reg > 0:
global_pose_orig = codedict['original_code']['pose'][:, :3]
global_pose = codedict['posecode'][..., :3]
global_pose_reg = (torch.sum((global_pose - global_pose_orig) ** 2) / 2) * self.deca.config.deca_global_reg
losses['deca_global_pose_reg'] = global_pose_reg
# original expression regularization
if 'deca_expression_reg' in self.deca.config.keys() and self.deca.config.deca_expression_reg > 0:
expression_orig = codedict['original_code']['exp']
expression = codedict['expcode']
deca_expression_reg = (torch.sum((expression - expression_orig) ** 2) / 2) * self.deca.config.deca_expression_reg
losses['deca_expression_reg'] = deca_expression_reg
losses, metrics, codedict = self._compute_emonet_loss_wrapper(codedict, batch, training, testing, losses, metrics,
prefix="coarse", image_key="predicted_images",
with_grad=self.deca.config.use_emonet_loss and not self.deca._has_neural_rendering(),
batch_size=bs, ring_size=rs)
if self.deca._has_neural_rendering():
losses, metrics, codedict = self._compute_emonet_loss_wrapper(codedict, batch, training, testing, losses, metrics,
prefix="coarse_translated", image_key="predicted_translated_image",
with_grad=self.deca.config.use_emonet_loss and self.deca._has_neural_rendering(),
batch_size=bs, ring_size=rs
)
if self.au_loss is not None:
# with torch.no_grad():
self._compute_au_loss(images, predicted_images, losses, metrics, "coarse",
au=None,
with_grad=self.deca.config.au_loss.use_as_loss and not self.deca._has_neural_rendering())
if self.deca._has_neural_rendering():
self._compute_au_loss(images, predicted_translated_image, losses, metrics, "coarse",
au=None,
with_grad=self.deca.config.au_loss.use_as_loss and self.deca._has_neural_rendering())
if self.lipread_loss is not None:
# with torch.no_grad():
self._compute_lipread_loss(images, predicted_images, lmk, predicted_landmarks, losses, metrics, "coarse",
with_grad=self.deca.config.lipread_loss.use_as_loss and not self.deca._has_neural_rendering())
if self.deca._has_neural_rendering():
self._compute_lipread_loss(images, predicted_translated_image,
lmk, predicted_landmarks,
losses, metrics, "coarse",
with_grad=self.deca.config.lipread_loss.use_as_loss and self.deca._has_neural_rendering())
## DETAIL loss only
if self.mode == DecaMode.DETAIL:
predicted_detailed_image = codedict["predicted_detailed_image"]
uv_z = codedict["uv_z"] # UV displacement map
uv_shading = codedict["uv_shading"]
uv_vis_mask = codedict["uv_vis_mask"] # uv_mask of what is visible
photometric_detailed = (masks[:geom_losses_idxs, ...] * (
predicted_detailed_image[:geom_losses_idxs, ...] -
images[:geom_losses_idxs, ...]).abs()).mean() * self.deca.config.photow
if self.deca.config.use_detailed_photo:
losses['photometric_detailed_texture'] = photometric_detailed
else:
metrics['photometric_detailed_texture'] = photometric_detailed
if self.deca.vgg_loss is not None:
vggl, _ = self.deca.vgg_loss(
masks[:geom_losses_idxs, ...] * images[:geom_losses_idxs, ...], # masked input image
masks[:geom_losses_idxs, ...] * predicted_detailed_image[:geom_losses_idxs, ...],
# masked output image
)
self._metric_or_loss(losses, metrics, self.deca.config.use_vgg)['vgg_detailed'] = vggl * self.deca.config.vggw
if self.deca._has_neural_rendering():
predicted_detailed_translated_image = codedict["predicted_detailed_translated_image"]
photometric_detailed_translated = (masks[:geom_losses_idxs, ...] * (
predicted_detailed_translated_image[:geom_losses_idxs, ...] - images[:geom_losses_idxs,
...]).abs()).mean() * self.deca.config.photow
if self.deca.config.use_detailed_photo:
losses['photometric_translated_detailed_texture'] = photometric_detailed_translated
else:
metrics['photometric_translated_detailed_texture'] = photometric_detailed_translated
if self.deca.vgg_loss is not None:
vggl, _ = self.deca.vgg_loss(
masks[:geom_losses_idxs, ...] * images[:geom_losses_idxs, ...], # masked input image
masks[:geom_losses_idxs, ...] * predicted_detailed_translated_image[:geom_losses_idxs, ...],
# masked output image
)
self._metric_or_loss(losses, metrics, self.deca.config.use_vgg)[
'vgg_detailed_translated'] = vggl * self.deca.config.vggw
losses, metrics, codedict = self._compute_emonet_loss_wrapper(codedict, batch, training, testing, losses, metrics,
prefix="detail", image_key = "predicted_detailed_image",
with_grad=self.deca.config.use_emonet_loss and not self.deca._has_neural_rendering(),
batch_size=bs, ring_size=rs)
if self.deca._has_neural_rendering():
losses, metrics, codedict = self._compute_emonet_loss_wrapper(codedict, batch, training, testing, losses, metrics,
prefix="detail_translated",
image_key="predicted_detailed_translated_image",
with_grad=self.deca.config.use_emonet_loss and self.deca._has_neural_rendering(),
batch_size=bs, ring_size=rs)
# if self.emonet_loss is not None:
# self._compute_emotion_loss(images, predicted_detailed_image, losses, metrics, "detail",
# with_grad=self.deca.config.use_emonet_loss and not self.deca._has_neural_rendering(),
# batch_size=bs, ring_size=rs)
# codedict["detail_valence_input"] = self.emonet_loss.input_emotion['valence']
# codedict["detail_arousal_input"] = self.emonet_loss.input_emotion['arousal']
# codedict["detail_expression_input"] = self.emonet_loss.input_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification']
# codedict["detail_valence_output"] = self.emonet_loss.output_emotion['valence']
# codedict["detail_arousal_output"] = self.emonet_loss.output_emotion['arousal']
# codedict["detail_expression_output"] = self.emonet_loss.output_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification']
#
# if va is not None:
# codedict["detail_valence_gt"] = va[:,0]
# codedict["detail_arousal_gt"] = va[:,1]
# if expr7 is not None:
# codedict["detail_expression_gt"] = expr7
# if self.deca._has_neural_rendering():
# #TODO possible to make this more GPU efficient by not recomputing emotion for input image
# self._compute_emotion_loss(images, predicted_detailed_translated_image,
# losses, metrics, "detail_translated",
# va, expr7,
# with_grad= self.deca.config.use_emonet_loss and self.deca._has_neural_rendering(),
# batch_size=bs, ring_size=rs)
#
# # codedict["coarse_valence_input"] = self.emonet_loss.input_emotion['valence']
# # codedict["coarse_arousal_input"] = self.emonet_loss.input_emotion['arousal']
# # codedict["coarse_expression_input"] = self.emonet_loss.input_emotion['expression']
# codedict["detail_translated_valence_output"] = self.emonet_loss.output_emotion['valence']
# codedict["detail_translated_arousal_output"] = self.emonet_loss.output_emotion['arousal']
# codedict["detail_translated_expression_output"] = self.emonet_loss.output_emotion['expression' if 'expression' in self.emonet_loss.input_emotion.keys() else 'expr_classification']
if self.au_loss is not None:
self._compute_au_loss(images, predicted_images, losses, metrics, "detail",
au=None,
with_grad=self.deca.config.au_loss.use_as_loss and not self.deca._has_neural_rendering())
if self.deca._has_neural_rendering():
self._compute_au_loss(images, predicted_detailed_translated_image, losses, metrics, "detail",
au=None,
with_grad=self.deca.config.au_loss.use_as_loss and self.deca._has_neural_rendering())
for pi in range(3): # self.deca.face_attr_mask.shape[0]):
if self.deca.config.sfsw[pi] != 0:
# if pi==0:
new_size = 256
# else:
# new_size = 128
# if self.deca.config.uv_size != 256:
# new_size = 128
uv_texture_patch = F.interpolate(
uv_texture[:geom_losses_idxs, :, self.deca.face_attr_mask[pi][2]:self.deca.face_attr_mask[pi][3],
self.deca.face_attr_mask[pi][0]:self.deca.face_attr_mask[pi][1]],
[new_size, new_size], mode='bilinear')
uv_texture_gt_patch = F.interpolate(
uv_texture_gt[:geom_losses_idxs, :, self.deca.face_attr_mask[pi][2]:self.deca.face_attr_mask[pi][3],
self.deca.face_attr_mask[pi][0]:self.deca.face_attr_mask[pi][1]], [new_size, new_size],
mode='bilinear')
uv_vis_mask_patch = F.interpolate(
uv_vis_mask[:geom_losses_idxs, :, self.deca.face_attr_mask[pi][2]:self.deca.face_attr_mask[pi][3],
self.deca.face_attr_mask[pi][0]:self.deca.face_attr_mask[pi][1]],
[new_size, new_size], mode='bilinear')
detail_l1 = (uv_texture_patch * uv_vis_mask_patch - uv_texture_gt_patch * uv_vis_mask_patch).abs().mean() * \
self.deca.config.sfsw[pi]
if self.deca.config.use_detail_l1 and not self.deca._has_neural_rendering():
losses['detail_l1_{}'.format(pi)] = detail_l1
else:
metrics['detail_l1_{}'.format(pi)] = detail_l1
if self.deca.config.use_detail_mrf and not self.deca._has_neural_rendering():
mrf = self.deca.perceptual_loss(uv_texture_patch * uv_vis_mask_patch,
uv_texture_gt_patch * uv_vis_mask_patch) * \
self.deca.config.sfsw[pi] * self.deca.config.mrfwr
losses['detail_mrf_{}'.format(pi)] = mrf
else:
with torch.no_grad():
mrf = self.deca.perceptual_loss(uv_texture_patch * uv_vis_mask_patch,
uv_texture_gt_patch * uv_vis_mask_patch) * \
self.deca.config.sfsw[pi] * self.deca.config.mrfwr
metrics['detail_mrf_{}'.format(pi)] = mrf
if self.deca._has_neural_rendering():
# raise NotImplementedError("Gotta implement the texture extraction first.")
translated_uv_texture = codedict["translated_uv_texture"]
translated_uv_texture_patch = F.interpolate(
translated_uv_texture[:geom_losses_idxs, :,
self.deca.face_attr_mask[pi][2]:self.deca.face_attr_mask[pi][3],
self.deca.face_attr_mask[pi][0]:self.deca.face_attr_mask[pi][1]],
[new_size, new_size], mode='bilinear')
translated_detail_l1 = (translated_uv_texture_patch * uv_vis_mask_patch
- uv_texture_gt_patch * uv_vis_mask_patch).abs().mean() * \
self.deca.config.sfsw[pi]
if self.deca.config.use_detail_l1:
losses['detail_translated_l1_{}'.format(pi)] = translated_detail_l1
else:
metrics['detail_translated_l1_{}'.format(pi)] = translated_detail_l1
if self.deca.config.use_detail_mrf:
translated_mrf = self.deca.perceptual_loss(translated_uv_texture_patch * uv_vis_mask_patch,
uv_texture_gt_patch * uv_vis_mask_patch) * \
self.deca.config.sfsw[pi] * self.deca.config.mrfwr
losses['detail_translated_mrf_{}'.format(pi)] = translated_mrf
else:
with torch.no_grad():
mrf = self.deca.perceptual_loss(translated_uv_texture_patch * uv_vis_mask_patch,
uv_texture_gt_patch * uv_vis_mask_patch) * \
self.deca.config.sfsw[pi] * self.deca.config.mrfwr
metrics['detail_translated_mrf_{}'.format(pi)] = mrf
# Old piece of debug code. Good to delete.
# if pi == 2:
# uv_texture_gt_patch_ = uv_texture_gt_patch
# uv_texture_patch_ = uv_texture_patch
# uv_vis_mask_patch_ = uv_vis_mask_patch
losses['z_reg'] = torch.mean(uv_z.abs()) * self.deca.config.zregw
losses['z_diff'] = lossfunc.shading_smooth_loss(uv_shading) * self.deca.config.zdiffw
nonvis_mask = (1 - util.binary_erosion(uv_vis_mask))
losses['z_sym'] = (nonvis_mask * (uv_z - torch.flip(uv_z, [-1]).detach()).abs()).sum() * self.deca.config.zsymw
if self.emotion_mlp is not None:# and not testing:
mlp_losses, mlp_metrics = self.emotion_mlp.compute_loss(
codedict, batch, training=training, pred_prefix="emo_mlp_")
for key in mlp_losses.keys():
if key in losses.keys():
raise RuntimeError(f"Duplicate loss label {key}")
losses[key] = self.deca.config.mlp_emotion_predictor_weight * mlp_losses[key]
for key in mlp_metrics.keys():
if key in metrics.keys():
raise RuntimeError(f"Duplicate metric label {key}")
# let's report the metrics (which are a superset of losses when it comes to EmoMLP) without the weight,
# it's hard to plot the metrics otherwise
metrics[key] = mlp_metrics[key]
# metrics[key] = self.deca.config.mlp_emotion_predictor_weight * mlp_metrics[key]
# else:
# uv_texture_gt_patch_ = None
# uv_texture_patch_ = None
# uv_vis_mask_patch_ = None
return losses, metrics
def compute_loss(self, values, batch, training=True, testing=False) -> dict:
"""
The function used to compute the loss on a training batch.
:
training should be set to true when calling from training_step only
"""
losses, metrics = self._compute_loss(values, batch, training=training, testing=testing)
all_loss = 0.
losses_key = losses.keys()
for key in losses_key:
all_loss = all_loss + losses[key]
# losses['all_loss'] = all_loss
losses = {'loss_' + key: value for key, value in losses.items()} # add prefix loss for better logging
losses['loss'] = all_loss
# add metrics that do not effect the loss function (if any)
for key in metrics.keys():
losses['metric_' + key] = metrics[key]
return losses
def _val_to_be_logged(self, d):
if not hasattr(self, 'val_dict_list'):
self.val_dict_list = []
self.val_dict_list += [d]
def _train_to_be_logged(self, d):
if not hasattr(self, 'train_dict_list'):
self.train_dict_list = []
self.train_dict_list += [d]
def validation_step(self, batch, batch_idx, dataloader_idx=None):
"""
Training step override of pytorch lightning module. It makes the encoding, decoding passes, computes the loss and logs the losses/visualizations.
:param batch: Batch of images to encode. batch['image'] [batch_size, ring_size, 3, image_size, image_size].
For a training forward pass, additional corresponding data are necessery such as 'landmarks' and 'masks'.
:batch_idx batch index
"""
with torch.no_grad():
training = False
values = self.encode(batch, training=training)
values = self.decode(values, training=training)
losses_and_metrics = self.compute_loss(values, batch, training=training)
#### self.log_dict(losses_and_metrics, on_step=False, on_epoch=True)
# prefix = str(self.mode.name).lower()
prefix = self._get_logging_prefix()
# if dataloader_idx is not None:
# dataloader_str = str(dataloader_idx) + "_"
# else:
dataloader_str = ''
stage_str = dataloader_str + 'val_'
# losses_and_metrics_to_log = {prefix + dataloader_str +'_val_' + key: value.detach().cpu() for key, value in losses_and_metrics.items()}
# losses_and_metrics_to_log = {prefix + '_' + stage_str + key: value.detach() for key, value in losses_and_metrics.items()}
losses_and_metrics_to_log = {prefix + '_' + stage_str + key: value.detach().cpu().item() for key, value in losses_and_metrics.items()}
losses_and_metrics_to_log[prefix + '_' + stage_str + 'epoch'] = self.current_epoch
# losses_and_metrics_to_log[prefix + '_' + stage_str + 'epoch'] = torch.tensor(self.current_epoch, device=self.device)
# log val_loss also without any prefix for a model checkpoint to track it
losses_and_metrics_to_log[stage_str + 'loss'] = losses_and_metrics_to_log[prefix + '_' + stage_str + 'loss']
losses_and_metrics_to_log[prefix + '_' + stage_str + 'step'] = self.global_step
losses_and_metrics_to_log[prefix + '_' + stage_str + 'batch_idx'] = batch_idx
losses_and_metrics_to_log[stage_str + 'step'] = self.global_step
losses_and_metrics_to_log[stage_str + 'batch_idx'] = batch_idx
losses_and_metrics_to_log[prefix + '_' + stage_str + 'mem_usage'] = self.process.memory_info().rss
losses_and_metrics_to_log[stage_str + 'mem_usage'] = self.process.memory_info().rss
# self._val_to_be_logged(losses_and_metrics_to_log)
if self.logger is not None:
self.log_dict(losses_and_metrics_to_log, on_step=False, on_epoch=True, sync_dist=True) # log per epoch # recommended
if self.trainer.is_global_zero:
if self.deca.config.val_vis_frequency > 0:
if batch_idx % self.deca.config.val_vis_frequency == 0:
uv_detail_normals = None
if 'uv_detail_normals' in values.keys():
uv_detail_normals = values['uv_detail_normals']
visualizations, grid_image = self._visualization_checkpoint(values['verts'], values['trans_verts'], values['ops'],
uv_detail_normals, values, batch_idx, stage_str[:-1], prefix)
vis_dict = self._create_visualizations_to_log(stage_str[:-1], visualizations, values, batch_idx, indices=0, dataloader_idx=dataloader_idx)
# image = Image(grid_image, caption="full visualization")
# vis_dict[prefix + '_val_' + "visualization"] = image
if isinstance(self.logger, WandbLogger):
self.logger.log_metrics(vis_dict)
return None
def _get_logging_prefix(self):
prefix = self.stage_name + str(self.mode.name).lower()
return prefix
def test_step(self, batch, batch_idx, dataloader_idx=None):
"""
Testing step override of pytorch lightning module. It makes the encoding, decoding passes, computes the loss and logs the losses/visualizations
without gradient
:param batch: Batch of images to encode. batch['image'] [batch_size, ring_size, 3, image_size, image_size].
For a training forward pass, additional corresponding data are necessery such as 'landmarks' and 'masks'.
:batch_idx batch index
"""
prefix = self._get_logging_prefix()
losses_and_metrics_to_log = {}
# if dataloader_idx is not None:
# dataloader_str = str(dataloader_idx) + "_"
# else:
dataloader_str = ''
stage_str = dataloader_str + 'test_'
with torch.no_grad():
training = False
testing = True
values = self.encode(batch, training=training)
values = self.decode(values, training=training)
if 'mask' in batch.keys():
losses_and_metrics = self.compute_loss(values, batch, training=False, testing=testing)
# losses_and_metrics_to_log = {prefix + '_' + stage_str + key: value.detach().cpu() for key, value in losses_and_metrics.items()}
losses_and_metrics_to_log = {prefix + '_' + stage_str + key: value.detach().cpu().item() for key, value in losses_and_metrics.items()}
else:
losses_and_metric = None
# losses_and_metrics_to_log[prefix + '_' + stage_str + 'epoch'] = self.current_epoch
# losses_and_metrics_to_log[prefix + '_' + stage_str + 'epoch'] = torch.tensor(self.current_epoch, device=self.device)
# losses_and_metrics_to_log[prefix + '_' + stage_str + 'step'] = torch.tensor(self.global_step, device=self.device)
# losses_and_metrics_to_log[prefix + '_' + stage_str + 'batch_idx'] = torch.tensor(batch_idx, device=self.device)
# losses_and_metrics_to_log[stage_str + 'epoch'] = torch.tensor(self.current_epoch, device=self.device)
# losses_and_metrics_to_log[stage_str + 'step'] = torch.tensor(self.global_step, device=self.device)
# losses_and_metrics_to_log[stage_str + 'batch_idx'] = torch.tensor(batch_idx, device=self.device)
losses_and_metrics_to_log[prefix + '_' + stage_str + 'epoch'] = self.current_epoch
losses_and_metrics_to_log[prefix + '_' + stage_str + 'step'] = self.global_step
losses_and_metrics_to_log[prefix + '_' + stage_str + 'batch_idx'] = batch_idx
losses_and_metrics_to_log[prefix + '_' + stage_str + 'mem_usage'] = self.process.memory_info().rss
losses_and_metrics_to_log[stage_str + 'epoch'] = self.current_epoch
losses_and_metrics_to_log[stage_str + 'step'] = self.global_step
losses_and_metrics_to_log[stage_str + 'batch_idx'] = batch_idx
losses_and_metrics_to_log[stage_str + 'mem_usage'] = self.process.memory_info().rss
if self.logger is not None:
# self.logger.log_metrics(losses_and_metrics_to_log)
self.log_dict(losses_and_metrics_to_log, sync_dist=True, on_step=False, on_epoch=True)
# if self.global_step % 200 == 0:
uv_detail_normals = None
if 'uv_detail_normals' in values.keys():
uv_detail_normals = values['uv_detail_normals']
if self.deca.config.test_vis_frequency > 0:
# Log visualizations every once in a while
if batch_idx % self.deca.config.test_vis_frequency == 0:
# if self.trainer.is_global_zero:
visualizations, grid_image = self._visualization_checkpoint(values['verts'], values['trans_verts'], values['ops'],
uv_detail_normals, values, self.global_step, stage_str[:-1], prefix)
visdict = self._create_visualizations_to_log(stage_str[:-1], visualizations, values, batch_idx, indices=0, dataloader_idx=dataloader_idx)
self.logger.log_metrics(visdict)
return None
@property
def process(self):
if not hasattr(self,"process_"):
self.process_ = psutil.Process(os.getpid())
return self.process_
def training_step(self, batch, batch_idx, *args, **kwargs): #, debug=True):
"""
Training step override of pytorch lightning module. It makes the encoding, decoding passes, computes the loss and logs the losses/visualizations.
:param batch: Batch of images to encode. batch['image'] [batch_size, ring_size, 3, image_size, image_size].
For a training forward pass, additional corresponding data are necessery such as 'landmarks' and 'masks'.
:batch_idx batch index
"""
values = self.encode(batch, training=True)
values = self.decode(values, training=True)
losses_and_metrics = self.compute_loss(values, batch, training=True)
uv_detail_normals = None
if 'uv_detail_normals' in values.keys():
uv_detail_normals = values['uv_detail_normals']
# prefix = str(self.mode.name).lower()
prefix = self._get_logging_prefix()
# losses_and_metrics_to_log = {prefix + '_train_' + key: value.detach().cpu() for key, value in losses_and_metrics.items()}
# losses_and_metrics_to_log = {prefix + '_train_' + key: value.detach() for key, value in losses_and_metrics.items()}
losses_and_metrics_to_log = {prefix + '_train_' + key: value.detach().cpu().item() for key, value in losses_and_metrics.items()}
# losses_and_metrics_to_log[prefix + '_train_' + 'epoch'] = torch.tensor(self.current_epoch, device=self.device)
losses_and_metrics_to_log[prefix + '_train_' + 'epoch'] = self.current_epoch
losses_and_metrics_to_log[prefix + '_train_' + 'step'] = self.global_step
losses_and_metrics_to_log[prefix + '_train_' + 'batch_idx'] = batch_idx
losses_and_metrics_to_log[prefix + '_' + "train_" + 'mem_usage'] = self.process.memory_info().rss
# losses_and_metrics_to_log['train_' + 'epoch'] = torch.tensor(self.current_epoch, device=self.device)
losses_and_metrics_to_log['train_' + 'epoch'] = self.current_epoch
losses_and_metrics_to_log['train_' + 'step'] = self.global_step
losses_and_metrics_to_log['train_' + 'batch_idx'] = batch_idx
losses_and_metrics_to_log["train_" + 'mem_usage'] = self.process.memory_info().rss
# log loss also without any prefix for a model checkpoint to track it
losses_and_metrics_to_log['loss'] = losses_and_metrics_to_log[prefix + '_train_loss']
if self.logger is not None:
self.log_dict(losses_and_metrics_to_log, on_step=False, on_epoch=True, sync_dist=True) # log per epoch, # recommended
if self.deca.config.train_vis_frequency > 0:
if self.global_step % self.deca.config.train_vis_frequency == 0:
if self.trainer.is_global_zero:
visualizations, grid_image = self._visualization_checkpoint(values['verts'], values['trans_verts'], values['ops'],
uv_detail_normals, values, batch_idx, "train", prefix)
visdict = self._create_visualizations_to_log('train', visualizations, values, batch_idx, indices=0)
if isinstance(self.logger, WandbLogger):
self.logger.log_metrics(visdict)#, step=self.global_step)
# self.log_dict(visdict, sync_dist=True)
# self.log_dict(losses_and_metrics_to_log, on_step=True, on_epoch=False) # log per step
# self.log_dict(losses_and_metrics_to_log, on_step=True, on_epoch=True) # log per both
# return losses_and_metrics
return losses_and_metrics['loss']
### STEP ENDS ARE PROBABLY NOT NECESSARY BUT KEEP AN EYE ON THEM IF MULI-GPU TRAINING DOESN'T WORK
# def training_step_end(self, batch_parts):
# return self._step_end(batch_parts)
#
# def validation_step_end(self, batch_parts):
# return self._step_end(batch_parts)
#
# def _step_end(self, batch_parts):
# # gpu_0_prediction = batch_parts.pred[0]['pred']
# # gpu_1_prediction = batch_parts.pred[1]['pred']
# N = len(batch_parts)
# loss_dict = {}
# for key in batch_parts[0]:
# for i in range(N):
# if key not in loss_dict.keys():
# loss_dict[key] = batch_parts[i]
# else:
# loss_dict[key] = batch_parts[i]
# loss_dict[key] = loss_dict[key] / N
# return loss_dict
def vae_2_str(self, valence=None, arousal=None, affnet_expr=None, expr7=None, prefix=""):
caption = ""
if len(prefix) > 0:
prefix += "_"
if valence is not None and not np.isnan(valence).any():
caption += prefix + "valence= %.03f\n" % valence
if arousal is not None and not np.isnan(arousal).any():
caption += prefix + "arousal= %.03f\n" % arousal
if affnet_expr is not None and not np.isnan(affnet_expr).any():
caption += prefix + "expression= %s \n" % AffectNetExpressions(affnet_expr).name
if expr7 is not None and not np.isnan(expr7).any():
caption += prefix +"expression= %s \n" % Expression7(expr7).name
return caption
def _create_visualizations_to_log(self, stage, visdict, values, step, indices=None,
dataloader_idx=None, output_dir=None):
mode_ = str(self.mode.name).lower()
prefix = self._get_logging_prefix()
output_dir = output_dir or self.inout_params.full_run_dir
log_dict = {}
for key in visdict.keys():
images = _torch_image2np(visdict[key])
if images.dtype == np.float32 or images.dtype == np.float64 or images.dtype == np.float16:
images = np.clip(images, 0, 1)
if indices is None:
indices = np.arange(images.shape[0])
if isinstance(indices, int):
indices = [indices,]
if isinstance(indices, str) and indices == 'all':
image = np.concatenate([images[i] for i in range(images.shape[0])], axis=1)
savepath = Path(f'{output_dir}/{prefix}_{stage}/{key}/{self.current_epoch:04d}_{step:04d}_all.png')
# im2log = Image(image, caption=key)
if isinstance(self.logger, WandbLogger):
im2log = _log_wandb_image(savepath, image)
else:
im2log = _log_array_image(savepath, image)
name = prefix + "_" + stage + "_" + key
if dataloader_idx is not None:
name += "/dataloader_idx_" + str(dataloader_idx)
log_dict[name] = im2log
else:
for i in indices:
caption = key + f" batch_index={step}\n"
caption += key + f" index_in_batch={i}\n"
if self.emonet_loss is not None:
if key == 'inputs':
if mode_ + "_valence_input" in values.keys():
caption += self.vae_2_str(
values[mode_ + "_valence_input"][i].detach().cpu().item(),
values[mode_ + "_arousal_input"][i].detach().cpu().item(),
np.argmax(values[mode_ + "_expression_input"][i].detach().cpu().numpy()),
prefix="emonet") + "\n"
if 'va' in values.keys() and mode_ + "valence_gt" in values.keys():
# caption += self.vae_2_str(
# values[mode_ + "_valence_gt"][i].detach().cpu().item(),
# values[mode_ + "_arousal_gt"][i].detach().cpu().item(),
caption += self.vae_2_str(
values[mode_ + "valence_gt"][i].detach().cpu().item(),
values[mode_ + "arousal_gt"][i].detach().cpu().item(),
prefix="gt") + "\n"
if 'expr7' in values.keys() and mode_ + "_expression_gt" in values.keys():
caption += "\n" + self.vae_2_str(
expr7=values[mode_ + "_expression_gt"][i].detach().cpu().numpy(),
prefix="gt") + "\n"
if 'affectnetexp' in values.keys() and mode_ + "_expression_gt" in values.keys():
caption += "\n" + self.vae_2_str(
affnet_expr=values[mode_ + "_expression_gt"][i].detach().cpu().numpy(),
prefix="gt") + "\n"
elif 'geometry_detail' in key:
if "emo_mlp_valence" in values.keys():
caption += self.vae_2_str(
values["emo_mlp_valence"][i].detach().cpu().item(),
values["emo_mlp_arousal"][i].detach().cpu().item(),
prefix="mlp")
if 'emo_mlp_expr_classification' in values.keys():
caption += "\n" + self.vae_2_str(
affnet_expr=values["emo_mlp_expr_classification"][i].detach().cpu().argmax().numpy(),
prefix="mlp") + "\n"
elif key == 'output_images_' + mode_:
if mode_ + "_valence_output" in values.keys():
caption += self.vae_2_str(values[mode_ + "_valence_output"][i].detach().cpu().item(),
values[mode_ + "_arousal_output"][i].detach().cpu().item(),
np.argmax(values[mode_ + "_expression_output"][i].detach().cpu().numpy())) + "\n"
elif key == 'output_translated_images_' + mode_:
if mode_ + "_translated_valence_output" in values.keys():
caption += self.vae_2_str(values[mode_ + "_translated_valence_output"][i].detach().cpu().item(),
values[mode_ + "_translated_arousal_output"][i].detach().cpu().item(),
np.argmax(values[mode_ + "_translated_expression_output"][i].detach().cpu().numpy())) + "\n"
# elif key == 'output_images_detail':
# caption += "\n" + self.vae_2_str(values["detail_output_valence"][i].detach().cpu().item(),
# values["detail_output_valence"][i].detach().cpu().item(),
# np.argmax(values["detail_output_expression"][
# i].detach().cpu().numpy()))
savepath = Path(f'{output_dir}/{prefix}_{stage}/{key}/{self.current_epoch:04d}_{step:04d}_{i:02d}.png')
image = images[i]
# im2log = Image(image, caption=caption)
if isinstance(self.logger, WandbLogger):
im2log = _log_wandb_image(savepath, image, caption)
elif self.logger is not None:
im2log = _log_array_image(savepath, image, caption)
else:
im2log = _log_array_image(None, image, caption)
name = prefix + "_" + stage + "_" + key
if dataloader_idx is not None:
name += "/dataloader_idx_" + str(dataloader_idx)
log_dict[name] = im2log
return log_dict
def _visualization_checkpoint(self, verts, trans_verts, ops, uv_detail_normals, additional, batch_idx, stage, prefix,
save=False):
batch_size = verts.shape[0]
visind = np.arange(batch_size)
shape_images = self.deca.render.render_shape(verts, trans_verts)
if uv_detail_normals is not None:
detail_normal_images = F.grid_sample(uv_detail_normals.detach(), ops['grid'].detach(),
align_corners=False)
shape_detail_images = self.deca.render.render_shape(verts, trans_verts,
detail_normal_images=detail_normal_images)
else:
shape_detail_images = None
visdict = {}
if 'images' in additional.keys():
visdict['inputs'] = additional['images'][visind]
if 'images' in additional.keys() and 'lmk' in additional.keys():
visdict['landmarks_gt'] = util.tensor_vis_landmarks(additional['images'][visind], additional['lmk'][visind])
if 'images' in additional.keys() and 'predicted_landmarks' in additional.keys():
visdict['landmarks_predicted'] = util.tensor_vis_landmarks(additional['images'][visind],
additional['predicted_landmarks'][visind])
if 'predicted_images' in additional.keys():
visdict['output_images_coarse'] = additional['predicted_images'][visind]
if 'predicted_translated_image' in additional.keys() and additional['predicted_translated_image'] is not None:
visdict['output_translated_images_coarse'] = additional['predicted_translated_image'][visind]
visdict['geometry_coarse'] = shape_images[visind]
if shape_detail_images is not None:
visdict['geometry_detail'] = shape_detail_images[visind]
if 'albedo_images' in additional.keys():
visdict['albedo_images'] = additional['albedo_images'][visind]
if 'masks' in additional.keys():
visdict['mask'] = additional['masks'].repeat(1, 3, 1, 1)[visind]
if 'albedo' in additional.keys():
visdict['albedo'] = additional['albedo'][visind]
if 'predicted_detailed_image' in additional.keys() and additional['predicted_detailed_image'] is not None:
visdict['output_images_detail'] = additional['predicted_detailed_image'][visind]
if 'predicted_detailed_translated_image' in additional.keys() and additional['predicted_detailed_translated_image'] is not None:
visdict['output_translated_images_detail'] = additional['predicted_detailed_translated_image'][visind]
if 'shape_detail_images' in additional.keys():
visdict['shape_detail_images'] = additional['shape_detail_images'][visind]
if 'uv_detail_normals' in additional.keys():
visdict['uv_detail_normals'] = additional['uv_detail_normals'][visind] * 0.5 + 0.5
if 'uv_texture_patch' in additional.keys():
visdict['uv_texture_patch'] = additional['uv_texture_patch'][visind]
if 'uv_texture_gt' in additional.keys():
visdict['uv_texture_gt'] = additional['uv_texture_gt'][visind]
if 'translated_uv_texture' in additional.keys() and additional['translated_uv_texture'] is not None:
visdict['translated_uv_texture'] = additional['translated_uv_texture'][visind]
if 'uv_vis_mask_patch' in additional.keys():
visdict['uv_vis_mask_patch'] = additional['uv_vis_mask_patch'][visind]
if save:
savepath = f'{self.inout_params.full_run_dir}/{prefix}_{stage}/combined/{self.current_epoch:04d}_{batch_idx:04d}.png'
Path(savepath).parent.mkdir(exist_ok=True, parents=True)
visualization_image = self.deca.visualize(visdict, savepath)
return visdict, visualization_image[..., [2, 1, 0]]
else:
visualization_image = None
return visdict, None
def _get_trainable_parameters(self):
trainable_params = []
if self.mode == DecaMode.COARSE:
trainable_params += self.deca._get_coarse_trainable_parameters()
elif self.mode == DecaMode.DETAIL:
trainable_params += self.deca._get_detail_trainable_parameters()
else:
raise ValueError(f"Invalid deca mode: {self.mode}")
if self.emotion_mlp is not None:
trainable_params += list(self.emotion_mlp.parameters())
if self.emonet_loss is not None:
trainable_params += self.emonet_loss._get_trainable_params()
if self.deca.id_loss is not None:
trainable_params += self.deca.id_loss._get_trainable_params()
return trainable_params
def configure_optimizers(self):
# optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)
print("Configuring optimizer")
trainable_params = self._get_trainable_parameters()
if self.learning_params.optimizer == 'Adam':
self.deca.opt = torch.optim.Adam(
trainable_params,
lr=self.learning_params.learning_rate,
amsgrad=False)
elif self.config.learning.optimizer == 'AdaBound':
self.deca.opt = adabound.AdaBound(
trainable_params,
lr=self.config.learning.learning_rate,
final_lr=self.config.learning.final_learning_rate
)
elif self.learning_params.optimizer == 'SGD':
self.deca.opt = torch.optim.SGD(
trainable_params,
lr=self.learning_params.learning_rate)
else:
raise ValueError(f"Unsupported optimizer: '{self.learning_params.optimizer}'")
optimizers = [self.deca.opt]
schedulers = []
if 'learning_rate_decay' in self.learning_params.keys():
scheduler = torch.optim.lr_scheduler.ExponentialLR(self.deca.opt, gamma=self.learning_params.learning_rate_decay)
schedulers += [scheduler]
if len(schedulers) == 0:
return self.deca.opt
return optimizers, schedulers
class DECA(torch.nn.Module):
"""
The original DECA class which contains the encoders, FLAME decoder and the detail decoder.
"""
def __init__(self, config):
"""
:config corresponds to a model_params from DecaModule
"""
super().__init__()
# ID-MRF perceptual loss (kept here from the original DECA implementation)
self.perceptual_loss = None
# Face Recognition loss
self.id_loss = None
# VGG feature loss
self.vgg_loss = None
self._reconfigure(config)
self._reinitialize()
def _dirty_init(self):
pass # not used here, implemented for EMICA
def get_input_image_size(self):
return (self.config.image_size, self.config.image_size)
def _reconfigure(self, config):
self.config = config
self.n_param = config.n_shape + config.n_tex + config.n_exp + config.n_pose + config.n_cam + config.n_light
# identity-based detail code
self.n_detail = config.n_detail
# emotion-based detail code (deprecated, not use by DECA or EMOCA)
self.n_detail_emo = config.n_detail_emo if 'n_detail_emo' in config.keys() else 0
# count the size of the conidition vector
if 'detail_conditioning' in self.config.keys():
self.n_cond = 0
if 'globalpose' in self.config.detail_conditioning:
self.n_cond += 3
if 'jawpose' in self.config.detail_conditioning:
self.n_cond += 3
if 'identity' in self.config.detail_conditioning:
self.n_cond += config.n_shape
if 'expression' in self.config.detail_conditioning:
self.n_cond += config.n_exp
else:
self.n_cond = 3 + config.n_exp
self.mode = DecaMode[str(config.mode).upper()]
self._create_detail_generator()
self._init_deep_losses()
self._setup_neural_rendering()
def _reinitialize(self):
self._create_model()
self._setup_renderer()
self._init_deep_losses()
self.face_attr_mask = util.load_local_mask(image_size=self.config.uv_size, mode='bbx')
def _get_num_shape_params(self):
return self.config.n_shape
def _init_deep_losses(self):
"""
Initialize networks for deep losses
"""
# TODO: ideally these networks should be moved out the DECA class and into DecaModule,
# but that would break backwards compatility with the original DECA and would not be able to load DECA's weights
if 'mrfwr' not in self.config.keys() or self.config.mrfwr == 0:
self.perceptual_loss = None
else:
if self.perceptual_loss is None:
self.perceptual_loss = lossfunc.IDMRFLoss().eval()
self.perceptual_loss.requires_grad_(False) # TODO, move this to the constructor
if 'idw' not in self.config.keys() or self.config.idw == 0:
self.id_loss = None
else:
if self.id_loss is None:
id_metric = self.config.id_metric if 'id_metric' in self.config.keys() else None
id_trainable = self.config.id_trainable if 'id_trainable' in self.config.keys() else False
self.id_loss_start_step = self.config.id_loss_start_step if 'id_loss_start_step' in self.config.keys() else 0
self.id_loss = lossfunc.VGGFace2Loss(self.config.pretrained_vgg_face_path, id_metric, id_trainable)
self.id_loss.freeze_nontrainable_layers()
if 'vggw' not in self.config.keys() or self.config.vggw == 0:
self.vgg_loss = None
else:
if self.vgg_loss is None:
vgg_loss_batch_norm = 'vgg_loss_batch_norm' in self.config.keys() and self.config.vgg_loss_batch_norm
self.vgg_loss = VGG19Loss(dict(zip(self.config.vgg_loss_layers, self.config.lambda_vgg_layers)), batch_norm=vgg_loss_batch_norm).eval()
self.vgg_loss.requires_grad_(False) # TODO, move this to the constructor
def _setup_renderer(self):
self.render = SRenderY(self.config.image_size, obj_filename=self.config.topology_path,
uv_size=self.config.uv_size) # .to(self.device)
# face mask for rendering details
mask = imread(self.config.face_mask_path).astype(np.float32) / 255.
mask = torch.from_numpy(mask[:, :, 0])[None, None, :, :].contiguous()
self.uv_face_mask = F.interpolate(mask, [self.config.uv_size, self.config.uv_size])
mask = imread(self.config.face_eye_mask_path).astype(np.float32) / 255.
mask = torch.from_numpy(mask[:, :, 0])[None, None, :, :].contiguous()
uv_face_eye_mask = F.interpolate(mask, [self.config.uv_size, self.config.uv_size])
self.register_buffer('uv_face_eye_mask', uv_face_eye_mask)
# displacement mask is deprecated and not used by DECA or EMOCA
if 'displacement_mask' in self.config.keys():
displacement_mask_ = 1-np.load(self.config.displacement_mask).astype(np.float32)
# displacement_mask_ = np.load(self.config.displacement_mask).astype(np.float32)
displacement_mask_ = torch.from_numpy(displacement_mask_)[None, None, ...].contiguous()
displacement_mask_ = F.interpolate(displacement_mask_, [self.config.uv_size, self.config.uv_size])
self.register_buffer('displacement_mask', displacement_mask_)
## displacement correct
if os.path.isfile(self.config.fixed_displacement_path):
fixed_dis = np.load(self.config.fixed_displacement_path)
fixed_uv_dis = torch.tensor(fixed_dis).float()
else:
fixed_uv_dis = torch.zeros([512, 512]).float()
print("Warning: fixed_displacement_path not found, using zero displacement")
self.register_buffer('fixed_uv_dis', fixed_uv_dis)
def uses_texture(self):
if 'use_texture' in self.config.keys():
return self.config.use_texture
return True # true by default
def _disable_texture(self, remove_from_model=False):
self.config.use_texture = False
if remove_from_model:
self.flametex = None
def _enable_texture(self):
self.config.use_texture = True
def _has_neural_rendering(self):
return hasattr(self.config, "neural_renderer") and bool(self.config.neural_renderer)
def _setup_neural_rendering(self):
if self._has_neural_rendering():
if self.config.neural_renderer.class_ == "StarGAN":
print("Creating StarGAN neural renderer")
self.image_translator = StarGANWrapper(self.config.neural_renderer.cfg, self.config.neural_renderer.stargan_repo)
else:
raise ValueError(f"Unsupported neural renderer class '{self.config.neural_renderer.class_}'")
if self.image_translator.background_mode == "input":
if self.config.background_from_input not in [True, "input"]:
raise NotImplementedError("The background mode of the neural renderer and deca is not synchronized. "
"Background should be inpainted from the input")
elif self.image_translator.background_mode == "black":
if self.config.background_from_input not in [False, "black"]:
raise NotImplementedError("The background mode of the neural renderer and deca is not synchronized. "
"Background should be black.")
elif self.image_translator.background_mode == "none":
if self.config.background_from_input not in ["none"]:
raise NotImplementedError("The background mode of the neural renderer and deca is not synchronized. "
"The background should not be handled")
else:
raise NotImplementedError(f"Unsupported mode of the neural renderer backroungd: "
f"'{self.image_translator.background_mode}'")
def _create_detail_generator(self):
#backwards compatibility hack:
if hasattr(self, 'D_detail'):
if (not "detail_conditioning_type" in self.config.keys() or self.config.detail_conditioning_type == "concat") \
and isinstance(self.D_detail, Generator):
return
if self.config.detail_conditioning_type == "adain" and isinstance(self.D_detail, GeneratorAdaIn):
return
print("[WARNING]: We are reinitializing the detail generator!")
del self.D_detail # just to make sure we free the CUDA memory, probably not necessary
if not "detail_conditioning_type" in self.config.keys() or str(self.config.detail_conditioning_type).lower() == "concat":
# concatenates detail latent and conditioning (this one is used by DECA/EMOCA)
print("Creating classic detail generator.")
self.D_detail = Generator(latent_dim=self.n_detail + self.n_detail_emo + self.n_cond, out_channels=1, out_scale=0.01,
sample_mode='bilinear')
elif str(self.config.detail_conditioning_type).lower() == "adain":
# conditioning passed in through adain layers (this one is experimental and not currently used)
print("Creating AdaIn detail generator.")
self.D_detail = GeneratorAdaIn(self.n_detail + self.n_detail_emo, self.n_cond, out_channels=1, out_scale=0.01,
sample_mode='bilinear')
else:
raise NotImplementedError(f"Detail conditioning invalid: '{self.config.detail_conditioning_type}'")
def _create_model(self):
# 1) build coarse encoder
e_flame_type = 'ResnetEncoder'
if 'e_flame_type' in self.config.keys():
e_flame_type = self.config.e_flame_type
if e_flame_type == 'ResnetEncoder':
self.E_flame = ResnetEncoder(outsize=self.n_param)
elif e_flame_type[:4] == 'swin':
self.E_flame = SwinEncoder(outsize=self.n_param, img_size=self.config.image_size, swin_type=e_flame_type)
else:
raise ValueError(f"Invalid 'e_flame_type' = {e_flame_type}")
flame_cfg = copy.deepcopy(self.config)
flame_cfg.n_shape = self._get_num_shape_params()
if 'flame_mediapipe_lmk_embedding_path' not in flame_cfg.keys():
self.flame = FLAME(flame_cfg)
else:
self.flame = FLAME_mediapipe(flame_cfg)
if self.uses_texture():
self.flametex = FLAMETex(self.config)
else:
self.flametex = None
# 2) build detail encoder
e_detail_type = 'ResnetEncoder'
if 'e_detail_type' in self.config.keys():
e_detail_type = self.config.e_detail_type
if e_detail_type == 'ResnetEncoder':
self.E_detail = ResnetEncoder(outsize=self.n_detail + self.n_detail_emo)
elif e_flame_type[:4] == 'swin':
self.E_detail = SwinEncoder(outsize=self.n_detail + self.n_detail_emo, img_size=self.config.image_size, swin_type=e_detail_type)
else:
raise ValueError(f"Invalid 'e_detail_type'={e_detail_type}")
self._create_detail_generator()
# self._load_old_checkpoint()
def _get_coarse_trainable_parameters(self):
print("Add E_flame.parameters() to the optimizer")
return list(self.E_flame.parameters())
def _get_detail_trainable_parameters(self):
trainable_params = []
if self.config.train_coarse:
trainable_params += self._get_coarse_trainable_parameters()
print("Add E_flame.parameters() to the optimizer")
trainable_params += list(self.E_detail.parameters())
print("Add E_detail.parameters() to the optimizer")
trainable_params += list(self.D_detail.parameters())
print("Add D_detail.parameters() to the optimizer")
return trainable_params
def train(self, mode: bool = True):
super().train(mode)
if mode:
if self.mode == DecaMode.COARSE:
self.E_flame.train()
# print("Setting E_flame to train")
self.E_detail.eval()
# print("Setting E_detail to eval")
self.D_detail.eval()
# print("Setting D_detail to eval")
elif self.mode == DecaMode.DETAIL:
if self.config.train_coarse:
# print("Setting E_flame to train")
self.E_flame.train()
else:
# print("Setting E_flame to eval")
self.E_flame.eval()
self.E_detail.train()
# print("Setting E_detail to train")
self.D_detail.train()
# print("Setting D_detail to train")
else:
raise ValueError(f"Invalid mode '{self.mode}'")
else:
self.E_flame.eval()
# print("Setting E_flame to eval")
self.E_detail.eval()
# print("Setting E_detail to eval")
self.D_detail.eval()
# print("Setting D_detail to eval")
# these are set to eval no matter what, they're never being trained (the FLAME shape and texture spaces are pretrained)
self.flame.eval()
if self.flametex is not None:
self.flametex.eval()
return self
def _load_old_checkpoint(self):
"""
Loads the DECA model weights from the original DECA implementation:
https://github.com/YadiraF/DECA
"""
if self.config.resume_training:
model_path = self.config.pretrained_modelpath
print(f"Loading model state from '{model_path}'")
checkpoint = torch.load(model_path)
# model
util.copy_state_dict(self.E_flame.state_dict(), checkpoint['E_flame'])
# util.copy_state_dict(self.opt.state_dict(), checkpoint['opt']) # deprecate
# detail model
if 'E_detail' in checkpoint.keys():
util.copy_state_dict(self.E_detail.state_dict(), checkpoint['E_detail'])
util.copy_state_dict(self.D_detail.state_dict(), checkpoint['D_detail'])
# training state
self.start_epoch = 0 # checkpoint['epoch']
self.start_iter = 0 # checkpoint['iter']
else:
print('Start training from scratch')
self.start_epoch = 0
self.start_iter = 0
def _encode_flame(self, images, **kwargs):
return self.E_flame(images)
def decompose_code(self, code):
'''
config.n_shape + config.n_tex + config.n_exp + config.n_pose + config.n_cam + config.n_light
'''
code_list = []
# num_list = [self.config.n_shape, self.config.n_tex, self.config.n_exp, self.config.n_pose, self.config.n_cam,
# self.config.n_light]
num_list = [self._get_num_shape_params(), self.config.n_tex, self.config.n_exp, self.config.n_pose, self.config.n_cam,
self.config.n_light]
start = 0
for i in range(len(num_list)):
code_list.append(code[:, start:start + num_list[i]])
start = start + num_list[i]
# shapecode, texcode, expcode, posecode, cam, lightcode = code_list
code_list[-1] = code_list[-1].reshape(code.shape[0], 9, 3)
return code_list, None
def displacement2normal(self, uv_z, coarse_verts, coarse_normals, detach=True):
"""
Converts the displacement uv map (uv_z) and coarse_verts to a normal map coarse_normals.
"""
batch_size = uv_z.shape[0]
uv_coarse_vertices = self.render.world2uv(coarse_verts)#.detach()
if detach:
uv_coarse_vertices = uv_coarse_vertices.detach()
uv_coarse_normals = self.render.world2uv(coarse_normals)#.detach()
if detach:
uv_coarse_normals = uv_coarse_normals.detach()
uv_z = uv_z * self.uv_face_eye_mask
# detail vertices = coarse vertice + predicted displacement*normals + fixed displacement*normals
uv_detail_vertices = uv_coarse_vertices + \
uv_z * uv_coarse_normals + \
self.fixed_uv_dis[None, None, :,:] * uv_coarse_normals #.detach()
dense_vertices = uv_detail_vertices.permute(0, 2, 3, 1).reshape([batch_size, -1, 3])
uv_detail_normals = util.vertex_normals(dense_vertices, self.render.dense_faces.expand(batch_size, -1, -1))
uv_detail_normals = uv_detail_normals.reshape(
[batch_size, uv_coarse_vertices.shape[2], uv_coarse_vertices.shape[3], 3]).permute(0, 3, 1, 2)
# uv_detail_normals = uv_detail_normals*self.uv_face_eye_mask + uv_coarse_normals*(1-self.uv_face_eye_mask)
# uv_detail_normals = util.gaussian_blur(uv_detail_normals)
return uv_detail_normals, uv_coarse_vertices
def visualize(self, visdict, savepath, catdim=1):
grids = {}
for key in visdict:
# print(key)
if visdict[key] is None:
continue
grids[key] = torchvision.utils.make_grid(
F.interpolate(visdict[key], [self.config.image_size, self.config.image_size])).detach().cpu()
grid = torch.cat(list(grids.values()), catdim)
grid_image = (grid.numpy().transpose(1, 2, 0).copy() * 255)[:, :, [2, 1, 0]]
grid_image = np.minimum(np.maximum(grid_image, 0), 255).astype(np.uint8)
if savepath is not None:
cv2.imwrite(savepath, grid_image)
return grid_image
def create_mesh(self, opdict, dense_template):
'''
vertices: [nv, 3], tensor
texture: [3, h, w], tensor
'''
i = 0
vertices = opdict['verts'][i].cpu().numpy()
faces = self.render.faces[0].cpu().numpy()
if 'uv_texture_gt' in opdict.keys():
texture = util.tensor2image(opdict['uv_texture_gt'][i])
else:
texture = None
uvcoords = self.render.raw_uvcoords[0].cpu().numpy()
uvfaces = self.render.uvfaces[0].cpu().numpy()
# save coarse mesh, with texture and normal map
if 'uv_detail_normals' in opdict.keys():
normal_map = util.tensor2image(opdict['uv_detail_normals'][i]*0.5 + 0.5)
# upsample mesh, save detailed mesh
texture = texture[:, :, [2, 1, 0]]
normals = opdict['normals'][i].cpu().numpy()
displacement_map = opdict['displacement_map'][i].detach().cpu().numpy().squeeze()
dense_vertices, dense_colors, dense_faces = util.upsample_mesh(vertices, normals, faces,
displacement_map, texture, dense_template)
else:
normal_map = None
dense_vertices = None
dense_colors = None
dense_faces = None
return vertices, faces, texture, uvcoords, uvfaces, normal_map, dense_vertices, dense_faces, dense_colors
def save_obj(self, filename, opdict, dense_template, mode ='detail'):
if mode not in ['coarse', 'detail', 'both']:
raise ValueError(f"Invalid mode '{mode}. Expected modes are: 'coarse', 'detail', 'both'")
vertices, faces, texture, uvcoords, uvfaces, normal_map, dense_vertices, dense_faces, dense_colors \
= self.create_mesh(opdict, dense_template)
if mode == 'both':
if isinstance(filename, list):
filename_coarse = filename[0]
filename_detail = filename[1]
else:
filename_coarse = filename
filename_detail = filename.replace('.obj', '_detail.obj')
elif mode == 'coarse':
filename_coarse = filename
else:
filename_detail = filename
if mode in ['coarse', 'both']:
util.write_obj(str(filename_coarse), vertices, faces,
texture=texture,
uvcoords=uvcoords,
uvfaces=uvfaces,
normal_map=normal_map)
if mode in ['detail', 'both']:
util.write_obj(str(filename_detail),
dense_vertices,
dense_faces,
colors = dense_colors,
inverse_face_order=True)
class ExpDECAInterface(object):
"""
This serves as an interface for EMOCA-like classes that need to use a different sub class but
retain the EMOCA functionality. See EMICA_v2 for an example.
"""
def _create_model(self):
# E_flame should be fixed for expression EMOCA
self.E_flame.requires_grad_(False)
# 2) add expression decoder
if self.config.expression_backbone == 'deca_parallel':
## a) Attach a parallel flow of FCs onto the original DECA coarse backbone. (Only the second FC head is trainable)
self.E_expression = SecondHeadResnet(self.E_flame, self.n_exp_param, 'same')
elif self.config.expression_backbone == 'deca_clone':
## b) Clones the original DECA coarse decoder (and the entire decoder will be trainable) - This is in final EMOCA.
#TODO this will only work for Resnet. Make this work for the other backbones (Swin) as well.
self.E_expression = ResnetEncoder(self.n_exp_param)
# clone parameters of the ResNet
self.E_expression.encoder.load_state_dict(self.E_flame.encoder.state_dict())
elif self.config.expression_backbone == 'emonet_trainable':
# Trainable EmoNet instead of Resnet (deprecated) | self.E_expression = EmoNetRegressor(self.n_exp_param) | 21 | 2023-11-07 20:13:32+00:00 | 24k |
codefuse-ai/Collinear-Constrained-Attention | model/build_model.py | [
{
"identifier": "get_model_params_num",
"path": "utils/common_utils.py",
"snippet": "def get_model_params_num(model):\n \"\"\"\n Get params number of the model\n Args:\n model: model(required)\n Returns:\n the number of parameters of model\n \"\"\"\n num = 0\n for _, p... | import os
import torch
import sys
import peft
import model.peft.modeling_peft # noqa
import bitsandbytes as bnb # noqa
import accelerate # noqa
from utils.common_utils import get_model_params_num
from transformers import ( # noqa: E402
CONFIG_MAPPING,
AutoConfig,
AutoModelForCausalLM,
AutoTokenizer,
PreTrainedTokenizerFast
)
from .gpt_neox.configuration_gpt_neox import GPTNeoXConfig
from .gpt_neox.modeling_gpt_neox import GPTNeoXForCausalLM
from .gpt_neox.tokenization_gpt_neox_fast import GPTNeoXTokenizerFast
from .llama.configuration_llama import LlamaConfig
from .llama.modeling_llama import LlamaForCausalLM
from .llama.tokenization_llama import LlamaTokenizer
from .llama.tokenization_llama_fast import LlamaTokenizerFast
from torch.distributed.fsdp import (
FullyShardedDataParallel as FSDP,
StateDictType,
)
from utils.common_utils import print_rank_0, is_old_version
from tokenizer import build_tokenizer
from tokenizer.tokenizer import HFTokenizer
from peft.tuners.lora import LoraLayer
from model.peft.utils import prepare_model_for_kbit_training
from peft import ( # noqa
LoraConfig,
PrefixTuningConfig,
PromptEncoderConfig,
PromptEncoderReparameterizationType,
PromptTuningConfig,
PromptTuningInit,
TaskType,
get_peft_model
)
from model.peft.tuner import AdaLoraConfig
from transformers import BitsAndBytesConfig
from packaging import version
from .glm.tokenization_glm_deprecated import GLMChineseTokenizer | 17,455 | # coding=utf-8
# Copyright (c) 2023 Ant Group. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
sys.path.append("..")
# from .glm.modeling_glm import GLMForConditionalGeneration
# from .glm.configuration_glm import GLMConfig
# from .glm.tokenization_glm import GLMTokenizer
try:
except ImportError:
BitsAndBytesConfig = None
try:
except ImportError:
bnb = None
def find_all_linear_names(args, model):
cls = bnb.nn.Linear4bit if args.bits == 4 else (bnb.nn.Linear8bitLt if args.bits == 8 else torch.nn.Linear)
lora_module_names = set()
for name, module in model.named_modules():
if isinstance(module, cls):
names = name.split('.')
lora_module_names.add(names[0] if len(names) == 1 else names[-1])
if 'lm_head' in lora_module_names: # needed for 16-bit
lora_module_names.remove('lm_head')
return list(lora_module_names)
def setup_model(args, logger, use_cache=False):
# Load pretrained model and tokenizer
if args.pretrained_model_path: # TODO: 实现from pretrained读tokenizer
if args.model_type == 'gpt_neox':
# if args.tokenizer_type:
# tokenizer = build_tokenizer(args)
# tokenizer.eod_token = "<|endoftext|>"
# tokenizer.pad_token = "<|pad|>"
# # tokenizer.sop_token = "<|endoftext|>" # 适配multi task dataset
# # tokenizer.eop_token = "<|endoftext|>"
# tokenizer.eod_id = tokenizer.tokenize(tokenizer.eod_token)[0]
# tokenizer.pad_id = tokenizer.tokenize(tokenizer.pad_token)[0]
# else:
tokenizer = GPTNeoXTokenizerFast.from_pretrained(args.pretrained_model_path)
# tokenizer = PreTrainedTokenizerFast(tokenizer_file=args.vocab_file)
tokenizer.eod_token = "<|endoftext|>"
tokenizer.pad_token = "<|pad|>"
tokenizer.sop_token = "<|endoftext|>" # 适配multi task dataset
tokenizer.eop_token = "<|endoftext|>"
tokenizer.eod_id = tokenizer.convert_tokens_to_ids(tokenizer.eod_token)
tokenizer.pad_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
print_rank_0(f'tokenizer {tokenizer.eod_token} id: {tokenizer.eod_id}')
print_rank_0(f'tokenizer {tokenizer.pad_token} id: {tokenizer.pad_id}')
elif args.model_type == 'llama':
tokenizer = LlamaTokenizerFast.from_pretrained(args.pretrained_model_path)
# tokenizer = AutoTokenizer.from_pretrained(
# args.pretrained_model_path,
# trust_remote_code=True,
# )
tokenizer.eod_token = "</s>"
tokenizer.eos_token = "</s>"
tokenizer.bos_token = "<s>"
tokenizer.pad_token = "[PAD]"
tokenizer.unk_token = "<unk>"
tokenizer.sop_token = "</s>" # 适配multi task dataset
tokenizer.eop_token = "</s>"
tokenizer.eod_id = tokenizer.convert_tokens_to_ids(tokenizer.eod_token)
tokenizer.eos_id = tokenizer.convert_tokens_to_ids(tokenizer.eos_token)
tokenizer.bos_id = tokenizer.convert_tokens_to_ids(tokenizer.bos_token)
tokenizer.pad_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
tokenizer.unk_id = tokenizer.convert_tokens_to_ids(tokenizer.unk_token)
print_rank_0(f'tokenizer {tokenizer.eod_token} id: {tokenizer.eod_id}')
print_rank_0(f'tokenizer {tokenizer.eos_token} id: {tokenizer.eos_id}')
print_rank_0(f'tokenizer {tokenizer.bos_token} id: {tokenizer.bos_id}')
print_rank_0(f'tokenizer {tokenizer.pad_token} id: {tokenizer.pad_id}')
print_rank_0(f'tokenizer {tokenizer.unk_token} id: {tokenizer.unk_id}')
elif args.model_type == 'glm':
if is_old_version(args.pretrained_model_path):
tokenizer = GLMChineseTokenizer.from_pretrained(args.pretrained_model_path)
else:
tokenizer = GLMTokenizer.from_pretrained(args.pretrained_model_path)
elif args.train_mode == 'sst':
# tokenizer = build_tokenizer(args)
tokenizer = PreTrainedTokenizerFast(tokenizer_file=args.vocab_file)
tokenizer.eod_token = "<|endoftext|>"
tokenizer.pad_token = "<|pad|>"
tokenizer.sop_token = "<|endoftext|>" # 适配multi task dataset
tokenizer.eop_token = "<|endoftext|>"
tokenizer.eod_id = tokenizer.convert_tokens_to_ids(tokenizer.eod_token)
tokenizer.pad_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
print_rank_0(f'tokenizer {tokenizer.eod_token} id: {tokenizer.eod_id}')
print_rank_0(f'tokenizer {tokenizer.pad_token} id: {tokenizer.pad_id}')
else:
raise ValueError(
"You are instantiating a new tokenizer from scratch. This is not supported by this script."
"You can do it from another script, save it, and load it from here, using --tokenizer_path."
)
if args.model_type == 'gpt_neox':
auto_config = GPTNeoXConfig
auto_model_class = GPTNeoXForCausalLM
elif args.model_type == 'llama':
auto_config = LlamaConfig
| # coding=utf-8
# Copyright (c) 2023 Ant Group. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
sys.path.append("..")
# from .glm.modeling_glm import GLMForConditionalGeneration
# from .glm.configuration_glm import GLMConfig
# from .glm.tokenization_glm import GLMTokenizer
try:
except ImportError:
BitsAndBytesConfig = None
try:
except ImportError:
bnb = None
def find_all_linear_names(args, model):
cls = bnb.nn.Linear4bit if args.bits == 4 else (bnb.nn.Linear8bitLt if args.bits == 8 else torch.nn.Linear)
lora_module_names = set()
for name, module in model.named_modules():
if isinstance(module, cls):
names = name.split('.')
lora_module_names.add(names[0] if len(names) == 1 else names[-1])
if 'lm_head' in lora_module_names: # needed for 16-bit
lora_module_names.remove('lm_head')
return list(lora_module_names)
def setup_model(args, logger, use_cache=False):
# Load pretrained model and tokenizer
if args.pretrained_model_path: # TODO: 实现from pretrained读tokenizer
if args.model_type == 'gpt_neox':
# if args.tokenizer_type:
# tokenizer = build_tokenizer(args)
# tokenizer.eod_token = "<|endoftext|>"
# tokenizer.pad_token = "<|pad|>"
# # tokenizer.sop_token = "<|endoftext|>" # 适配multi task dataset
# # tokenizer.eop_token = "<|endoftext|>"
# tokenizer.eod_id = tokenizer.tokenize(tokenizer.eod_token)[0]
# tokenizer.pad_id = tokenizer.tokenize(tokenizer.pad_token)[0]
# else:
tokenizer = GPTNeoXTokenizerFast.from_pretrained(args.pretrained_model_path)
# tokenizer = PreTrainedTokenizerFast(tokenizer_file=args.vocab_file)
tokenizer.eod_token = "<|endoftext|>"
tokenizer.pad_token = "<|pad|>"
tokenizer.sop_token = "<|endoftext|>" # 适配multi task dataset
tokenizer.eop_token = "<|endoftext|>"
tokenizer.eod_id = tokenizer.convert_tokens_to_ids(tokenizer.eod_token)
tokenizer.pad_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
print_rank_0(f'tokenizer {tokenizer.eod_token} id: {tokenizer.eod_id}')
print_rank_0(f'tokenizer {tokenizer.pad_token} id: {tokenizer.pad_id}')
elif args.model_type == 'llama':
tokenizer = LlamaTokenizerFast.from_pretrained(args.pretrained_model_path)
# tokenizer = AutoTokenizer.from_pretrained(
# args.pretrained_model_path,
# trust_remote_code=True,
# )
tokenizer.eod_token = "</s>"
tokenizer.eos_token = "</s>"
tokenizer.bos_token = "<s>"
tokenizer.pad_token = "[PAD]"
tokenizer.unk_token = "<unk>"
tokenizer.sop_token = "</s>" # 适配multi task dataset
tokenizer.eop_token = "</s>"
tokenizer.eod_id = tokenizer.convert_tokens_to_ids(tokenizer.eod_token)
tokenizer.eos_id = tokenizer.convert_tokens_to_ids(tokenizer.eos_token)
tokenizer.bos_id = tokenizer.convert_tokens_to_ids(tokenizer.bos_token)
tokenizer.pad_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
tokenizer.unk_id = tokenizer.convert_tokens_to_ids(tokenizer.unk_token)
print_rank_0(f'tokenizer {tokenizer.eod_token} id: {tokenizer.eod_id}')
print_rank_0(f'tokenizer {tokenizer.eos_token} id: {tokenizer.eos_id}')
print_rank_0(f'tokenizer {tokenizer.bos_token} id: {tokenizer.bos_id}')
print_rank_0(f'tokenizer {tokenizer.pad_token} id: {tokenizer.pad_id}')
print_rank_0(f'tokenizer {tokenizer.unk_token} id: {tokenizer.unk_id}')
elif args.model_type == 'glm':
if is_old_version(args.pretrained_model_path):
tokenizer = GLMChineseTokenizer.from_pretrained(args.pretrained_model_path)
else:
tokenizer = GLMTokenizer.from_pretrained(args.pretrained_model_path)
elif args.train_mode == 'sst':
# tokenizer = build_tokenizer(args)
tokenizer = PreTrainedTokenizerFast(tokenizer_file=args.vocab_file)
tokenizer.eod_token = "<|endoftext|>"
tokenizer.pad_token = "<|pad|>"
tokenizer.sop_token = "<|endoftext|>" # 适配multi task dataset
tokenizer.eop_token = "<|endoftext|>"
tokenizer.eod_id = tokenizer.convert_tokens_to_ids(tokenizer.eod_token)
tokenizer.pad_id = tokenizer.convert_tokens_to_ids(tokenizer.pad_token)
print_rank_0(f'tokenizer {tokenizer.eod_token} id: {tokenizer.eod_id}')
print_rank_0(f'tokenizer {tokenizer.pad_token} id: {tokenizer.pad_id}')
else:
raise ValueError(
"You are instantiating a new tokenizer from scratch. This is not supported by this script."
"You can do it from another script, save it, and load it from here, using --tokenizer_path."
)
if args.model_type == 'gpt_neox':
auto_config = GPTNeoXConfig
auto_model_class = GPTNeoXForCausalLM
elif args.model_type == 'llama':
auto_config = LlamaConfig | auto_model_class = LlamaForCausalLM | 5 | 2023-11-02 01:37:01+00:00 | 24k |
bytedance/cryostar | projects/star/train_atom.py | [
{
"identifier": "SpatialGridTranslate",
"path": "cryostar/utils/transforms.py",
"snippet": "class SpatialGridTranslate(torch.nn.Module):\n\n def __init__(self, D, device=None) -> None:\n super().__init__()\n self.D = D\n # yapf: disable\n coords = torch.stack(torch.meshgri... | import os.path as osp
import warnings
import collections
import einops
import numpy as np
import biotite.structure as struc
import torch
import lightning.pytorch as pl
from pathlib import Path
from copy import deepcopy
from torch import nn
from torch import optim
from torch.utils.data import DataLoader
from torchinfo import summary
from lightning.fabric.utilities.warnings import PossibleUserWarning
from lightning.pytorch.utilities import rank_zero_only
from lightning.pytorch.strategies import DDPStrategy
from mmengine import mkdir_or_exist
from cryostar.utils.transforms import SpatialGridTranslate
from cryostar.utils.dataio import StarfileDataSet, StarfileDatasetConfig, Mask
from cryostar.utils.ctf_utils import CTFRelion, CTFCryoDRGN
from cryostar.utils.losses import calc_cor_loss, calc_kl_loss
from cryostar.utils.misc import log_to_current, \
pl_init_exp, pretty_dict, set_seed, warmup
from cryostar.utils.pdb_tools import bt_save_pdb
from cryostar.gmm.gmm import EMAN2Grid, batch_projection, Gaussian
from cryostar.gmm.deformer import E3Deformer, NMADeformer
from cryostar.utils.fft_utils import primal_to_fourier_2d, fourier_to_primal_2d
from cryostar.utils.polymer import Polymer, NT_ATOMS, AA_ATOMS
from cryostar.utils.dist_loss import (find_quaint_cutoff_pairs, find_range_cutoff_pairs, find_continuous_pairs,
calc_dist_by_pair_indices, remove_duplicate_pairs, filter_same_chain_pairs,
DistLoss)
from cryostar.utils.latent_space_utils import get_nearest_point, cluster_kmeans, run_pca, get_pc_traj, run_umap
from cryostar.utils.vis_utils import plot_z_dist, save_tensor_image
from cryostar.utils.pl_utils import merge_step_outputs, squeeze_dict_outputs_1st_dim, \
filter_outputs_by_indices, get_1st_unique_indices
from miscs import calc_pair_dist_loss, calc_clash_loss, low_pass_mask2d, VAE, infer_ctf_params_from_config | 16,442 | if cfg.loss.sse_weight != 0.0:
log_to_current("use pseduo `sse` by building spatial/sequential edges")
sse_pairs = find_quaint_cutoff_pairs(meta.coord, meta.chain_id, meta.res_id, cfg.loss.intra_chain_cutoff, 0,
20)
cutoff_pairs = remove_duplicate_pairs(cutoff_pairs, sse_pairs)
clash_pairs = find_range_cutoff_pairs(meta.coord, cfg.loss.clash_min_cutoff)
clash_pairs = remove_duplicate_pairs(clash_pairs, connect_pairs)
if len(connect_pairs) > 0:
self.register_buffer("connect_pairs", torch.from_numpy(connect_pairs).long())
dists = calc_dist_by_pair_indices(meta.coord, connect_pairs)
self.register_buffer("connect_dists", torch.from_numpy(dists).float())
log_to_current(f"found {len(connect_pairs)} connect_pairs")
else:
log_to_current("connect_pairs is empty")
if cfg.loss.sse_weight != 0.0:
self.register_buffer("sse_pairs", torch.from_numpy(sse_pairs).long())
dists = calc_dist_by_pair_indices(meta.coord, sse_pairs)
self.register_buffer("sse_dists", torch.from_numpy(dists).float())
log_to_current(f"found {len(sse_pairs)} sse_pairs")
if len(cutoff_pairs) > 0:
dists = calc_dist_by_pair_indices(meta.coord, cutoff_pairs)
log_to_current(f"found {len(cutoff_pairs)} cutoff_pairs")
self.dist_loss_fn = DistLoss(cutoff_pairs, dists, reduction=None)
# for chain-wise dropout
cutoff_chain_mask = filter_same_chain_pairs(cutoff_pairs, meta.chain_id)
self.register_buffer("cutoff_chain_mask", torch.from_numpy(cutoff_chain_mask))
else:
log_to_current("cutoff_pairs is empty")
if len(clash_pairs) > 0:
self.register_buffer("clash_pairs", torch.from_numpy(clash_pairs).long())
log_to_current(f"found {len(clash_pairs)} clash_pairs")
else:
log_to_current("clash_pairs is empty")
# low-pass filtering
if hasattr(cfg.data_process, "low_pass_bandwidth"):
log_to_current(f"Use low-pass filtering w/ {cfg.data_process.low_pass_bandwidth} A")
lp_mask2d = low_pass_mask2d(cfg.data_process.down_side_shape, cfg.data_process.down_apix,
cfg.data_process.low_pass_bandwidth)
self.register_buffer("lp_mask2d", torch.from_numpy(lp_mask2d).float())
else:
self.lp_mask2d = None
#
self.mask = Mask(cfg.data_process.down_side_shape, rad=cfg.loss.mask_rad_for_image_loss)
# for projection
grid = EMAN2Grid(side_shape=cfg.data_process.down_side_shape, voxel_size=cfg.data_process.down_apix)
self.grid = grid
ctf_params = infer_ctf_params_from_config(cfg)
if cfg.model.ctf == "v1":
self.ctf = CTFRelion(**ctf_params, num_particles=len(dataset))
log_to_current("We will deprecate `model.ctf=v1` in a future version, use `model.ctf=v2` instead.")
elif cfg.model.ctf == "v2":
self.ctf = CTFCryoDRGN(**ctf_params, num_particles=len(dataset))
else:
raise NotImplementedError
log_to_current(ctf_params)
# translate image helper
self.translator = SpatialGridTranslate(D=cfg.data_process.down_side_shape, device=self.device)
self.apix = self.cfg.data_process.down_apix
# cache
self.validation_step_outputs = []
self.stored_metrics = {}
self.history_saved_dirs = []
if getattr(self.cfg.extra_input_data_attr, "ckpt_path", None) is not None:
log_to_current(f"load checkpoint from {self.cfg.extra_input_data_attr.ckpt_path}")
self._load_ckpt(self.cfg.extra_input_data_attr.ckpt_path)
def _save_ckpt(self, ckpt_path):
torch.save(
{
"model": self.model.state_dict(),
"gmm_sigmas": self.gmm_sigmas.data,
"gmm_amps": self.gmm_amps.data
}, ckpt_path)
def _load_ckpt(self, ckpt_path):
state_dict = torch.load(ckpt_path, map_location=self.device)
self.model.load_state_dict(state_dict["model"])
if self.cfg.gmm.tunable:
self.gmm_sigmas.data = state_dict["gmm_sigmas"]
self.gmm_amps.data = state_dict["gmm_amps"]
def _get_save_dir(self):
save_dir = osp.join(self.cfg.work_dir, f"{self.current_epoch:04d}_{self.global_step:07d}")
mkdir_or_exist(save_dir)
return save_dir
def low_pass_images(self, images):
f_images = primal_to_fourier_2d(images)
f_images = f_images * self.lp_mask2d
images = fourier_to_primal_2d(f_images).real
return images
def get_batch_pose(self, batch):
rot_mats = batch["rotmat"]
# yx order
trans_mats = torch.concat((batch["shiftY"].unsqueeze(1), batch["shiftX"].unsqueeze(1)), dim=1)
trans_mats /= self.apix
return rot_mats, trans_mats
def _shared_forward(self, images, idxes, rots):
# predict structure
pred_deformation, mu, log_var = self.model(prepare_images(images, self.cfg.model.input_space), idxes, rots)
return pred_deformation, mu, log_var
def _shared_projection(self, pred_struc, rot_mats):
pred_images = batch_projection(
|
# other
# avoid num_workers set as cpu_count warning
warnings.simplefilter("ignore", PossibleUserWarning)
# only log to rank_zero, comment this for debugging
log_to_current = rank_zero_only(log_to_current)
TASK_NAME = "atom"
def prepare_images(images: torch.FloatTensor, space: str):
assert space in ("real", "fourier")
if space == "real":
model_input = einops.rearrange(images, "b 1 ny nx -> b (1 ny nx)")
else:
fimages = primal_to_fourier_2d(images)
model_input = einops.rearrange(torch.view_as_real(fimages), "b 1 ny nx c2 -> b (1 ny nx c2)", c2=2)
return model_input
class InitTask(pl.LightningModule):
def __init__(self, em_module):
super().__init__()
self.cfg = em_module.cfg
self.em_module = em_module
self.loss_deque = collections.deque([
10,
], maxlen=20)
def on_train_batch_end(self, outputs, batch, batch_idx):
self.loss_deque.append(outputs['loss'].item())
if np.mean(self.loss_deque) < 1e-3:
self.trainer.should_stop = True
# update all process status
self.trainer.should_stop = self.trainer.strategy.broadcast(self.trainer.should_stop)
def training_step(self, batch, batch_idx):
images = batch["proj"]
idxes = batch["idx"]
rot_mats, trans_mats = self.em_module.get_batch_pose(batch)
pred_deformation, mu, log_var = self.em_module.model(prepare_images(images, self.cfg.model.input_space), idxes,
rot_mats)
shift_loss = torch.mean(torch.pow(pred_deformation.flatten(start_dim=-2), 2))
loss = shift_loss
if self.global_step % self.cfg.runner.log_every_n_step == 0:
log_to_current(f"loss {loss.item()}")
return loss
def configure_optimizers(self):
return optim.AdamW(self.em_module.model.parameters(), lr=1e-4)
def on_fit_end(self):
log_to_current(f"Init finished with loss {np.mean(self.loss_deque)}")
class CryoEMTask(pl.LightningModule):
def __init__(self, cfg, dataset):
super().__init__()
cfg = deepcopy(cfg)
self.cfg = cfg
# Define GMM
meta = Polymer.from_pdb(cfg.dataset_attr.ref_pdb_path)
log_to_current(f"Load reference structure from {cfg.dataset_attr.ref_pdb_path}")
# for save
self.template_pdb = meta.to_atom_arr()
log_to_current(f"Protein contains {len(meta)} atoms, "
f"{meta.num_amino_acids} amino acids, "
f"{meta.num_nucleotides} nucleotides, "
f"{meta.num_chains} chains.")
# ref
ref_centers = torch.from_numpy(meta.coord).float()
ref_amps = torch.from_numpy(meta.num_electron).float()
ref_sigmas = torch.ones_like(ref_amps)
ref_sigmas.fill_(2.)
log_to_current(f"1st GMM blob amplitude {ref_amps[0].item()}, sigma {ref_sigmas[0].item()}")
num_pts = len(meta)
log_to_current(f"Reference structure has {num_pts} atom coordinates")
# tunable params
# gmm
self.register_buffer("gmm_centers", ref_centers)
if cfg.gmm.tunable:
log_to_current("Set GMM sigmas, amplitudes tunable")
self.register_parameter("gmm_sigmas", nn.Parameter(ref_sigmas))
self.register_parameter("gmm_amps", nn.Parameter(ref_amps))
else:
self.register_buffer("gmm_sigmas", ref_sigmas)
self.register_buffer("gmm_amps", ref_amps)
nma_modes = None
if (hasattr(self.cfg.extra_input_data_attr, "nma_path") and
self.cfg.extra_input_data_attr.nma_path not in ["", None]):
nma_modes = torch.tensor(np.load(self.cfg.extra_input_data_attr.nma_path), dtype=torch.float32)
log_to_current(f"Load NMA coefficients from {self.cfg.extra_input_data_attr.nma_path}, "
f"whose shape is {nma_modes.shape}")
# model
if cfg.model.input_space == "fourier":
in_dim = 2 * cfg.data_process.down_side_shape ** 2
elif cfg.model.input_space == "real":
in_dim = cfg.data_process.down_side_shape ** 2
else:
raise NotImplementedError
self.model = VAE(in_dim=in_dim,
out_dim=num_pts * 3 if nma_modes is None else 6 + nma_modes.shape[1],
**cfg.model.model_cfg)
log_to_current('Model summary:\n' + str(summary(self.model, input_size=[(1, in_dim), (1,)], verbose=0)))
if nma_modes is None:
self.deformer = E3Deformer()
else:
self.deformer = NMADeformer(nma_modes)
# loss or regularization's preparation
# dist loss
connect_pairs = find_continuous_pairs(meta.chain_id, meta.res_id, meta.atom_name)
if cfg.extra_input_data_attr.use_domain:
log_to_current("use domain instead of chain!")
domain_id = np.load(cfg.extra_input_data_attr.domain_path)
cutoff_pairs = find_quaint_cutoff_pairs(meta.coord, domain_id, meta.res_id, cfg.loss.intra_chain_cutoff,
cfg.loss.inter_chain_cutoff, cfg.loss.intra_chain_res_bound)
else:
# deal with RNA/DNA
if np.sum(np.isin(meta.atom_name, NT_ATOMS)):
# aa
tmp_mask = np.isin(meta.atom_name, AA_ATOMS)
indices_in_pdb = np.nonzero(tmp_mask)[0]
aa_cutoff_pairs = find_quaint_cutoff_pairs(meta.coord[tmp_mask], meta.chain_id[tmp_mask],
meta.res_id[tmp_mask], cfg.loss.intra_chain_cutoff,
cfg.loss.inter_chain_cutoff, cfg.loss.intra_chain_res_bound)
aa_cutoff_pairs = indices_in_pdb[aa_cutoff_pairs]
log_to_current(f"{len(aa_cutoff_pairs)} AA pairs")
# nt
tmp_mask = np.isin(meta.atom_name, NT_ATOMS)
indices_in_pdb = np.nonzero(tmp_mask)[0]
nt_cutoff_pairs = find_quaint_cutoff_pairs(meta.coord[tmp_mask], meta.chain_id[tmp_mask],
meta.res_id[tmp_mask], cfg.loss.nt_intra_chain_cutoff,
cfg.loss.nt_inter_chain_cutoff,
cfg.loss.nt_intra_chain_res_bound)
nt_cutoff_pairs = indices_in_pdb[nt_cutoff_pairs]
log_to_current(f"{len(nt_cutoff_pairs)} NT pairs")
cutoff_pairs = np.vstack((aa_cutoff_pairs, nt_cutoff_pairs))
else:
cutoff_pairs = find_quaint_cutoff_pairs(meta.coord, meta.chain_id, meta.res_id,
cfg.loss.intra_chain_cutoff, cfg.loss.inter_chain_cutoff,
cfg.loss.intra_chain_res_bound)
cutoff_pairs = remove_duplicate_pairs(cutoff_pairs, connect_pairs)
if cfg.loss.sse_weight != 0.0:
log_to_current("use pseduo `sse` by building spatial/sequential edges")
sse_pairs = find_quaint_cutoff_pairs(meta.coord, meta.chain_id, meta.res_id, cfg.loss.intra_chain_cutoff, 0,
20)
cutoff_pairs = remove_duplicate_pairs(cutoff_pairs, sse_pairs)
clash_pairs = find_range_cutoff_pairs(meta.coord, cfg.loss.clash_min_cutoff)
clash_pairs = remove_duplicate_pairs(clash_pairs, connect_pairs)
if len(connect_pairs) > 0:
self.register_buffer("connect_pairs", torch.from_numpy(connect_pairs).long())
dists = calc_dist_by_pair_indices(meta.coord, connect_pairs)
self.register_buffer("connect_dists", torch.from_numpy(dists).float())
log_to_current(f"found {len(connect_pairs)} connect_pairs")
else:
log_to_current("connect_pairs is empty")
if cfg.loss.sse_weight != 0.0:
self.register_buffer("sse_pairs", torch.from_numpy(sse_pairs).long())
dists = calc_dist_by_pair_indices(meta.coord, sse_pairs)
self.register_buffer("sse_dists", torch.from_numpy(dists).float())
log_to_current(f"found {len(sse_pairs)} sse_pairs")
if len(cutoff_pairs) > 0:
dists = calc_dist_by_pair_indices(meta.coord, cutoff_pairs)
log_to_current(f"found {len(cutoff_pairs)} cutoff_pairs")
self.dist_loss_fn = DistLoss(cutoff_pairs, dists, reduction=None)
# for chain-wise dropout
cutoff_chain_mask = filter_same_chain_pairs(cutoff_pairs, meta.chain_id)
self.register_buffer("cutoff_chain_mask", torch.from_numpy(cutoff_chain_mask))
else:
log_to_current("cutoff_pairs is empty")
if len(clash_pairs) > 0:
self.register_buffer("clash_pairs", torch.from_numpy(clash_pairs).long())
log_to_current(f"found {len(clash_pairs)} clash_pairs")
else:
log_to_current("clash_pairs is empty")
# low-pass filtering
if hasattr(cfg.data_process, "low_pass_bandwidth"):
log_to_current(f"Use low-pass filtering w/ {cfg.data_process.low_pass_bandwidth} A")
lp_mask2d = low_pass_mask2d(cfg.data_process.down_side_shape, cfg.data_process.down_apix,
cfg.data_process.low_pass_bandwidth)
self.register_buffer("lp_mask2d", torch.from_numpy(lp_mask2d).float())
else:
self.lp_mask2d = None
#
self.mask = Mask(cfg.data_process.down_side_shape, rad=cfg.loss.mask_rad_for_image_loss)
# for projection
grid = EMAN2Grid(side_shape=cfg.data_process.down_side_shape, voxel_size=cfg.data_process.down_apix)
self.grid = grid
ctf_params = infer_ctf_params_from_config(cfg)
if cfg.model.ctf == "v1":
self.ctf = CTFRelion(**ctf_params, num_particles=len(dataset))
log_to_current("We will deprecate `model.ctf=v1` in a future version, use `model.ctf=v2` instead.")
elif cfg.model.ctf == "v2":
self.ctf = CTFCryoDRGN(**ctf_params, num_particles=len(dataset))
else:
raise NotImplementedError
log_to_current(ctf_params)
# translate image helper
self.translator = SpatialGridTranslate(D=cfg.data_process.down_side_shape, device=self.device)
self.apix = self.cfg.data_process.down_apix
# cache
self.validation_step_outputs = []
self.stored_metrics = {}
self.history_saved_dirs = []
if getattr(self.cfg.extra_input_data_attr, "ckpt_path", None) is not None:
log_to_current(f"load checkpoint from {self.cfg.extra_input_data_attr.ckpt_path}")
self._load_ckpt(self.cfg.extra_input_data_attr.ckpt_path)
def _save_ckpt(self, ckpt_path):
torch.save(
{
"model": self.model.state_dict(),
"gmm_sigmas": self.gmm_sigmas.data,
"gmm_amps": self.gmm_amps.data
}, ckpt_path)
def _load_ckpt(self, ckpt_path):
state_dict = torch.load(ckpt_path, map_location=self.device)
self.model.load_state_dict(state_dict["model"])
if self.cfg.gmm.tunable:
self.gmm_sigmas.data = state_dict["gmm_sigmas"]
self.gmm_amps.data = state_dict["gmm_amps"]
def _get_save_dir(self):
save_dir = osp.join(self.cfg.work_dir, f"{self.current_epoch:04d}_{self.global_step:07d}")
mkdir_or_exist(save_dir)
return save_dir
def low_pass_images(self, images):
f_images = primal_to_fourier_2d(images)
f_images = f_images * self.lp_mask2d
images = fourier_to_primal_2d(f_images).real
return images
def get_batch_pose(self, batch):
rot_mats = batch["rotmat"]
# yx order
trans_mats = torch.concat((batch["shiftY"].unsqueeze(1), batch["shiftX"].unsqueeze(1)), dim=1)
trans_mats /= self.apix
return rot_mats, trans_mats
def _shared_forward(self, images, idxes, rots):
# predict structure
pred_deformation, mu, log_var = self.model(prepare_images(images, self.cfg.model.input_space), idxes, rots)
return pred_deformation, mu, log_var
def _shared_projection(self, pred_struc, rot_mats):
pred_images = batch_projection( | gauss=Gaussian( | 12 | 2023-11-06 07:15:26+00:00 | 24k |
KAIST-AILab/palr | train.py | [
{
"identifier": "BC",
"path": "imitation/bc.py",
"snippet": "class BC(nn.Module):\n def __init__(self, policy, env, best_policy=None,\n replay_buffer=None, replay_buffer_valid=None, seed=0, \n device='cpu', lr=3e-4, envname=None, wandb=None, save_policy_path=None, \n ... | import os
import wandb
import envs
import d4rl
import gym
import torch
from imitation.bc import BC
from imitation.rap import RAP
from imitation.fca import FCA
from imitation.mine import MINE_BC
from imitation.palr import PALR
from argparse import ArgumentParser
from itertools import product
from core.policy import TanhGaussianPolicyWithEmbedding, TanhGaussianRAPPolicy
from core.replay_buffer import EnvReplayBuffer
from core.preprocess import preprocess_dataset_with_prev_actions, data_select_num_transitions
from rlkit.envs.wrappers import NormalizedBoxEnv | 19,053 | wandb_dir = '.'
os.environ['WANDB_DIR'] = wandb_dir
os.environ['D4RL_DATASET_DIR'] = './dataset/'
def train(configs):
env = NormalizedBoxEnv(gym.make(configs['envname']))
obs_dim = env.observation_space.low.size
action_dim = env.action_space.low.size
d4rl_env = gym.make(configs['d4rl_env_name'])
stacksize = configs['stacksize']
if stacksize == 0:
stacksize = 1
device = 'cuda' if torch.cuda.is_available() else 'cpu'
envname, envtype = configs['envname'], configs['envtype']
traj_load_path = configs['traj_load_path']
print(f'-- Loading dataset from {traj_load_path}...')
dataset = d4rl_env.get_dataset()
print(f'-- Done!')
print(f'-- Preprocessing dataset... ({envtype}, {stacksize})')
| wandb_dir = '.'
os.environ['WANDB_DIR'] = wandb_dir
os.environ['D4RL_DATASET_DIR'] = './dataset/'
def train(configs):
env = NormalizedBoxEnv(gym.make(configs['envname']))
obs_dim = env.observation_space.low.size
action_dim = env.action_space.low.size
d4rl_env = gym.make(configs['d4rl_env_name'])
stacksize = configs['stacksize']
if stacksize == 0:
stacksize = 1
device = 'cuda' if torch.cuda.is_available() else 'cpu'
envname, envtype = configs['envname'], configs['envtype']
traj_load_path = configs['traj_load_path']
print(f'-- Loading dataset from {traj_load_path}...')
dataset = d4rl_env.get_dataset()
print(f'-- Done!')
print(f'-- Preprocessing dataset... ({envtype}, {stacksize})') | path = preprocess_dataset_with_prev_actions(dataset, envtype, stacksize, configs['partially_observable'], action_history_len=2) | 8 | 2023-11-06 08:35:34+00:00 | 24k |
tylerlight071/Project-Cipher | main.py | [
{
"identifier": "clear_terminal",
"path": "components/common_functions.py",
"snippet": "def clear_terminal():\n os.system('cls' if os.name == 'nt' else 'clear')"
},
{
"identifier": "print_slow",
"path": "components/common_functions.py",
"snippet": "def print_slow(text, delay=0.00): #... | import msvcrt
import os
import pickle
import sys
import time
import colorama
import pygame
from colorama import Fore, Style
from components.common_functions import clear_terminal, print_slow, shop_help, help_user, connect_help, mail_help, \
system_help
from conversations.calls import intro_call, first_call, second_call, third_call, fourth_call, fifth_call, sixth_call, \
markus_seen_call
from conversations.minigame_calls import code_shatter_call
from minigames.code_shatter_minigame import code_shatter_minigame
from minigames.eye_spy_minigame import port_scanning
from systems.level_1.amy.amy_system import AmySystem
from systems.level_1.billy.billy_system import BillySystem
from systems.level_1.cameras.camera_1 import camera_first
from systems.level_1.markus.markus_system import MarkusSystem | 15,253 | def save_game():
global inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus
with open('savegame.pkl', 'wb') as f:
pickle.dump(
(inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus),
f)
# Load the game state from a file
def load_game():
global inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus
if os.path.exists('savegame.pkl'):
with open('savegame.pkl', 'rb') as f:
inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus = pickle.load(
f)
else:
# If the savegame file doesn't exist, set the default values
inventory = []
player_level = 1
evidence = []
has_intro_call = False
has_started_game = False
seen_markus = False
balance = 30000
emails = [
{
"sender": "Hacker's Digest",
"subject": "Weekly Hacker's Digest",
"body": (
"Issue #143\n\n"
"Cipher,\n\n"
"Welcome to the latest edition of Hacker's Digest! In this issue: \n\n"
"- Unveiling the Latest Exploits\n"
"- Spotlight on Cryptocurrency Security\n"
"- Interview with a Grey Hat Hacker\n"
"- Tool of the Week: EnigmaLink\n\n"
"Don't miss out on the latest in the world of hacking and cybersecurity. Stay informed and stay secure!\n\n"
"Best regards,\n"
"Hacker's Digest Team"
)
},
{
"sender": "The Cyber Mythbuster",
"subject": "Busting Cybersecurity Myths",
"body": (
"Cipher,\n\n"
"Heard any wild cybersecurity myths lately? This week, we're busting the craziest ones, including:\n\n"
"- Using 'Password123' for Maximum Security\n"
"- Cyber Ninjas and Their Stealthy VPNs\n"
"- USB Drives: The Fountain of Eternal Data\n\n"
"Stay myth-free and keep on hacking (responsibly)!\n\n"
"Mythbustingly,\n"
"The Cyber Mythbuster"
)
},
{
"sender": "CyberSilliness",
"subject": "Where Cyber Meets Comedy",
"body": (
"Welcome to the CyberSilliness Gazette\n"
"Where we believe that a good laugh is the ultimate antivirus! In this week's hilarity-packed issue:\n\n"
"- Cyber Jokes to Crack You Up (Without Cracking Your Passwords)\n"
"- Tech Support Horror Stories: A Comedy of Errors\n"
"- Chuckle Challenge: Share Your Funniest Cybersecurity Anecdote\n"
"- Meet the Cyber Clowns: Our Team's Silly Security Habits Revealed\n\n"
"Laughter is contagious, and so is good cybersecurity. Dive into the giggles and stay safe!\n\n"
"Silly Regards,\n"
"The CyberSilliness Team"
)
},
{
"sender": "Security Insight Weekly",
"subject": "Navigating the Cybersecurity Landscape",
"body": (
"Hello Cipher,\n\n"
"Welcome to Security Insight Weekly, your reliable source for navigating the ever-evolving cybersecurity landscape. In this week's issue:\n\n"
"- Threat Analysis: Understanding Recent Cybersecurity Incidents\n"
"- Best Practices for Endpoint Security\n"
"- Industry Spotlight: Healthcare Cybersecurity Challenges\n"
"- Security Compliance Update: Staying Aligned with Regulations\n\n"
"Stay informed and empowered as we delve into the serious aspects of cybersecurity. Your security is our priority.\n\n"
"Best regards,\n"
"The Security Insight Team"
)
},
]
# New function for game settings
def game_settings():
global bg_music_enabled
print_slow(Fore.GREEN + "░██████╗███████╗████████╗████████╗██╗███╗░░██╗░██████╗░░██████╗")
print_slow(Fore.GREEN + "██╔════╝██╔════╝╚══██╔══╝╚══██╔══╝██║████╗░██║██╔════╝░██╔════╝")
print_slow(Fore.GREEN + "╚█████╗░█████╗░░░░░██║░░░░░░██║░░░██║██╔██╗██║██║░░██╗░╚█████╗░")
print_slow(Fore.GREEN + "░╚═══██╗██╔══╝░░░░░██║░░░░░░██║░░░██║██║╚████║██║░░╚██╗░╚═══██╗")
print_slow(Fore.GREEN + "██████╔╝███████╗░░░██║░░░░░░██║░░░██║██║░╚███║╚██████╔╝██████╔╝")
print_slow(Fore.GREEN + "╚═════╝░╚══════╝░░░╚═╝░░░░░░╚═╝░░░╚═╝╚═╝░░╚══╝░╚═════╝░╚═════╝░" + Style.RESET_ALL)
print_slow("")
print_slow("")
print_slow("")
print_slow(Fore.GREEN + " --------------------------------------------" + Style.RESET_ALL)
print_slow(
Fore.GREEN + f"| [Background Music] {'Enabled |' if bg_music_enabled else 'Disabled |'}" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| [Delete Savegame] |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| [Back to Main Menu] |" + Style.RESET_ALL)
print_slow(Fore.GREEN + " --------------------------------------------" + Style.RESET_ALL)
choice = input(Fore.GREEN + "\n> " + Style.RESET_ALL)
if choice.lower() == "background music":
# Toggle background music
bg_music_enabled = not bg_music_enabled
if bg_music_enabled:
pygame.mixer.music.play(-1)
print_slow(Fore.GREEN + "\nBackground Music Enabled" + Style.RESET_ALL)
time.sleep(1)
|
# Set the PYGAME_HIDE_SUPPORT_PROMPT environment variable
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "1"
# Initialize pygame mixer
pygame.mixer.init()
# Load the bg music file and loop it
pygame.mixer.music.load('bg_music.mp3')
pygame.mixer.music.play(-1)
# sets the volume to 20% (change value to adjust)
pygame.mixer.music.set_volume(0.2)
# Define the global variables at the module level
inventory = []
balance = 300
emails = []
has_read_email = False
has_read_file = False
has_intro_call = False
seen_markus = False
evidence = []
amy_system = AmySystem()
billy_system = BillySystem()
markus_system = MarkusSystem()
bg_music_enabled = True
player_level = 1
has_started_game = False
# Save the game state to a file
def save_game():
global inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus
with open('savegame.pkl', 'wb') as f:
pickle.dump(
(inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus),
f)
# Load the game state from a file
def load_game():
global inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus
if os.path.exists('savegame.pkl'):
with open('savegame.pkl', 'rb') as f:
inventory, balance, emails, has_read_email, evidence, player_level, has_intro_call, has_started_game, seen_markus = pickle.load(
f)
else:
# If the savegame file doesn't exist, set the default values
inventory = []
player_level = 1
evidence = []
has_intro_call = False
has_started_game = False
seen_markus = False
balance = 30000
emails = [
{
"sender": "Hacker's Digest",
"subject": "Weekly Hacker's Digest",
"body": (
"Issue #143\n\n"
"Cipher,\n\n"
"Welcome to the latest edition of Hacker's Digest! In this issue: \n\n"
"- Unveiling the Latest Exploits\n"
"- Spotlight on Cryptocurrency Security\n"
"- Interview with a Grey Hat Hacker\n"
"- Tool of the Week: EnigmaLink\n\n"
"Don't miss out on the latest in the world of hacking and cybersecurity. Stay informed and stay secure!\n\n"
"Best regards,\n"
"Hacker's Digest Team"
)
},
{
"sender": "The Cyber Mythbuster",
"subject": "Busting Cybersecurity Myths",
"body": (
"Cipher,\n\n"
"Heard any wild cybersecurity myths lately? This week, we're busting the craziest ones, including:\n\n"
"- Using 'Password123' for Maximum Security\n"
"- Cyber Ninjas and Their Stealthy VPNs\n"
"- USB Drives: The Fountain of Eternal Data\n\n"
"Stay myth-free and keep on hacking (responsibly)!\n\n"
"Mythbustingly,\n"
"The Cyber Mythbuster"
)
},
{
"sender": "CyberSilliness",
"subject": "Where Cyber Meets Comedy",
"body": (
"Welcome to the CyberSilliness Gazette\n"
"Where we believe that a good laugh is the ultimate antivirus! In this week's hilarity-packed issue:\n\n"
"- Cyber Jokes to Crack You Up (Without Cracking Your Passwords)\n"
"- Tech Support Horror Stories: A Comedy of Errors\n"
"- Chuckle Challenge: Share Your Funniest Cybersecurity Anecdote\n"
"- Meet the Cyber Clowns: Our Team's Silly Security Habits Revealed\n\n"
"Laughter is contagious, and so is good cybersecurity. Dive into the giggles and stay safe!\n\n"
"Silly Regards,\n"
"The CyberSilliness Team"
)
},
{
"sender": "Security Insight Weekly",
"subject": "Navigating the Cybersecurity Landscape",
"body": (
"Hello Cipher,\n\n"
"Welcome to Security Insight Weekly, your reliable source for navigating the ever-evolving cybersecurity landscape. In this week's issue:\n\n"
"- Threat Analysis: Understanding Recent Cybersecurity Incidents\n"
"- Best Practices for Endpoint Security\n"
"- Industry Spotlight: Healthcare Cybersecurity Challenges\n"
"- Security Compliance Update: Staying Aligned with Regulations\n\n"
"Stay informed and empowered as we delve into the serious aspects of cybersecurity. Your security is our priority.\n\n"
"Best regards,\n"
"The Security Insight Team"
)
},
]
# New function for game settings
def game_settings():
global bg_music_enabled
print_slow(Fore.GREEN + "░██████╗███████╗████████╗████████╗██╗███╗░░██╗░██████╗░░██████╗")
print_slow(Fore.GREEN + "██╔════╝██╔════╝╚══██╔══╝╚══██╔══╝██║████╗░██║██╔════╝░██╔════╝")
print_slow(Fore.GREEN + "╚█████╗░█████╗░░░░░██║░░░░░░██║░░░██║██╔██╗██║██║░░██╗░╚█████╗░")
print_slow(Fore.GREEN + "░╚═══██╗██╔══╝░░░░░██║░░░░░░██║░░░██║██║╚████║██║░░╚██╗░╚═══██╗")
print_slow(Fore.GREEN + "██████╔╝███████╗░░░██║░░░░░░██║░░░██║██║░╚███║╚██████╔╝██████╔╝")
print_slow(Fore.GREEN + "╚═════╝░╚══════╝░░░╚═╝░░░░░░╚═╝░░░╚═╝╚═╝░░╚══╝░╚═════╝░╚═════╝░" + Style.RESET_ALL)
print_slow("")
print_slow("")
print_slow("")
print_slow(Fore.GREEN + " --------------------------------------------" + Style.RESET_ALL)
print_slow(
Fore.GREEN + f"| [Background Music] {'Enabled |' if bg_music_enabled else 'Disabled |'}" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| [Delete Savegame] |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| |" + Style.RESET_ALL)
print_slow(Fore.GREEN + "| [Back to Main Menu] |" + Style.RESET_ALL)
print_slow(Fore.GREEN + " --------------------------------------------" + Style.RESET_ALL)
choice = input(Fore.GREEN + "\n> " + Style.RESET_ALL)
if choice.lower() == "background music":
# Toggle background music
bg_music_enabled = not bg_music_enabled
if bg_music_enabled:
pygame.mixer.music.play(-1)
print_slow(Fore.GREEN + "\nBackground Music Enabled" + Style.RESET_ALL)
time.sleep(1) | clear_terminal() | 0 | 2023-11-06 09:52:13+00:00 | 24k |
ziqi-zhang/TAOISM | python/test/test_conv.py | [
{
"identifier": "register_layer",
"path": "python/common_net.py",
"snippet": "def register_layer(layer, name):\n layer.register_forward_hook(hooking_layer(name))\n layer.register_backward_hook(hooking_layer_backward(name))\n layer_names.append(name)"
},
{
"identifier": "register_weight_... | import os
import sys
import numpy as np
import torch
import torch.distributed as dist
import sys
import pdb
from pdb import set_trace as st
from torch import optim, nn
from python.common_net import register_layer, register_weight_layer, get_layer_weight, get_layer_input, \
get_layer_weight_grad, get_layer_output, get_layer_output_grad, get_layer_input_grad
from python.enclave_interfaces import GlobalTensor
from python.layers.batch_norm_2d import SecretBatchNorm2dLayer
from python.layers.flatten import SecretFlattenLayer
from python.layers.input import SecretInputLayer
from python.layers.maxpool2d import SecretMaxpool2dLayer
from python.layers.output import SecretOutputLayer
from python.layers.relu import SecretReLULayer
from python.sgx_net import init_communicate, warming_up_cuda, SecretNeuralNetwork, SgdOptimizer
from python.layers.sgx_linear_base import SGXLinearBase
from python.layers.sgx_conv_base import SGXConvBase
from python.utils.basic_utils import ExecutionModeOptions
from python.utils.logger_utils import Logger
from python.quantize_net import NetQ
from python.test_sgx_net import argparser_distributed, marshal_process, load_cifar10, seed_torch
from python.utils.timer_utils import NamedTimerInstance, VerboseLevel, NamedTimer
from python.utils.torch_utils import compare_expected_actual
from pdb import set_trace as st | 21,043 |
device_cuda = torch.device("cuda:0")
torch.set_printoptions(precision=10)
def compare_layer_member(layer: SGXLinearBase, layer_name: str,
extract_func , member_name: str, save_path=None) -> None:
print(member_name)
layer.make_sure_cpu_is_latest(member_name)
compare_expected_actual(extract_func(layer_name), layer.get_cpu(member_name), get_relative=True, verbose=True)
if save_path is not None:
if not os.path.exists(save_path):
os.makedirs(save_path)
print("Directory ", save_path, " Created ")
else:
print("Directory ", save_path, " already exists")
torch.save(extract_func(layer_name), os.path.join(save_path, member_name + "_expected"))
torch.save(layer.get_cpu(member_name), os.path.join(save_path, member_name + "_actual"))
def compare_layer(layer: SGXLinearBase, layer_name: str, save_path=None) -> None:
print("comparing with layer in expected NN :", layer_name)
|
device_cuda = torch.device("cuda:0")
torch.set_printoptions(precision=10)
def compare_layer_member(layer: SGXLinearBase, layer_name: str,
extract_func , member_name: str, save_path=None) -> None:
print(member_name)
layer.make_sure_cpu_is_latest(member_name)
compare_expected_actual(extract_func(layer_name), layer.get_cpu(member_name), get_relative=True, verbose=True)
if save_path is not None:
if not os.path.exists(save_path):
os.makedirs(save_path)
print("Directory ", save_path, " Created ")
else:
print("Directory ", save_path, " already exists")
torch.save(extract_func(layer_name), os.path.join(save_path, member_name + "_expected"))
torch.save(layer.get_cpu(member_name), os.path.join(save_path, member_name + "_actual"))
def compare_layer(layer: SGXLinearBase, layer_name: str, save_path=None) -> None:
print("comparing with layer in expected NN :", layer_name) | compare_name_function = [("input", get_layer_input), ("output", get_layer_output), | 3 | 2023-11-01 10:37:37+00:00 | 24k |
Codra-Ingenierie-Informatique/DataLab | cdl/core/gui/panel/signal.py | [
{
"identifier": "_",
"path": "cdl/config.py",
"snippet": "CONF_VERSION = \"1.0.0\"\nAPP_NAME = \"DataLab\"\nMOD_NAME = \"cdl\"\nAPP_DESC = _(\"\"\"DataLab is a generic signal and image processing platform\"\"\")\nAPP_PATH = osp.dirname(__file__)\nDEBUG = os.environ.get(\"DEBUG\", \"\").lower() in (\"1\"... | from typing import TYPE_CHECKING
from plotpy.tools import (
HCursorTool,
HRangeTool,
LabelTool,
RectangleTool,
SegmentTool,
VCursorTool,
XCursorTool,
)
from cdl.config import _
from cdl.core.gui import roieditor
from cdl.core.gui.actionhandler import SignalActionHandler
from cdl.core.gui.panel.base import BaseDataPanel
from cdl.core.gui.plothandler import SignalPlotHandler
from cdl.core.gui.processor.signal import SignalProcessor
from cdl.core.io.signal import SignalIORegistry
from cdl.core.model.signal import SignalObj, create_signal_from_param, new_signal_param
from plotpy.plot import PlotWidget
from qtpy import QtWidgets as QW
from cdl.core.model.signal import NewSignalParam
import guidata.dataset as gds | 19,399 | # -*- coding: utf-8 -*-
#
# Licensed under the terms of the BSD 3-Clause
# (see cdl/LICENSE for details)
"""DataLab Signal Panel"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
if TYPE_CHECKING: # pragma: no cover
class SignalPanel(BaseDataPanel):
"""Object handling the item list, the selected item properties and plot,
specialized for Signal objects"""
PANEL_STR = _("Signal panel")
PARAMCLASS = SignalObj
ANNOTATION_TOOLS = (
LabelTool,
VCursorTool,
HCursorTool,
XCursorTool,
SegmentTool,
RectangleTool,
HRangeTool,
)
| # -*- coding: utf-8 -*-
#
# Licensed under the terms of the BSD 3-Clause
# (see cdl/LICENSE for details)
"""DataLab Signal Panel"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
if TYPE_CHECKING: # pragma: no cover
class SignalPanel(BaseDataPanel):
"""Object handling the item list, the selected item properties and plot,
specialized for Signal objects"""
PANEL_STR = _("Signal panel")
PARAMCLASS = SignalObj
ANNOTATION_TOOLS = (
LabelTool,
VCursorTool,
HCursorTool,
XCursorTool,
SegmentTool,
RectangleTool,
HRangeTool,
) | IO_REGISTRY = SignalIORegistry | 6 | 2023-11-09 16:56:03+00:00 | 24k |
ingra14m/Tensor4D-DNeRF | exp_runner.py | [
{
"identifier": "Dataset",
"path": "models/dataset.py",
"snippet": "class Dataset:\n def __init__(self, conf):\n super(Dataset, self).__init__()\n print('Load data: Begin')\n self.device = torch.device('cuda')\n self.conf = conf\n\n self.data_dir = conf.get_string('... | import os
import time
import logging
import argparse
import numpy as np
import cv2 as cv
import torch
import torch.nn.functional as F
from torch.utils.tensorboard import SummaryWriter
from shutil import copyfile
from tqdm import tqdm
from pyhocon import ConfigFactory
from models.dataset import Dataset, BlenderDataset
from models.fields import RenderingNetwork, FieldNetwork, SingleVarianceNetwork
from models.tensor4d import Tensor4D
from models.renderer import NeuSRenderer
from models.mask import Mask3D
from metrics import * | 16,196 | os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
class Runner:
def __init__(self, conf_path, mode='train', case='CASE_NAME', is_continue=False):
self.device = torch.device('cuda')
# Configuration
self.conf_path = conf_path
f = open(self.conf_path)
conf_text = f.read()
conf_text = conf_text.replace('CASE_NAME', case)
f.close()
self.conf = ConfigFactory.parse_string(conf_text)
self.conf['dataset.data_dir'] = self.conf['dataset.data_dir'].replace('CASE_NAME', case)
self.base_exp_dir = self.conf['general.base_exp_dir']
os.makedirs(self.base_exp_dir, exist_ok=True)
self.is_blender = self.conf['dataset'].get_bool('is_blender', default=False)
self.dataset = BlenderDataset(self.conf['dataset']) if self.is_blender else Dataset(self.conf['dataset'])
self.g_nums = self.conf['dataset']['g_nums']
self.iter_step = 0
self.flow = self.conf.get_bool('model.flow', default=False)
# Training parameters
self.end_iter = self.conf.get_int('train.end_iter')
self.save_freq = self.conf.get_int('train.save_freq')
self.report_freq = self.conf.get_int('train.report_freq')
self.val_freq = self.conf.get_int('train.val_freq')
self.batch_size = self.conf.get_int('train.batch_size')
self.fine_level_iter = self.conf.get_int('train.fine_level_iter')
self.downsample_iter = self.conf.get_int('train.downsample_iter')
self.validate_resolution_level = self.conf.get_int('train.validate_resolution_level')
self.learning_rate = self.conf.get_float('train.learning_rate')
self.learning_rate_alpha = self.conf.get_float('train.learning_rate_alpha')
self.use_white_bkgd = self.conf.get_bool('train.use_white_bkgd')
self.warm_up_end = self.conf.get_float('train.warm_up_end', default=0.0)
self.warm_up_imgs = self.conf.get_int('train.warm_up_imgs', default=50)
self.anneal_end = self.conf.get_float('train.anneal_end', default=0.0)
self.mask_color_loss = self.conf.get_bool('train.mask_color_loss')
self.weighted_sample = self.conf.get_bool('train.weighted_sample')
# Weights
self.igr_weight = self.conf.get_float('train.igr_weight')
self.tgr_weight = self.conf.get_float('train.tgr_weight')
self.mask_weight = self.conf.get_float('train.mask_weight')
self.tv_weight = self.conf.get_float('train.tv_weight')
if self.tv_weight > 0:
self.reg_l2 = True
else:
self.reg_l2 = False
self.is_continue = is_continue
self.mode = mode
self.model_list = []
self.writer = None
# Masks
self.mask3d = Mask3D(**self.conf['model.mask3d'], num_frames=self.dataset.n_images // self.g_nums, device=self.device)
# Networks
self.tensor4d = Tensor4D(**self.conf['model.tensor4d']).to(self.device)
| os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
class Runner:
def __init__(self, conf_path, mode='train', case='CASE_NAME', is_continue=False):
self.device = torch.device('cuda')
# Configuration
self.conf_path = conf_path
f = open(self.conf_path)
conf_text = f.read()
conf_text = conf_text.replace('CASE_NAME', case)
f.close()
self.conf = ConfigFactory.parse_string(conf_text)
self.conf['dataset.data_dir'] = self.conf['dataset.data_dir'].replace('CASE_NAME', case)
self.base_exp_dir = self.conf['general.base_exp_dir']
os.makedirs(self.base_exp_dir, exist_ok=True)
self.is_blender = self.conf['dataset'].get_bool('is_blender', default=False)
self.dataset = BlenderDataset(self.conf['dataset']) if self.is_blender else Dataset(self.conf['dataset'])
self.g_nums = self.conf['dataset']['g_nums']
self.iter_step = 0
self.flow = self.conf.get_bool('model.flow', default=False)
# Training parameters
self.end_iter = self.conf.get_int('train.end_iter')
self.save_freq = self.conf.get_int('train.save_freq')
self.report_freq = self.conf.get_int('train.report_freq')
self.val_freq = self.conf.get_int('train.val_freq')
self.batch_size = self.conf.get_int('train.batch_size')
self.fine_level_iter = self.conf.get_int('train.fine_level_iter')
self.downsample_iter = self.conf.get_int('train.downsample_iter')
self.validate_resolution_level = self.conf.get_int('train.validate_resolution_level')
self.learning_rate = self.conf.get_float('train.learning_rate')
self.learning_rate_alpha = self.conf.get_float('train.learning_rate_alpha')
self.use_white_bkgd = self.conf.get_bool('train.use_white_bkgd')
self.warm_up_end = self.conf.get_float('train.warm_up_end', default=0.0)
self.warm_up_imgs = self.conf.get_int('train.warm_up_imgs', default=50)
self.anneal_end = self.conf.get_float('train.anneal_end', default=0.0)
self.mask_color_loss = self.conf.get_bool('train.mask_color_loss')
self.weighted_sample = self.conf.get_bool('train.weighted_sample')
# Weights
self.igr_weight = self.conf.get_float('train.igr_weight')
self.tgr_weight = self.conf.get_float('train.tgr_weight')
self.mask_weight = self.conf.get_float('train.mask_weight')
self.tv_weight = self.conf.get_float('train.tv_weight')
if self.tv_weight > 0:
self.reg_l2 = True
else:
self.reg_l2 = False
self.is_continue = is_continue
self.mode = mode
self.model_list = []
self.writer = None
# Masks
self.mask3d = Mask3D(**self.conf['model.mask3d'], num_frames=self.dataset.n_images // self.g_nums, device=self.device)
# Networks
self.tensor4d = Tensor4D(**self.conf['model.tensor4d']).to(self.device) | self.sdf_network = FieldNetwork(d_t4d=self.tensor4d.dims, **self.conf['model.sdf_network']).to(self.device) | 3 | 2023-11-07 10:16:33+00:00 | 24k |
Kushalhk/AutoFilter | utils.py | [
{
"identifier": "AUTH_CHANNEL",
"path": "info.py",
"snippet": "AUTH_CHANNEL = int(auth_channel) if auth_channel and id_pattern.search(auth_channel) else None"
},
{
"identifier": "LONG_IMDB_DESCRIPTION",
"path": "info.py",
"snippet": "LONG_IMDB_DESCRIPTION = is_enabled(environ.get(\"LONG_... | import logging
import asyncio
import pytz
import random
import re
import os
import string
import requests
import aiohttp
import http.client
import json
from pyrogram.errors import InputUserDeactivated, UserNotParticipant, FloodWait, UserIsBlocked, PeerIdInvalid
from info import AUTH_CHANNEL, LONG_IMDB_DESCRIPTION, MAX_LIST_ELM, SHORTLINK_URL, SHORTLINK_API, IS_SHORTLINK, LOG_CHANNEL, TUTORIAL, GRP_LNK, CHNL_LNK, CUSTOM_FILE_CAPTION, SECOND_SHORTLINK_URL, SECOND_SHORTLINK_API
from imdb import Cinemagoer
from pyrogram.types import Message, InlineKeyboardButton, InlineKeyboardMarkup
from pyrogram.errors import FloodWait, UserIsBlocked, MessageNotModified, PeerIdInvalid
from pyrogram import enums
from typing import Union
from Script import script
from datetime import datetime, date
from typing import List
from database.users_chats_db import db
from bs4 import BeautifulSoup
from shortzy import Shortzy | 19,308 |
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
BTN_URL_REGEX = re.compile(
r"(\[([^\[]+?)\]\((buttonurl|buttonalert):(?:/{0,2})(.+?)(:same)?\))"
)
imdb = Cinemagoer()
TOKENS = {}
VERIFIED = {}
BANNED = {}
SECOND_SHORTENER = {}
SMART_OPEN = '“'
SMART_CLOSE = '”'
START_CHAR = ('\'', '"', SMART_OPEN)
# temp db for banned
class temp(object):
BANNED_USERS = []
BANNED_CHATS = []
ME = None
CURRENT=int(os.environ.get("SKIP", 2))
CANCEL = False
MELCOW = {}
U_NAME = None
B_NAME = None
GETALL = {}
SHORT = {}
SETTINGS = {}
async def is_subscribed(bot, query):
try:
|
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
BTN_URL_REGEX = re.compile(
r"(\[([^\[]+?)\]\((buttonurl|buttonalert):(?:/{0,2})(.+?)(:same)?\))"
)
imdb = Cinemagoer()
TOKENS = {}
VERIFIED = {}
BANNED = {}
SECOND_SHORTENER = {}
SMART_OPEN = '“'
SMART_CLOSE = '”'
START_CHAR = ('\'', '"', SMART_OPEN)
# temp db for banned
class temp(object):
BANNED_USERS = []
BANNED_CHATS = []
ME = None
CURRENT=int(os.environ.get("SKIP", 2))
CANCEL = False
MELCOW = {}
U_NAME = None
B_NAME = None
GETALL = {}
SHORT = {}
SETTINGS = {}
async def is_subscribed(bot, query):
try: | user = await bot.get_chat_member(AUTH_CHANNEL, query.from_user.id) | 0 | 2023-11-03 12:21:26+00:00 | 24k |
apple/ml-reed | reed/algorithms/pebble.py | [
{
"identifier": "utils",
"path": "BPref/utils.py",
"snippet": "def make_env(cfg):\ndef ppo_make_env(env_id, seed):\ndef tie_weights(src, trg):\ndef make_metaworld_env(cfg):\ndef ppo_make_metaworld_env(env_id, seed):\n def __init__(self, *models):\n def __enter__(self):\n def __exit__(self, *arg... | import typing as t
import time
import numpy as np
import torch
import hydra
from pathlib import Path
from omegaconf import dictconfig, OmegaConf
from BPref import utils
from BPref.logger import Logger
from BPref.replay_buffer import TrajectoryReplayBuffer
from collections import deque
from reed.models.reward_model import StateActionRewardModel
from reed.data.preference_dataset import PreferenceDataset
from reed.data.preference_data_loader import PreferenceTripletEnsembleDataLoader
from reed.data.preprocess_images import PreProcessInference | 21,223 | Returns:
the dimensionality of reward's observation space
"""
if self.experiment_config.reward_from_image_observations:
# get a sample image rendering of the environment and get its shape
self.env.reset()
if "metaworld" in self.experiment_config.env:
start_time = time.time()
img_obs = self.env.render(camera_name=self.experiment_config.camera_name,
resolution=(
self.experiment_config.image_height, self.experiment_config.image_width))
end_time = time.time()
print(f"Sample render time for metaworld is {end_time - start_time} seconds")
else:
start_time = time.time()
img_obs = self.env.render(mode="rgb_array",
height=self.experiment_config.image_height,
width=self.experiment_config.image_width)
end_time = time.time()
print(f"Sample render time for DMC is {end_time - start_time} seconds")
observation_space = img_obs.shape
print("--------------------------")
print("--------------------------")
print("--------------------------")
print("image observation shape", observation_space)
print("--------------------------")
print("--------------------------")
print("--------------------------")
else:
observation_space = self.env.observation_space.shape[0]
return observation_space
def _render_image_observation(self) -> np.ndarray:
"""
Render the current image observation
"""
if "metaworld" in self.experiment_config.env:
img_obs = self.env.render(camera_name=self.experiment_config.camera_name,
resolution=(
self.experiment_config.image_height, self.experiment_config.image_width))
else:
img_obs = self.env.render(mode="rgb_array",
height=self.experiment_config.image_height,
width=self.experiment_config.image_width)
return img_obs
def construct_reward_ensemble(self) -> StateActionRewardModel:
"""
Create the reward ensemble as specified in the experiment config.
"""
return StateActionRewardModel(
in_dim=self.reward_in_dim,
ensemble_size=self.experiment_config.ensemble_size,
hidden_dim=self.experiment_config.reward_hidden_embed_dim,
hidden_layers=self.experiment_config.reward_num_hidden_layers,
final_activation=self.experiment_config.activation,
lr=self.experiment_config.reward_lr,
reward_train_batch=self.experiment_config.reward_train_batch,
size_segment=self.experiment_config.segment_size,
device=self.device,
multi_gpu=self.multi_gpu,
image_observations=self.experiment_config.reward_from_image_observations,
image_encoder_architecture=self.experiment_config.image_encoder_architecture,
image_hidden_num_channels=self.experiment_config.image_hidden_num_channels,
grayscale_images=self.experiment_config.grayscale_images
)
def evaluate(self):
average_episode_reward = 0
average_true_episode_reward = 0
success_rate = 0
for episode in range(self.experiment_config.num_eval_episodes):
obs = self.env.reset()
self.agent.reset()
done = False
episode_reward = 0
true_episode_reward = 0
if self.log_success:
episode_success = 0
while not done:
with utils.eval_mode(self.agent):
action = self.agent.act(obs, sample=False)
obs, reward, done, extra = self.env.step(action)
episode_reward += reward
true_episode_reward += reward
if self.log_success:
episode_success = max(episode_success, extra['success'])
average_episode_reward += episode_reward
average_true_episode_reward += true_episode_reward
if self.log_success:
success_rate += episode_success
average_episode_reward /= self.experiment_config.num_eval_episodes
average_true_episode_reward /= self.experiment_config.num_eval_episodes
if self.log_success:
success_rate /= self.experiment_config.num_eval_episodes
success_rate *= 100.0
self.logger.log('eval/episode_reward', average_episode_reward,
self.step)
self.logger.log('eval/true_episode_reward', average_true_episode_reward,
self.step)
if self.log_success:
self.logger.log('eval/success_rate', success_rate, self.step)
self.logger.log('train/true_episode_success', success_rate, self.step)
self.logger.dump(self.step)
def train_reward_on_preferences(self) -> t.Optional[float]:
"""
Update the reward model on the current preference dataset
Returns:
train accuracy on the current reward model update round, if the preference dataset contains samples
"""
# create the data loader that will be used to train the reward model
| #
# For licensing see accompanying LICENSE file.
# Copyright (C) 2023 Apple Inc. All Rights Reserved.
#
class PEBBLE:
"""
Train a reward model in conjunction with policy training following the PEBBLE algorithm from (Lee et al. 2021)
"""
def __init__(self, experiment_config: dictconfig.DictConfig):
"""
Args:
experiment_config: contains the configuration for the experiment to be run. Access like a dictionry
"""
# track the experimental configuration
self.experiment_config = experiment_config
# create the logger to track policy learning progress
self.logger = Logger(
self.experiment_config.out_dir,
save_tb=self.experiment_config.log_save_tb,
log_frequency=self.experiment_config.log_frequency,
agent=self.experiment_config.agent.name)
# used to track where we are in training
# total amount of feedback the reward model has solicited
self.total_feedback = 0
# total amount of feedback given to the reward model
self.labeled_feedback = 0
# policy train step
self.step = 0
# we need to set the random seed for replication purposes
utils.set_seed_everywhere(self.experiment_config.seed)
# the device on which models will be trained
self.device = torch.device(self.experiment_config.device)
# flag to make sure we are handling multi-gpu training where we need to
self.multi_gpu = torch.cuda.device_count() > 1
print("----------------------------------------")
print("----------------------------------------")
print("----------------------------------------")
print("----------------------------------------")
print(f"There is {torch.cuda.device_count()} GPU, so models will be trained with torch.nn.DataParallel.")
print("----------------------------------------")
print("----------------------------------------")
print("----------------------------------------")
print("----------------------------------------")
# make the environment
if 'metaworld' in self.experiment_config.env:
self.env = utils.make_metaworld_env(self.experiment_config)
# we are not evaluating a domain where we need to log whether an agent has reached a goal state
self.log_success = True
else:
self.env = utils.make_env(self.experiment_config)
# we are not evaluating a domain where we need to log whether an agent has reached a goal state
self.log_success = False
print('----------------------')
print('----------------------')
print('----------------------')
print('----------------------')
print("observation space ", self.env.observation_space.shape[0])
print("action space ", self.env.action_space.shape[0])
print('----------------------')
print('----------------------')
print('----------------------')
print('----------------------')
# we need to set the policy's observation and action space
self.experiment_config.agent.params.obs_dim = self.env.observation_space.shape[0]
self.experiment_config.agent.params.action_dim = self.env.action_space.shape[0]
self.experiment_config.agent.params.action_range = [
float(self.env.action_space.low.min()),
float(self.env.action_space.high.max())
]
# create the agent specified in the configuration
self.agent = hydra.utils.instantiate(self.experiment_config.agent)
# the class that will format the observations and observation action pairs for consumption by the reward model
self._reward_input_preprocessor = PreProcessInference(
image_observations=self.experiment_config.reward_from_image_observations,
grayscale_images=self.experiment_config.grayscale_images,
normalize_images=self.experiment_config.normalized_images)
# determine the reward's observation space
# if the reward is trained on images then the reward's observation space differs from the policy's, which is
# trained on the state space
self._observation_dimensionality = self._determine_observation_dimensions()
self._reward_observation_dimensionality = self._determine_reward_observation_dimensions()
# create the agent's replay buffer setting if image observations will need to be tracked
self.replay_buffer = TrajectoryReplayBuffer(
int(self.experiment_config.replay_buffer_capacity),
self.device,
image_observations=(self._observation_dimensionality
if (self.experiment_config.reward_from_image_observations
or self.experiment_config.save_image_observations)
else None)
)
# determine the dimensionality of the input to the reward function
self.reward_in_dim = self._determine_reward_input_dimensions(
observation_dim=self._reward_observation_dimensionality,
action_dim=self.env.action_space.shape[0])
# instantiating the reward model
self.reward_model = self.construct_reward_ensemble()
# create the preference dataset that will solicit and hold labelled preference triplets
self.preference_dataset = PreferenceDataset(
observation_dim=self._reward_observation_dimensionality,
action_dim=self.env.action_space.shape[0],
capacity=self.experiment_config.preference_dataset_capacity,
size_segment=self.experiment_config.segment_size,
out_path=Path("/tmp/preference_dataset/"),
image_observations=self.experiment_config.reward_from_image_observations,
state_action_formatter=self._reward_input_preprocessor,
grayscale_images=self.experiment_config.grayscale_images,
collect_image_pref_dataset=self.experiment_config.save_image_observations,
teacher_beta=self.experiment_config.teacher_beta,
teacher_gamma=self.experiment_config.teacher_gamma,
teacher_eps_mistake=self.experiment_config.teacher_eps_mistake,
teacher_eps_skip=self.experiment_config.teacher_eps_skip,
teacher_eps_equal=self.experiment_config.teacher_eps_equal
)
# save the experimental configuration
with open(Path(self.experiment_config.out_dir) / "experiment_config.yaml", "w+") as f:
OmegaConf.save(config=self.experiment_config, f=f)
def _determine_reward_input_dimensions(self,
observation_dim: t.Union[int, np.ndarray],
action_dim: int) -> t.Union[int, t.Sequence]:
"""
Determine the dimensionality of the inputs to the reward model
Args:
observation_dim: the dimensionality of agent observations. If the observation is an image, the
dimensionality should have the following order: (num_channels, height, width)
action_dim: the dimensionality of agent actions
Returns:
the dimensionality of the reward model's inputs
"""
# compute the dimensions of the input to the reward function
if not self.experiment_config.reward_from_image_observations:
return observation_dim + action_dim
else:
# we need to concatenate the actions to last dimension of the image
# the input to the reward net also needs to have the channels first
# the image dimensions are given to us a (height, width, channels)
sample_shape = list(observation_dim)
if self.experiment_config.grayscale_images:
num_channels = action_dim + 1
else:
num_channels = sample_shape[0] + action_dim
# update the number of channels
sample_shape[0] = num_channels
# the dimensions of the input to the reward model
return sample_shape
def _determine_reward_observation_dimensions(self) -> t.Union[int, np.ndarray]:
"""
Check if the reward will use the image observations.
If so the reward input shape needs to be set accordingly
Returns:
the dimensionality of reward's observation space
"""
if self.experiment_config.reward_from_image_observations:
# get a sample image rendering of the environment and get its shape
self.env.reset()
if "metaworld" in self.experiment_config.env:
start_time = time.time()
img_obs = self.env.render(camera_name=self.experiment_config.camera_name,
resolution=(
self.experiment_config.image_height, self.experiment_config.image_width))
end_time = time.time()
print(f"Sample render time for metaworld is {end_time - start_time} seconds")
else:
start_time = time.time()
img_obs = self.env.render(mode="rgb_array",
height=self.experiment_config.image_height,
width=self.experiment_config.image_width)
end_time = time.time()
print(f"Sample render time for DMC is {end_time - start_time} seconds")
formatted_image_observation = self._reward_input_preprocessor.format_state(img_obs).squeeze(axis=0)
observation_space = formatted_image_observation.shape
print("--------------------------")
print("--------------------------")
print("--------------------------")
print("image observation shape", observation_space)
print("--------------------------")
print("--------------------------")
print("--------------------------")
else:
observation_space = self.env.observation_space.shape[0]
return observation_space
def _determine_observation_dimensions(self) -> t.Union[int, np.ndarray]:
"""
Check if the reward will use the image observations.
If so the replay buffer needs to be set up to
accumulate the image observations
Returns:
the dimensionality of reward's observation space
"""
if self.experiment_config.reward_from_image_observations:
# get a sample image rendering of the environment and get its shape
self.env.reset()
if "metaworld" in self.experiment_config.env:
start_time = time.time()
img_obs = self.env.render(camera_name=self.experiment_config.camera_name,
resolution=(
self.experiment_config.image_height, self.experiment_config.image_width))
end_time = time.time()
print(f"Sample render time for metaworld is {end_time - start_time} seconds")
else:
start_time = time.time()
img_obs = self.env.render(mode="rgb_array",
height=self.experiment_config.image_height,
width=self.experiment_config.image_width)
end_time = time.time()
print(f"Sample render time for DMC is {end_time - start_time} seconds")
observation_space = img_obs.shape
print("--------------------------")
print("--------------------------")
print("--------------------------")
print("image observation shape", observation_space)
print("--------------------------")
print("--------------------------")
print("--------------------------")
else:
observation_space = self.env.observation_space.shape[0]
return observation_space
def _render_image_observation(self) -> np.ndarray:
"""
Render the current image observation
"""
if "metaworld" in self.experiment_config.env:
img_obs = self.env.render(camera_name=self.experiment_config.camera_name,
resolution=(
self.experiment_config.image_height, self.experiment_config.image_width))
else:
img_obs = self.env.render(mode="rgb_array",
height=self.experiment_config.image_height,
width=self.experiment_config.image_width)
return img_obs
def construct_reward_ensemble(self) -> StateActionRewardModel:
"""
Create the reward ensemble as specified in the experiment config.
"""
return StateActionRewardModel(
in_dim=self.reward_in_dim,
ensemble_size=self.experiment_config.ensemble_size,
hidden_dim=self.experiment_config.reward_hidden_embed_dim,
hidden_layers=self.experiment_config.reward_num_hidden_layers,
final_activation=self.experiment_config.activation,
lr=self.experiment_config.reward_lr,
reward_train_batch=self.experiment_config.reward_train_batch,
size_segment=self.experiment_config.segment_size,
device=self.device,
multi_gpu=self.multi_gpu,
image_observations=self.experiment_config.reward_from_image_observations,
image_encoder_architecture=self.experiment_config.image_encoder_architecture,
image_hidden_num_channels=self.experiment_config.image_hidden_num_channels,
grayscale_images=self.experiment_config.grayscale_images
)
def evaluate(self):
average_episode_reward = 0
average_true_episode_reward = 0
success_rate = 0
for episode in range(self.experiment_config.num_eval_episodes):
obs = self.env.reset()
self.agent.reset()
done = False
episode_reward = 0
true_episode_reward = 0
if self.log_success:
episode_success = 0
while not done:
with utils.eval_mode(self.agent):
action = self.agent.act(obs, sample=False)
obs, reward, done, extra = self.env.step(action)
episode_reward += reward
true_episode_reward += reward
if self.log_success:
episode_success = max(episode_success, extra['success'])
average_episode_reward += episode_reward
average_true_episode_reward += true_episode_reward
if self.log_success:
success_rate += episode_success
average_episode_reward /= self.experiment_config.num_eval_episodes
average_true_episode_reward /= self.experiment_config.num_eval_episodes
if self.log_success:
success_rate /= self.experiment_config.num_eval_episodes
success_rate *= 100.0
self.logger.log('eval/episode_reward', average_episode_reward,
self.step)
self.logger.log('eval/true_episode_reward', average_true_episode_reward,
self.step)
if self.log_success:
self.logger.log('eval/success_rate', success_rate, self.step)
self.logger.log('train/true_episode_success', success_rate, self.step)
self.logger.dump(self.step)
def train_reward_on_preferences(self) -> t.Optional[float]:
"""
Update the reward model on the current preference dataset
Returns:
train accuracy on the current reward model update round, if the preference dataset contains samples
"""
# create the data loader that will be used to train the reward model | preference_data_loader = PreferenceTripletEnsembleDataLoader( | 5 | 2023-11-06 23:14:20+00:00 | 24k |
alibaba/animate-anything | train.py | [
{
"identifier": "VideoJsonDataset",
"path": "utils/dataset.py",
"snippet": "class VideoJsonDataset(Dataset):\n def __init__(\n self,\n tokenizer=None,\n width: int = 256,\n height: int = 256,\n n_sample_frames: int = 16,\n fps: int = 8,\n video_dir: st... | import argparse
import datetime
import logging
import inspect
import math
import os
import json
import gc
import copy
import random
import cv2
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
import torchvision.transforms as T
import diffusers
import transformers
import numpy as np
import imageio
import itertools
import bitsandbytes as bnb
from typing import Dict, Optional, Tuple
from omegaconf import OmegaConf
from tqdm.auto import tqdm
from PIL import Image
from accelerate import Accelerator
from accelerate.logging import get_logger
from accelerate.utils import set_seed
from diffusers.models import AutoencoderKL
from diffusers import DPMSolverMultistepScheduler, DDPMScheduler
from diffusers.image_processor import VaeImageProcessor
from diffusers.optimization import get_scheduler
from diffusers.utils import check_min_version, export_to_video
from diffusers.utils.import_utils import is_xformers_available
from diffusers.models.attention_processor import AttnProcessor2_0, Attention
from diffusers.models.attention import BasicTransformerBlock
from diffusers.pipelines.text_to_video_synthesis.pipeline_text_to_video_synth import tensor2vid
from transformers import CLIPTextModel, CLIPTokenizer
from transformers.models.clip.modeling_clip import CLIPEncoder
from utils.dataset import VideoJsonDataset, SingleVideoDataset, \
ImageDataset, VideoFolderDataset, CachedDataset, VideoBLIPDataset
from einops import rearrange, repeat
from models.unet_3d_condition_mask import UNet3DConditionModel
from models.pipeline import LatentToVideoPipeline
from utils.lora_handler import LoraHandler, LORA_VERSIONS
from utils.common import read_mask, generate_random_mask, slerp, calculate_motion_score, \
read_video, calculate_motion_precision, calculate_latent_motion_score, \
DDPM_forward, DDPM_forward_timesteps, DDPM_forward_mask, motion_mask_loss, \
generate_center_mask, tensor_to_vae_latent
from xformers.ops import MemoryEfficientAttentionFlashAttentionOp | 19,661 | return {
"model": model,
"condition": condition,
'extra_params': extra_params,
'is_lora': is_lora,
"negation": negation
}
def create_optim_params(name='param', params=None, lr=5e-6, extra_params=None):
params = {
"name": name,
"params": params,
"lr": lr
}
if extra_params is not None:
for k, v in extra_params.items():
params[k] = v
return params
def negate_params(name, negation):
# We have to do this if we are co-training with LoRA.
# This ensures that parameter groups aren't duplicated.
if negation is None: return False
for n in negation:
if n in name and 'temp' not in name:
return True
return False
def create_optimizer_params(model_list, lr):
optimizer_params = []
for optim in model_list:
model, condition, extra_params, is_lora, negation = optim.values()
# Check if we are doing LoRA training.
if is_lora and condition and isinstance(model, list):
params = create_optim_params(
params=itertools.chain(*model),
extra_params=extra_params
)
optimizer_params.append(params)
continue
if is_lora and condition and not isinstance(model, list):
for n, p in model.named_parameters():
if 'lora' in n:
params = create_optim_params(n, p, lr, extra_params)
optimizer_params.append(params)
continue
# If this is true, we can train it.
if condition:
for n, p in model.named_parameters():
should_negate = 'lora' in n and not is_lora
if should_negate: continue
params = create_optim_params(n, p, lr, extra_params)
optimizer_params.append(params)
return optimizer_params
def get_optimizer(use_8bit_adam):
if use_8bit_adam:
try:
except ImportError:
raise ImportError(
"Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`"
)
return bnb.optim.AdamW8bit
else:
return torch.optim.AdamW
def is_mixed_precision(accelerator):
weight_dtype = torch.float32
if accelerator.mixed_precision == "fp16":
weight_dtype = torch.float16
elif accelerator.mixed_precision == "bf16":
weight_dtype = torch.bfloat16
return weight_dtype
def cast_to_gpu_and_type(model_list, device, weight_dtype):
for model in model_list:
if model is not None: model.to(device, dtype=weight_dtype)
def handle_cache_latents(
should_cache,
output_dir,
train_dataloader,
train_batch_size,
vae,
cached_latent_dir=None,
shuffle=False
):
# Cache latents by storing them in VRAM.
# Speeds up training and saves memory by not encoding during the train loop.
if not should_cache: return None
vae.to('cuda', dtype=torch.float16)
vae.enable_slicing()
cached_latent_dir = (
os.path.abspath(cached_latent_dir) if cached_latent_dir is not None else None
)
if cached_latent_dir is None:
cache_save_dir = f"{output_dir}/cached_latents"
os.makedirs(cache_save_dir, exist_ok=True)
for i, batch in enumerate(tqdm(train_dataloader, desc="Caching Latents.")):
save_name = f"cached_{i}"
full_out_path = f"{cache_save_dir}/{save_name}.pt"
pixel_values = batch['pixel_values'].to('cuda', dtype=torch.float16)
|
already_printed_trainables = False
logger = get_logger(__name__, log_level="INFO")
def create_logging(logging, logger, accelerator):
logging.basicConfig(
format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
level=logging.INFO,
)
logger.info(accelerator.state, main_process_only=False)
def accelerate_set_verbose(accelerator):
if accelerator.is_local_main_process:
transformers.utils.logging.set_verbosity_warning()
diffusers.utils.logging.set_verbosity_info()
else:
transformers.utils.logging.set_verbosity_error()
diffusers.utils.logging.set_verbosity_error()
def get_train_dataset(dataset_types, train_data, tokenizer):
train_datasets = []
dataset_cls = [VideoJsonDataset, SingleVideoDataset, ImageDataset, VideoFolderDataset, VideoBLIPDataset]
dataset_map = {d.__getname__(): d for d in dataset_cls}
# Loop through all available datasets, get the name, then add to list of data to process.
for dataset in dataset_types:
if dataset in dataset_map:
train_datasets.append(dataset_map[dataset](**train_data, tokenizer=tokenizer))
else:
raise ValueError(f"Dataset type not found: {dataset} not in {dataset_map.keys()}")
return train_datasets
def extend_datasets(datasets, dataset_items, extend=False):
biggest_data_len = max(x.__len__() for x in datasets)
extended = []
for dataset in datasets:
if dataset.__len__() == 0:
del dataset
continue
if dataset.__len__() < biggest_data_len:
for item in dataset_items:
if extend and item not in extended and hasattr(dataset, item):
print(f"Extending {item}")
value = getattr(dataset, item)
value *= biggest_data_len
value = value[:biggest_data_len]
setattr(dataset, item, value)
print(f"New {item} dataset length: {dataset.__len__()}")
extended.append(item)
def export_to_video(video_frames, output_video_path, fps):
fourcc = cv2.VideoWriter_fourcc(*"mp4v")
h, w, _ = video_frames[0].shape
video_writer = cv2.VideoWriter(output_video_path, fourcc, fps=fps, frameSize=(w, h))
for i in range(len(video_frames)):
img = cv2.cvtColor(video_frames[i], cv2.COLOR_RGB2BGR)
video_writer.write(img)
def create_output_folders(output_dir, config):
now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
out_dir = os.path.join(output_dir, f"train_{now}")
os.makedirs(out_dir, exist_ok=True)
os.makedirs(f"{out_dir}/samples", exist_ok=True)
OmegaConf.save(config, os.path.join(out_dir, 'config.yaml'))
return out_dir
def load_primary_models(pretrained_model_path, motion_mask, motion_strength):
noise_scheduler = DDPMScheduler.from_pretrained(pretrained_model_path, subfolder="scheduler")
tokenizer = CLIPTokenizer.from_pretrained(pretrained_model_path, subfolder="tokenizer")
text_encoder = CLIPTextModel.from_pretrained(pretrained_model_path, subfolder="text_encoder")
vae = AutoencoderKL.from_pretrained(pretrained_model_path, subfolder="vae")
unet = UNet3DConditionModel.from_pretrained(pretrained_model_path, subfolder="unet",
low_cpu_mem_usage=False, device_map=None, motion_mask=motion_mask, motion_strength=motion_strength)
if pretrained_model_path.endswith('zeroscope_v2_576w'):
#first time init, modify unet conv in2
unet.conv_in2.bias.data = copy.deepcopy(unet.conv_in.bias)
torch.nn.init.zeros_(unet.conv_in2.weight)
unet.conv_in2.weight.data[:,1:]= copy.deepcopy(unet.conv_in.weight)
return noise_scheduler, tokenizer, text_encoder, vae, unet
def unet_and_text_g_c(unet, text_encoder, unet_enable, text_enable):
unet._set_gradient_checkpointing(value=unet_enable)
if text_enable:
text_encoder.gradient_checkpointing_enable()
else:
text_encoder.gradient_checkpointing_disable()
def freeze_models(models_to_freeze):
for model in models_to_freeze:
if model is not None: model.requires_grad_(False)
def is_attn(name):
return ('attn1' or 'attn2' == name.split('.')[-1])
def set_processors(attentions):
for attn in attentions: attn.set_processor(AttnProcessor2_0())
def set_torch_2_attn(unet):
optim_count = 0
for name, module in unet.named_modules():
if is_attn(name):
if isinstance(module, torch.nn.ModuleList):
for m in module:
if isinstance(m, BasicTransformerBlock):
set_processors([m.attn1, m.attn2])
optim_count += 1
if optim_count > 0:
print(f"{optim_count} Attention layers using Scaled Dot Product Attention.")
def handle_memory_attention(enable_xformers_memory_efficient_attention, enable_torch_2_attn, unet):
try:
is_torch_2 = hasattr(F, 'scaled_dot_product_attention')
enable_torch_2 = is_torch_2 and enable_torch_2_attn
if enable_xformers_memory_efficient_attention and not enable_torch_2:
if is_xformers_available():
unet.enable_xformers_memory_efficient_attention(attention_op=MemoryEfficientAttentionFlashAttentionOp)
else:
raise ValueError("xformers is not available. Make sure it is installed correctly")
if enable_torch_2:
set_torch_2_attn(unet)
except:
print("Could not enable memory efficient attention for xformers or Torch 2.0.")
def param_optim(model, condition, extra_params=None, is_lora=False, negation=None):
extra_params = extra_params if len(extra_params.keys()) > 0 else None
return {
"model": model,
"condition": condition,
'extra_params': extra_params,
'is_lora': is_lora,
"negation": negation
}
def create_optim_params(name='param', params=None, lr=5e-6, extra_params=None):
params = {
"name": name,
"params": params,
"lr": lr
}
if extra_params is not None:
for k, v in extra_params.items():
params[k] = v
return params
def negate_params(name, negation):
# We have to do this if we are co-training with LoRA.
# This ensures that parameter groups aren't duplicated.
if negation is None: return False
for n in negation:
if n in name and 'temp' not in name:
return True
return False
def create_optimizer_params(model_list, lr):
optimizer_params = []
for optim in model_list:
model, condition, extra_params, is_lora, negation = optim.values()
# Check if we are doing LoRA training.
if is_lora and condition and isinstance(model, list):
params = create_optim_params(
params=itertools.chain(*model),
extra_params=extra_params
)
optimizer_params.append(params)
continue
if is_lora and condition and not isinstance(model, list):
for n, p in model.named_parameters():
if 'lora' in n:
params = create_optim_params(n, p, lr, extra_params)
optimizer_params.append(params)
continue
# If this is true, we can train it.
if condition:
for n, p in model.named_parameters():
should_negate = 'lora' in n and not is_lora
if should_negate: continue
params = create_optim_params(n, p, lr, extra_params)
optimizer_params.append(params)
return optimizer_params
def get_optimizer(use_8bit_adam):
if use_8bit_adam:
try:
except ImportError:
raise ImportError(
"Please install bitsandbytes to use 8-bit Adam. You can do so by running `pip install bitsandbytes`"
)
return bnb.optim.AdamW8bit
else:
return torch.optim.AdamW
def is_mixed_precision(accelerator):
weight_dtype = torch.float32
if accelerator.mixed_precision == "fp16":
weight_dtype = torch.float16
elif accelerator.mixed_precision == "bf16":
weight_dtype = torch.bfloat16
return weight_dtype
def cast_to_gpu_and_type(model_list, device, weight_dtype):
for model in model_list:
if model is not None: model.to(device, dtype=weight_dtype)
def handle_cache_latents(
should_cache,
output_dir,
train_dataloader,
train_batch_size,
vae,
cached_latent_dir=None,
shuffle=False
):
# Cache latents by storing them in VRAM.
# Speeds up training and saves memory by not encoding during the train loop.
if not should_cache: return None
vae.to('cuda', dtype=torch.float16)
vae.enable_slicing()
cached_latent_dir = (
os.path.abspath(cached_latent_dir) if cached_latent_dir is not None else None
)
if cached_latent_dir is None:
cache_save_dir = f"{output_dir}/cached_latents"
os.makedirs(cache_save_dir, exist_ok=True)
for i, batch in enumerate(tqdm(train_dataloader, desc="Caching Latents.")):
save_name = f"cached_{i}"
full_out_path = f"{cache_save_dir}/{save_name}.pt"
pixel_values = batch['pixel_values'].to('cuda', dtype=torch.float16) | batch['pixel_values'] = tensor_to_vae_latent(pixel_values, vae) | 22 | 2023-12-07 08:26:29+00:00 | 24k |
modelscope/richdreamer | threestudio/models/geometry/tetrahedra_sdf_grid.py | [
{
"identifier": "BaseExplicitGeometry",
"path": "threestudio/models/geometry/base.py",
"snippet": "class BaseExplicitGeometry(BaseGeometry):\n @dataclass\n class Config(BaseGeometry.Config):\n radius: float = 1.0\n\n cfg: Config\n\n def configure(self) -> None:\n self.bbox: Flo... | import numpy as np
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import threestudio
import trimesh
from dataclasses import dataclass, field
from threestudio.models.geometry.base import (BaseExplicitGeometry,
BaseGeometry,
contract_to_unisphere,)
from threestudio.models.geometry.implicit_sdf import ImplicitSDF
from threestudio.models.geometry.implicit_volume import ImplicitVolume
from threestudio.models.isosurface import MarchingTetrahedraHelper
from threestudio.models.mesh import Mesh
from threestudio.models.networks import get_encoding, get_mlp
from threestudio.utils.misc import broadcast, get_rank
from threestudio.utils.ops import scale_tensor
from threestudio.utils.typing import *
from pysdf import SDF | 15,175 | if self.cfg.shape_init == "ellipsoid":
assert (
isinstance(self.cfg.shape_init_params, Sized)
and len(self.cfg.shape_init_params) == 3
)
size = torch.as_tensor(self.cfg.shape_init_params).to(self.device)
def func(points_rand: Float[Tensor, "N 3"]) -> Float[Tensor, "N 1"]:
return ((points_rand / size) ** 2).sum(
dim=-1, keepdim=True
).sqrt() - 1.0 # pseudo signed distance of an ellipsoid
get_gt_sdf = func
elif self.cfg.shape_init == "sphere":
assert isinstance(self.cfg.shape_init_params, float)
radius = self.cfg.shape_init_params
def func(points_rand: Float[Tensor, "N 3"]) -> Float[Tensor, "N 1"]:
return (points_rand**2).sum(dim=-1, keepdim=True).sqrt() - radius
get_gt_sdf = func
elif self.cfg.shape_init.startswith("mesh:"):
assert isinstance(self.cfg.shape_init_params, float)
mesh_path = self.cfg.shape_init[5:]
if not os.path.exists(mesh_path):
raise ValueError(f"Mesh file {mesh_path} does not exist.")
mesh = trimesh.load(mesh_path)
# move to center
centroid = mesh.vertices.mean(0)
mesh.vertices = mesh.vertices - centroid
# align to up-z and front-x
dirs = ["+x", "+y", "+z", "-x", "-y", "-z"]
dir2vec = {
"+x": np.array([1, 0, 0]),
"+y": np.array([0, 1, 0]),
"+z": np.array([0, 0, 1]),
"-x": np.array([-1, 0, 0]),
"-y": np.array([0, -1, 0]),
"-z": np.array([0, 0, -1]),
}
if (
self.cfg.shape_init_mesh_up not in dirs
or self.cfg.shape_init_mesh_front not in dirs
):
raise ValueError(
f"shape_init_mesh_up and shape_init_mesh_front must be one of {dirs}."
)
if self.cfg.shape_init_mesh_up[1] == self.cfg.shape_init_mesh_front[1]:
raise ValueError(
"shape_init_mesh_up and shape_init_mesh_front must be orthogonal."
)
z_, x_ = (
dir2vec[self.cfg.shape_init_mesh_up],
dir2vec[self.cfg.shape_init_mesh_front],
)
y_ = np.cross(z_, x_)
std2mesh = np.stack([x_, y_, z_], axis=0).T
mesh2std = np.linalg.inv(std2mesh)
# scaling
scale = np.abs(mesh.vertices).max()
mesh.vertices = mesh.vertices / scale * self.cfg.shape_init_params
mesh.vertices = np.dot(mesh2std, mesh.vertices.T).T
sdf = SDF(mesh.vertices, mesh.faces)
def func(points_rand: Float[Tensor, "N 3"]) -> Float[Tensor, "N 1"]:
# add a negative signed here
# as in pysdf the inside of the shape has positive signed distance
return torch.from_numpy(-sdf(points_rand.cpu().numpy())).to(
points_rand
)[..., None]
get_gt_sdf = func
else:
raise ValueError(
f"Unknown shape initialization type: {self.cfg.shape_init}"
)
sdf_gt = get_gt_sdf(
scale_tensor(
self.isosurface_helper.grid_vertices,
self.isosurface_helper.points_range,
self.isosurface_bbox,
)
)
self.sdf.data = sdf_gt
# explicit broadcast to ensure param consistency across ranks
for param in self.parameters():
broadcast(param, src=0)
def isosurface(self) -> Mesh:
# return cached mesh if fix_geometry is True to save computation
if self.cfg.fix_geometry and self.mesh is not None:
return self.mesh
mesh = self.isosurface_helper(self.sdf, self.deformation)
mesh.v_pos = scale_tensor(
mesh.v_pos, self.isosurface_helper.points_range, self.isosurface_bbox
)
if self.cfg.isosurface_remove_outliers:
mesh = mesh.remove_outlier(self.cfg.isosurface_outlier_n_faces_threshold)
self.mesh = mesh
return mesh
def forward(
self, points: Float[Tensor, "*N Di"], output_normal: bool = False
) -> Dict[str, Float[Tensor, "..."]]:
if self.cfg.geometry_only:
return {}
assert (
output_normal == False
), f"Normal output is not supported for {self.__class__.__name__}"
points_unscaled = points # points in the original scale
|
@threestudio.register("tetrahedra-sdf-grid")
class TetrahedraSDFGrid(BaseExplicitGeometry):
@dataclass
class Config(BaseExplicitGeometry.Config):
isosurface_resolution: int = 128
isosurface_deformable_grid: bool = True
isosurface_remove_outliers: bool = False
isosurface_outlier_n_faces_threshold: Union[int, float] = 0.01
nerf_scale: float = 1.0
n_input_dims: int = 3
n_feature_dims: int = 3
pos_encoding_config: dict = field(
default_factory=lambda: {
"otype": "HashGrid",
"n_levels": 16,
"n_features_per_level": 2,
"log2_hashmap_size": 19,
"base_resolution": 16,
"per_level_scale": 1.447269237440378,
}
)
mlp_network_config: dict = field(
default_factory=lambda: {
"otype": "VanillaMLP",
"activation": "ReLU",
"output_activation": "none",
"n_neurons": 64,
"n_hidden_layers": 1,
}
)
shape_init: Optional[str] = None
shape_init_params: Optional[Any] = None
shape_init_mesh_up: str = "+z"
shape_init_mesh_front: str = "+x"
force_shape_init: bool = False
geometry_only: bool = False
fix_geometry: bool = False
# sdf_bias: Union[float, str] = 0.0
# sdf_bias_params: Optional[Any] = None
cfg: Config
def configure(self) -> None:
super().configure()
# this should be saved to state_dict, register as buffer
self.isosurface_bbox: Float[Tensor, "2 3"]
self.register_buffer("isosurface_bbox", self.bbox.clone())
self.isosurface_helper = MarchingTetrahedraHelper(
self.cfg.isosurface_resolution,
f"load/tets/{self.cfg.isosurface_resolution}_tets.npz",
)
self.sdf: Float[Tensor, "Nv 1"]
self.deformation: Optional[Float[Tensor, "Nv 3"]]
if not self.cfg.fix_geometry:
self.register_parameter(
"sdf",
nn.Parameter(
torch.zeros(
(self.isosurface_helper.grid_vertices.shape[0], 1),
dtype=torch.float32,
)
),
)
if self.cfg.isosurface_deformable_grid:
self.register_parameter(
"deformation",
nn.Parameter(
torch.zeros_like(self.isosurface_helper.grid_vertices)
),
)
else:
self.deformation = None
else:
self.register_buffer(
"sdf",
torch.zeros(
(self.isosurface_helper.grid_vertices.shape[0], 1),
dtype=torch.float32,
),
)
if self.cfg.isosurface_deformable_grid:
self.register_buffer(
"deformation",
torch.zeros_like(self.isosurface_helper.grid_vertices),
)
else:
self.deformation = None
if not self.cfg.geometry_only:
self.encoding = get_encoding(
self.cfg.n_input_dims, self.cfg.pos_encoding_config
)
self.feature_network = get_mlp(
self.encoding.n_output_dims,
self.cfg.n_feature_dims,
self.cfg.mlp_network_config,
)
self.mesh: Optional[Mesh] = None
def initialize_shape(self) -> None:
if self.cfg.shape_init is None and not self.cfg.force_shape_init:
return
# do not initialize shape if weights are provided
if self.cfg.weights is not None and not self.cfg.force_shape_init:
return
get_gt_sdf: Callable[[Float[Tensor, "N 3"]], Float[Tensor, "N 1"]]
assert isinstance(self.cfg.shape_init, str)
if self.cfg.shape_init == "ellipsoid":
assert (
isinstance(self.cfg.shape_init_params, Sized)
and len(self.cfg.shape_init_params) == 3
)
size = torch.as_tensor(self.cfg.shape_init_params).to(self.device)
def func(points_rand: Float[Tensor, "N 3"]) -> Float[Tensor, "N 1"]:
return ((points_rand / size) ** 2).sum(
dim=-1, keepdim=True
).sqrt() - 1.0 # pseudo signed distance of an ellipsoid
get_gt_sdf = func
elif self.cfg.shape_init == "sphere":
assert isinstance(self.cfg.shape_init_params, float)
radius = self.cfg.shape_init_params
def func(points_rand: Float[Tensor, "N 3"]) -> Float[Tensor, "N 1"]:
return (points_rand**2).sum(dim=-1, keepdim=True).sqrt() - radius
get_gt_sdf = func
elif self.cfg.shape_init.startswith("mesh:"):
assert isinstance(self.cfg.shape_init_params, float)
mesh_path = self.cfg.shape_init[5:]
if not os.path.exists(mesh_path):
raise ValueError(f"Mesh file {mesh_path} does not exist.")
mesh = trimesh.load(mesh_path)
# move to center
centroid = mesh.vertices.mean(0)
mesh.vertices = mesh.vertices - centroid
# align to up-z and front-x
dirs = ["+x", "+y", "+z", "-x", "-y", "-z"]
dir2vec = {
"+x": np.array([1, 0, 0]),
"+y": np.array([0, 1, 0]),
"+z": np.array([0, 0, 1]),
"-x": np.array([-1, 0, 0]),
"-y": np.array([0, -1, 0]),
"-z": np.array([0, 0, -1]),
}
if (
self.cfg.shape_init_mesh_up not in dirs
or self.cfg.shape_init_mesh_front not in dirs
):
raise ValueError(
f"shape_init_mesh_up and shape_init_mesh_front must be one of {dirs}."
)
if self.cfg.shape_init_mesh_up[1] == self.cfg.shape_init_mesh_front[1]:
raise ValueError(
"shape_init_mesh_up and shape_init_mesh_front must be orthogonal."
)
z_, x_ = (
dir2vec[self.cfg.shape_init_mesh_up],
dir2vec[self.cfg.shape_init_mesh_front],
)
y_ = np.cross(z_, x_)
std2mesh = np.stack([x_, y_, z_], axis=0).T
mesh2std = np.linalg.inv(std2mesh)
# scaling
scale = np.abs(mesh.vertices).max()
mesh.vertices = mesh.vertices / scale * self.cfg.shape_init_params
mesh.vertices = np.dot(mesh2std, mesh.vertices.T).T
sdf = SDF(mesh.vertices, mesh.faces)
def func(points_rand: Float[Tensor, "N 3"]) -> Float[Tensor, "N 1"]:
# add a negative signed here
# as in pysdf the inside of the shape has positive signed distance
return torch.from_numpy(-sdf(points_rand.cpu().numpy())).to(
points_rand
)[..., None]
get_gt_sdf = func
else:
raise ValueError(
f"Unknown shape initialization type: {self.cfg.shape_init}"
)
sdf_gt = get_gt_sdf(
scale_tensor(
self.isosurface_helper.grid_vertices,
self.isosurface_helper.points_range,
self.isosurface_bbox,
)
)
self.sdf.data = sdf_gt
# explicit broadcast to ensure param consistency across ranks
for param in self.parameters():
broadcast(param, src=0)
def isosurface(self) -> Mesh:
# return cached mesh if fix_geometry is True to save computation
if self.cfg.fix_geometry and self.mesh is not None:
return self.mesh
mesh = self.isosurface_helper(self.sdf, self.deformation)
mesh.v_pos = scale_tensor(
mesh.v_pos, self.isosurface_helper.points_range, self.isosurface_bbox
)
if self.cfg.isosurface_remove_outliers:
mesh = mesh.remove_outlier(self.cfg.isosurface_outlier_n_faces_threshold)
self.mesh = mesh
return mesh
def forward(
self, points: Float[Tensor, "*N Di"], output_normal: bool = False
) -> Dict[str, Float[Tensor, "..."]]:
if self.cfg.geometry_only:
return {}
assert (
output_normal == False
), f"Normal output is not supported for {self.__class__.__name__}"
points_unscaled = points # points in the original scale | points = contract_to_unisphere(points, self.bbox) # points normalized to (0, 1) | 2 | 2023-12-06 07:53:11+00:00 | 24k |
rehg-lab/RAVE | annotator/oneformer/oneformer/demo/visualizer.py | [
{
"identifier": "MetadataCatalog",
"path": "annotator/oneformer/detectron2/data/catalog.py",
"snippet": "class _DatasetCatalog(UserDict):\r\nclass Metadata(types.SimpleNamespace):\r\nclass _MetadataCatalog(UserDict):\r\n def register(self, name, func):\r\n def get(self, name):\r\n def list(self... | import colorsys
import logging
import math
import numpy as np
import cv2
import matplotlib as mpl
import matplotlib.colors as mplc
import matplotlib.figure as mplfigure
import annotator.oneformer.pycocotools.mask as mask_util
import torch
import random
from enum import Enum, unique
from matplotlib.backends.backend_agg import FigureCanvasAgg
from PIL import Image
from annotator.oneformer.detectron2.data import MetadataCatalog
from annotator.oneformer.detectron2.structures import BitMasks, Boxes, BoxMode, Keypoints, PolygonMasks, RotatedBoxes
from annotator.oneformer.detectron2.utils.file_io import PathManager
from .colormap import random_color, _COLORS
| 17,322 | self._draw_text_in_mask(binary_mask, text, lighter_color)
return self.output
def draw_soft_mask(self, soft_mask, color=None, *, text=None, alpha=0.5):
"""
Args:
soft_mask (ndarray): float array of shape (H, W), each value in [0, 1].
color: color of the mask. Refer to `matplotlib.colors` for a full list of
formats that are accepted. If None, will pick a random color.
text (str): if None, will be drawn on the object
alpha (float): blending efficient. Smaller values lead to more transparent masks.
Returns:
output (VisImage): image object with mask drawn.
"""
if color is None:
color = random_color(rgb=True, maximum=1)
color = mplc.to_rgb(color)
shape2d = (soft_mask.shape[0], soft_mask.shape[1])
rgba = np.zeros(shape2d + (4,), dtype="float32")
rgba[:, :, :3] = color
rgba[:, :, 3] = soft_mask * alpha
self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
if text is not None:
lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
binary_mask = (soft_mask > 0.5).astype("uint8")
# self._draw_text_in_mask(binary_mask, text, lighter_color)
return self.output
def draw_polygon(self, segment, color, edge_color=None, alpha=0.5):
"""
Args:
segment: numpy array of shape Nx2, containing all the points in the polygon.
color: color of the polygon. Refer to `matplotlib.colors` for a full list of
formats that are accepted.
edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
full list of formats that are accepted. If not provided, a darker shade
of the polygon color will be used instead.
alpha (float): blending efficient. Smaller values lead to more transparent masks.
Returns:
output (VisImage): image object with polygon drawn.
"""
if edge_color is None:
# make edge color darker than the polygon color
if alpha > 0.8:
edge_color = self._change_color_brightness(color, brightness_factor=-0.7)
else:
edge_color = color
edge_color = mplc.to_rgb(edge_color) + (1,)
polygon = mpl.patches.Polygon(
segment,
fill=True,
facecolor=mplc.to_rgb(color) + (alpha,),
edgecolor=edge_color,
linewidth=max(self._default_font_size // 15 * self.output.scale, 1),
)
self.output.ax.add_patch(polygon)
return self.output
"""
Internal methods:
"""
def _jitter(self, color):
"""
Randomly modifies given color to produce a slightly different color than the color given.
Args:
color (tuple[double]): a tuple of 3 elements, containing the RGB values of the color
picked. The values in the list are in the [0.0, 1.0] range.
Returns:
jittered_color (tuple[double]): a tuple of 3 elements, containing the RGB values of the
color after being jittered. The values in the list are in the [0.0, 1.0] range.
"""
color = mplc.to_rgb(color)
vec = np.random.rand(3)
# better to do it in another color space
vec = vec / np.linalg.norm(vec) * 0.5
res = np.clip(vec + color, 0, 1)
return tuple(res)
def _create_grayscale_image(self, mask=None):
"""
Create a grayscale version of the original image.
The colors in masked area, if given, will be kept.
"""
img_bw = self.img.astype("f4").mean(axis=2)
img_bw = np.stack([img_bw] * 3, axis=2)
if mask is not None:
img_bw[mask] = self.img[mask]
return img_bw
def _change_color_brightness(self, color, brightness_factor):
"""
Depending on the brightness_factor, gives a lighter or darker color i.e. a color with
less or more saturation than the original color.
Args:
color: color of the polygon. Refer to `matplotlib.colors` for a full list of
formats that are accepted.
brightness_factor (float): a value in [-1.0, 1.0] range. A lightness factor of
0 will correspond to no change, a factor in [-1.0, 0) range will result in
a darker color and a factor in (0, 1.0] range will result in a lighter color.
Returns:
modified_color (tuple[double]): a tuple containing the RGB values of the
modified color. Each value in the tuple is in the [0.0, 1.0] range.
"""
assert brightness_factor >= -1.0 and brightness_factor <= 1.0
color = mplc.to_rgb(color)
polygon_color = colorsys.rgb_to_hls(*mplc.to_rgb(color))
modified_lightness = polygon_color[1] + (brightness_factor * polygon_color[1])
modified_lightness = 0.0 if modified_lightness < 0.0 else modified_lightness
modified_lightness = 1.0 if modified_lightness > 1.0 else modified_lightness
modified_color = colorsys.hls_to_rgb(polygon_color[0], modified_lightness, polygon_color[2])
return modified_color
def _convert_boxes(self, boxes):
"""
Convert different format of boxes to an NxB array, where B = 4 or 5 is the box dimension.
"""
| # Copyright (c) Facebook, Inc. and its affiliates.
random.seed(0)
logger = logging.getLogger(__name__)
__all__ = ["ColorMode", "VisImage", "Visualizer"]
_SMALL_OBJECT_AREA_THRESH = 1000
_LARGE_MASK_AREA_THRESH = 120000
_OFF_WHITE = (1.0, 1.0, 1.0)
_BLACK = (0, 0, 0)
_RED = (1.0, 0, 0)
_KEYPOINT_THRESHOLD = 0.05
def instance_color(rgb=False, idx=1, maximum=255):
"""
Args:
rgb (bool): whether to return RGB colors or BGR colors.
maximum (int): either 255 or 1
Returns:
ndarray: a vector of 3 numbers
"""
ret = _COLORS[idx] * maximum
if not rgb:
ret = ret[::-1]
return ret
@unique
class ColorMode(Enum):
"""
Enum of different color modes to use for instance visualizations.
"""
IMAGE = 0
"""
Picks a random color for every instance and overlay segmentations with low opacity.
"""
SEGMENTATION = 1
"""
Let instances of the same category have similar colors
(from metadata.thing_colors), and overlay them with
high opacity. This provides more attention on the quality of segmentation.
"""
IMAGE_BW = 2
"""
Same as IMAGE, but convert all areas without masks to gray-scale.
Only available for drawing per-instance mask predictions.
"""
class GenericMask:
"""
Attribute:
polygons (list[ndarray]): list[ndarray]: polygons for this mask.
Each ndarray has format [x, y, x, y, ...]
mask (ndarray): a binary mask
"""
def __init__(self, mask_or_polygons, height, width):
self._mask = self._polygons = self._has_holes = None
self.height = height
self.width = width
m = mask_or_polygons
if isinstance(m, dict):
# RLEs
assert "counts" in m and "size" in m
if isinstance(m["counts"], list): # uncompressed RLEs
h, w = m["size"]
assert h == height and w == width
m = mask_util.frPyObjects(m, h, w)
self._mask = mask_util.decode(m)[:, :]
return
if isinstance(m, list): # list[ndarray]
self._polygons = [np.asarray(x).reshape(-1) for x in m]
return
if isinstance(m, np.ndarray): # assumed to be a binary mask
assert m.shape[1] != 2, m.shape
assert m.shape == (
height,
width,
), f"mask shape: {m.shape}, target dims: {height}, {width}"
self._mask = m.astype("uint8")
return
raise ValueError("GenericMask cannot handle object {} of type '{}'".format(m, type(m)))
@property
def mask(self):
if self._mask is None:
self._mask = self.polygons_to_mask(self._polygons)
return self._mask
@property
def polygons(self):
if self._polygons is None:
self._polygons, self._has_holes = self.mask_to_polygons(self._mask)
return self._polygons
@property
def has_holes(self):
if self._has_holes is None:
if self._mask is not None:
self._polygons, self._has_holes = self.mask_to_polygons(self._mask)
else:
self._has_holes = False # if original format is polygon, does not have holes
return self._has_holes
def mask_to_polygons(self, mask):
# cv2.RETR_CCOMP flag retrieves all the contours and arranges them to a 2-level
# hierarchy. External contours (boundary) of the object are placed in hierarchy-1.
# Internal contours (holes) are placed in hierarchy-2.
# cv2.CHAIN_APPROX_NONE flag gets vertices of polygons from contours.
mask = np.ascontiguousarray(mask) # some versions of cv2 does not support incontiguous arr
res = cv2.findContours(mask.astype("uint8"), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
hierarchy = res[-1]
if hierarchy is None: # empty mask
return [], False
has_holes = (hierarchy.reshape(-1, 4)[:, 3] >= 0).sum() > 0
res = res[-2]
res = [x.flatten() for x in res]
# These coordinates from OpenCV are integers in range [0, W-1 or H-1].
# We add 0.5 to turn them into real-value coordinate space. A better solution
# would be to first +0.5 and then dilate the returned polygon by 0.5.
res = [x + 0.5 for x in res if len(x) >= 6]
return res, has_holes
def polygons_to_mask(self, polygons):
rle = mask_util.frPyObjects(polygons, self.height, self.width)
rle = mask_util.merge(rle)
return mask_util.decode(rle)[:, :]
def area(self):
return self.mask.sum()
def bbox(self):
p = mask_util.frPyObjects(self.polygons, self.height, self.width)
p = mask_util.merge(p)
bbox = mask_util.toBbox(p)
bbox[2] += bbox[0]
bbox[3] += bbox[1]
return bbox
class _PanopticPrediction:
"""
Unify different panoptic annotation/prediction formats
"""
def __init__(self, panoptic_seg, segments_info, metadata=None):
if segments_info is None:
assert metadata is not None
# If "segments_info" is None, we assume "panoptic_img" is a
# H*W int32 image storing the panoptic_id in the format of
# category_id * label_divisor + instance_id. We reserve -1 for
# VOID label.
label_divisor = metadata.label_divisor
segments_info = []
for panoptic_label in np.unique(panoptic_seg.numpy()):
if panoptic_label == -1:
# VOID region.
continue
pred_class = panoptic_label // label_divisor
isthing = pred_class in metadata.thing_dataset_id_to_contiguous_id.values()
segments_info.append(
{
"id": int(panoptic_label),
"category_id": int(pred_class),
"isthing": bool(isthing),
}
)
del metadata
self._seg = panoptic_seg
self._sinfo = {s["id"]: s for s in segments_info} # seg id -> seg info
segment_ids, areas = torch.unique(panoptic_seg, sorted=True, return_counts=True)
areas = areas.numpy()
sorted_idxs = np.argsort(-areas)
self._seg_ids, self._seg_areas = segment_ids[sorted_idxs], areas[sorted_idxs]
self._seg_ids = self._seg_ids.tolist()
for sid, area in zip(self._seg_ids, self._seg_areas):
if sid in self._sinfo:
self._sinfo[sid]["area"] = float(area)
def non_empty_mask(self):
"""
Returns:
(H, W) array, a mask for all pixels that have a prediction
"""
empty_ids = []
for id in self._seg_ids:
if id not in self._sinfo:
empty_ids.append(id)
if len(empty_ids) == 0:
return np.zeros(self._seg.shape, dtype=np.uint8)
assert (
len(empty_ids) == 1
), ">1 ids corresponds to no labels. This is currently not supported"
return (self._seg != empty_ids[0]).numpy().astype(np.bool)
def semantic_masks(self):
for sid in self._seg_ids:
sinfo = self._sinfo.get(sid)
if sinfo is None or sinfo["isthing"]:
# Some pixels (e.g. id 0 in PanopticFPN) have no instance or semantic predictions.
continue
yield (self._seg == sid).numpy().astype(np.bool), sinfo
def instance_masks(self):
for sid in self._seg_ids:
sinfo = self._sinfo.get(sid)
if sinfo is None or not sinfo["isthing"]:
continue
mask = (self._seg == sid).numpy().astype(np.bool)
if mask.sum() > 0:
yield mask, sinfo
def _create_text_labels(classes, scores, class_names, is_crowd=None):
"""
Args:
classes (list[int] or None):
scores (list[float] or None):
class_names (list[str] or None):
is_crowd (list[bool] or None):
Returns:
list[str] or None
"""
labels = None
if classes is not None:
if class_names is not None and len(class_names) > 0:
labels = [class_names[i] for i in classes]
else:
labels = [str(i) for i in classes]
if scores is not None:
if labels is None:
labels = ["{:.0f}%".format(s * 100) for s in scores]
else:
labels = ["{} {:.0f}%".format(l, s * 100) for l, s in zip(labels, scores)]
if labels is not None and is_crowd is not None:
labels = [l + ("|crowd" if crowd else "") for l, crowd in zip(labels, is_crowd)]
return labels
class VisImage:
def __init__(self, img, scale=1.0):
"""
Args:
img (ndarray): an RGB image of shape (H, W, 3) in range [0, 255].
scale (float): scale the input image
"""
self.img = img
self.scale = scale
self.width, self.height = img.shape[1], img.shape[0]
self._setup_figure(img)
def _setup_figure(self, img):
"""
Args:
Same as in :meth:`__init__()`.
Returns:
fig (matplotlib.pyplot.figure): top level container for all the image plot elements.
ax (matplotlib.pyplot.Axes): contains figure elements and sets the coordinate system.
"""
fig = mplfigure.Figure(frameon=False)
self.dpi = fig.get_dpi()
# add a small 1e-2 to avoid precision lost due to matplotlib's truncation
# (https://github.com/matplotlib/matplotlib/issues/15363)
fig.set_size_inches(
(self.width * self.scale + 1e-2) / self.dpi,
(self.height * self.scale + 1e-2) / self.dpi,
)
self.canvas = FigureCanvasAgg(fig)
# self.canvas = mpl.backends.backend_cairo.FigureCanvasCairo(fig)
ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
ax.axis("off")
self.fig = fig
self.ax = ax
self.reset_image(img)
def reset_image(self, img):
"""
Args:
img: same as in __init__
"""
img = img.astype("uint8")
self.ax.imshow(img, extent=(0, self.width, self.height, 0), interpolation="nearest")
def save(self, filepath):
"""
Args:
filepath (str): a string that contains the absolute path, including the file name, where
the visualized image will be saved.
"""
self.fig.savefig(filepath)
def get_image(self):
"""
Returns:
ndarray:
the visualized image of shape (H, W, 3) (RGB) in uint8 type.
The shape is scaled w.r.t the input image using the given `scale` argument.
"""
canvas = self.canvas
s, (width, height) = canvas.print_to_buffer()
# buf = io.BytesIO() # works for cairo backend
# canvas.print_rgba(buf)
# width, height = self.width, self.height
# s = buf.getvalue()
buffer = np.frombuffer(s, dtype="uint8")
img_rgba = buffer.reshape(height, width, 4)
rgb, alpha = np.split(img_rgba, [3], axis=2)
return rgb.astype("uint8")
class Visualizer:
"""
Visualizer that draws data about detection/segmentation on images.
It contains methods like `draw_{text,box,circle,line,binary_mask,polygon}`
that draw primitive objects to images, as well as high-level wrappers like
`draw_{instance_predictions,sem_seg,panoptic_seg_predictions,dataset_dict}`
that draw composite data in some pre-defined style.
Note that the exact visualization style for the high-level wrappers are subject to change.
Style such as color, opacity, label contents, visibility of labels, or even the visibility
of objects themselves (e.g. when the object is too small) may change according
to different heuristics, as long as the results still look visually reasonable.
To obtain a consistent style, you can implement custom drawing functions with the
abovementioned primitive methods instead. If you need more customized visualization
styles, you can process the data yourself following their format documented in
tutorials (:doc:`/tutorials/models`, :doc:`/tutorials/datasets`). This class does not
intend to satisfy everyone's preference on drawing styles.
This visualizer focuses on high rendering quality rather than performance. It is not
designed to be used for real-time applications.
"""
# TODO implement a fast, rasterized version using OpenCV
def __init__(self, img_rgb, is_img=True, metadata=None, scale=1.0, instance_mode=ColorMode.IMAGE):
"""
Args:
img_rgb: a numpy array of shape (H, W, C), where H and W correspond to
the height and width of the image respectively. C is the number of
color channels. The image is required to be in RGB format since that
is a requirement of the Matplotlib library. The image is also expected
to be in the range [0, 255].
metadata (Metadata): dataset metadata (e.g. class names and colors)
instance_mode (ColorMode): defines one of the pre-defined style for drawing
instances on an image.
"""
if is_img:
self.img = np.asarray(img_rgb).clip(0, 255).astype(np.uint8)
else:
self.img = np.zeros_like(img_rgb).clip(0, 255).astype(np.uint8) + 255
if metadata is None:
metadata = MetadataCatalog.get("__nonexist__")
self.metadata = metadata
self.output = VisImage(self.img, scale=scale)
self.cpu_device = torch.device("cpu")
# too small texts are useless, therefore clamp to 9
self._default_font_size = max(
np.sqrt(self.output.height * self.output.width) // 90, 10 // scale
)
self._instance_mode = instance_mode
self.keypoint_threshold = _KEYPOINT_THRESHOLD
def get_image(self, img):
img = np.asarray(img).clip(0, 255).astype(np.uint8)
return VisImage(img, scale=1.0)
def draw_box_predictions(
self,
boxes=None,
labels=None,
scores=None,
assigned_colors=None
):
"""
Args:
boxes (Boxes, RotatedBoxes or ndarray): either a :class:`Boxes`,
or an Nx4 numpy array of XYXY_ABS format for the N objects in a single image,
or a :class:`RotatedBoxes`,
or an Nx5 numpy array of (x_center, y_center, width, height, angle_degrees) format
for the N objects in a single image,
labels (list[str]): the text to be displayed for each instance.
assigned_colors (list[matplotlib.colors]): a list of colors, where each color
corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
for full list of formats that the colors are accepted in.
Returns:
output (VisImage): image object with visualizations.
"""
num_instances = 0
boxes = self._convert_boxes(boxes)
classes = labels.tolist()
scores = scores.tolist()
labels = _create_text_labels(classes, scores, self.metadata.get("stuff_classes", None))
num_instances = len(boxes)
assert len(labels) == num_instances
if assigned_colors is None:
# assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
assigned_colors = [instance_color(rgb=True, idx=i, maximum=1) for i in range(num_instances)]
if num_instances == 0:
return self.output
# Display in largest to smallest order to reduce occlusion.
areas = None
areas = np.prod(boxes[:, 2:] - boxes[:, :2], axis=1)
if areas is not None:
sorted_idxs = np.argsort(-areas).tolist()
# Re-order overlapped instances in descending order.
boxes = boxes[sorted_idxs] if boxes is not None else None
labels = [labels[k] for k in sorted_idxs] if labels is not None else None
assigned_colors = [assigned_colors[idx] for idx in sorted_idxs]
for i in range(num_instances):
color = assigned_colors[i]
if boxes is not None:
self.draw_box(boxes[i], edge_color=color)
if labels is not None:
# first get a box
if boxes is not None:
x0, y0, x1, y1 = boxes[i]
text_pos = (x0, y0) # if drawing boxes, put text on the box corner.
horiz_align = "left"
else:
continue # drawing the box confidence for keypoints isn't very useful.
# for small objects, draw text at the side to avoid occlusion
instance_area = (y1 - y0) * (x1 - x0)
if (
instance_area < _SMALL_OBJECT_AREA_THRESH * self.output.scale
or y1 - y0 < 40 * self.output.scale
):
if y1 >= self.output.height - 5:
text_pos = (x1, y0)
else:
text_pos = (x0, y1)
height_ratio = (y1 - y0) / np.sqrt(self.output.height * self.output.width)
lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
font_size = (
np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2)
* 0.5
* self._default_font_size
)
self.draw_text(
labels[i],
text_pos,
color=lighter_color,
horizontal_alignment=horiz_align,
font_size=font_size,
)
return self.output
def draw_instance_predictions(self, predictions, alpha=0.8, is_text=True):
"""
Draw instance-level prediction results on an image.
Args:
predictions (Instances): the output of an instance detection/segmentation
model. Following fields will be used to draw:
"pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").
Returns:
output (VisImage): image object with visualizations.
"""
boxes = predictions.pred_boxes if predictions.has("pred_boxes") else None
scores = predictions.scores if predictions.has("scores") else None
classes = predictions.pred_classes.tolist() if predictions.has("pred_classes") else None
labels = _create_text_labels(classes, scores, self.metadata.get("stuff_classes", None))
keypoints = predictions.pred_keypoints if predictions.has("pred_keypoints") else None
if predictions.has("pred_masks"):
masks = np.asarray(predictions.pred_masks)
masks = [GenericMask(x, self.output.height, self.output.width) for x in masks]
else:
masks = None
if self._instance_mode == ColorMode.SEGMENTATION and self.metadata.get("stuff_colors"):
# colors = [
# self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in classes
# ]
colors = [
instance_color(rgb=True, idx=c, maximum=1) for c in classes
]
else:
colors = None
if self._instance_mode == ColorMode.IMAGE_BW:
self.output.reset_image(
self._create_grayscale_image(
(predictions.pred_masks.any(dim=0) > 0).numpy()
if predictions.has("pred_masks")
else None
)
)
self.overlay_instances(
masks=masks,
boxes=boxes,
labels=labels,
keypoints=keypoints,
assigned_colors=colors,
alpha=alpha,
is_text=is_text,
)
return self.output
def draw_sem_seg(self, sem_seg, area_threshold=None, alpha=0.8, is_text=True, edge_color=_OFF_WHITE):
"""
Draw semantic segmentation predictions/labels.
Args:
sem_seg (Tensor or ndarray): the segmentation of shape (H, W).
Each value is the integer label of the pixel.
area_threshold (int): segments with less than `area_threshold` are not drawn.
alpha (float): the larger it is, the more opaque the segmentations are.
Returns:
output (VisImage): image object with visualizations.
"""
if isinstance(sem_seg, torch.Tensor):
sem_seg = sem_seg.numpy()
labels, areas = np.unique(sem_seg, return_counts=True)
sorted_idxs = np.argsort(-areas).tolist()
labels = labels[sorted_idxs]
for label in filter(lambda l: l < len(self.metadata.stuff_classes), labels):
try:
mask_color = [x / 255 for x in self.metadata.stuff_colors[label]]
except (AttributeError, IndexError):
mask_color = None
binary_mask = (sem_seg == label).astype(np.uint8)
text = self.metadata.stuff_classes[label]
self.draw_binary_mask(
binary_mask,
color=mask_color,
edge_color=edge_color,
text=text,
alpha=alpha,
area_threshold=area_threshold,
is_text=is_text,
)
return self.output
def draw_panoptic_seg(self, panoptic_seg, segments_info, area_threshold=None, alpha=0.7, is_text=True,):
"""
Draw panoptic prediction annotations or results.
Args:
panoptic_seg (Tensor): of shape (height, width) where the values are ids for each
segment.
segments_info (list[dict] or None): Describe each segment in `panoptic_seg`.
If it is a ``list[dict]``, each dict contains keys "id", "category_id".
If None, category id of each pixel is computed by
``pixel // metadata.label_divisor``.
area_threshold (int): stuff segments with less than `area_threshold` are not drawn.
Returns:
output (VisImage): image object with visualizations.
"""
pred = _PanopticPrediction(panoptic_seg, segments_info, self.metadata)
if self._instance_mode == ColorMode.IMAGE_BW:
self.output.reset_image(self._create_grayscale_image(pred.non_empty_mask()))
# draw mask for all semantic segments first i.e. "stuff"
for mask, sinfo in pred.semantic_masks():
category_idx = sinfo["category_id"]
try:
mask_color = [x / 255 for x in self.metadata.stuff_colors[category_idx]]
except AttributeError:
mask_color = None
text = self.metadata.stuff_classes[category_idx]
self.draw_binary_mask(
mask,
color=mask_color,
edge_color=_OFF_WHITE,
text=text,
alpha=alpha,
area_threshold=area_threshold,
is_text=is_text,
)
# draw mask for all instances second
all_instances = list(pred.instance_masks())
if len(all_instances) == 0:
return self.output
masks, sinfo = list(zip(*all_instances))
category_ids = [x["category_id"] for x in sinfo]
try:
scores = [x["score"] for x in sinfo]
except KeyError:
scores = None
labels = _create_text_labels(
category_ids, scores, self.metadata.stuff_classes, [x.get("iscrowd", 0) for x in sinfo]
)
try:
colors = [
self._jitter([x / 255 for x in self.metadata.stuff_colors[c]]) for c in category_ids
]
except AttributeError:
colors = None
self.overlay_instances(masks=masks, labels=labels, assigned_colors=colors, alpha=alpha, is_text=is_text)
return self.output
draw_panoptic_seg_predictions = draw_panoptic_seg # backward compatibility
def draw_dataset_dict(self, dic):
"""
Draw annotations/segmentaions in Detectron2 Dataset format.
Args:
dic (dict): annotation/segmentation data of one image, in Detectron2 Dataset format.
Returns:
output (VisImage): image object with visualizations.
"""
annos = dic.get("annotations", None)
if annos:
if "segmentation" in annos[0]:
masks = [x["segmentation"] for x in annos]
else:
masks = None
if "keypoints" in annos[0]:
keypts = [x["keypoints"] for x in annos]
keypts = np.array(keypts).reshape(len(annos), -1, 3)
else:
keypts = None
boxes = [
BoxMode.convert(x["bbox"], x["bbox_mode"], BoxMode.XYXY_ABS)
if len(x["bbox"]) == 4
else x["bbox"]
for x in annos
]
colors = None
category_ids = [x["category_id"] for x in annos]
if self._instance_mode == ColorMode.SEGMENTATION and self.metadata.get("stuff_colors"):
colors = [
self._jitter([x / 255 for x in self.metadata.stuff_colors[c]])
for c in category_ids
]
names = self.metadata.get("stuff_classes", None)
labels = _create_text_labels(
category_ids,
scores=None,
class_names=names,
is_crowd=[x.get("iscrowd", 0) for x in annos],
)
self.overlay_instances(
labels=labels, boxes=boxes, masks=masks, keypoints=keypts, assigned_colors=colors
)
sem_seg = dic.get("sem_seg", None)
if sem_seg is None and "sem_seg_file_name" in dic:
with PathManager.open(dic["sem_seg_file_name"], "rb") as f:
sem_seg = Image.open(f)
sem_seg = np.asarray(sem_seg, dtype="uint8")
if sem_seg is not None:
self.draw_sem_seg(sem_seg, area_threshold=0, alpha=0.5)
pan_seg = dic.get("pan_seg", None)
# if pan_seg is None and "pan_seg_file_name" in dic:
# with PathManager.open(dic["pan_seg_file_name"], "rb") as f:
# pan_seg = Image.open(f)
# pan_seg = np.asarray(pan_seg)
# from panopticapi.utils import rgb2id
#
# pan_seg = rgb2id(pan_seg)
if pan_seg is not None:
segments_info = dic["segments_info"]
pan_seg = torch.tensor(pan_seg)
self.draw_panoptic_seg(pan_seg, segments_info, area_threshold=0, alpha=0.5)
return self.output
def overlay_instances(
self,
*,
boxes=None,
labels=None,
masks=None,
keypoints=None,
assigned_colors=None,
alpha=0.5,
is_text=True,
):
"""
Args:
boxes (Boxes, RotatedBoxes or ndarray): either a :class:`Boxes`,
or an Nx4 numpy array of XYXY_ABS format for the N objects in a single image,
or a :class:`RotatedBoxes`,
or an Nx5 numpy array of (x_center, y_center, width, height, angle_degrees) format
for the N objects in a single image,
labels (list[str]): the text to be displayed for each instance.
masks (masks-like object): Supported types are:
* :class:`detectron2.structures.PolygonMasks`,
:class:`detectron2.structures.BitMasks`.
* list[list[ndarray]]: contains the segmentation masks for all objects in one image.
The first level of the list corresponds to individual instances. The second
level to all the polygon that compose the instance, and the third level
to the polygon coordinates. The third level should have the format of
[x0, y0, x1, y1, ..., xn, yn] (n >= 3).
* list[ndarray]: each ndarray is a binary mask of shape (H, W).
* list[dict]: each dict is a COCO-style RLE.
keypoints (Keypoint or array like): an array-like object of shape (N, K, 3),
where the N is the number of instances and K is the number of keypoints.
The last dimension corresponds to (x, y, visibility or score).
assigned_colors (list[matplotlib.colors]): a list of colors, where each color
corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
for full list of formats that the colors are accepted in.
Returns:
output (VisImage): image object with visualizations.
"""
num_instances = 0
if boxes is not None:
boxes = self._convert_boxes(boxes)
num_instances = len(boxes)
if masks is not None:
masks = self._convert_masks(masks)
if num_instances:
assert len(masks) == num_instances
else:
num_instances = len(masks)
if keypoints is not None:
if num_instances:
assert len(keypoints) == num_instances
else:
num_instances = len(keypoints)
keypoints = self._convert_keypoints(keypoints)
if labels is not None:
assert len(labels) == num_instances
if assigned_colors is None:
# assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
assigned_colors = [instance_color(rgb=True, idx=i, maximum=1) for i in range(num_instances)]
if num_instances == 0:
return self.output
if boxes is not None and boxes.shape[1] == 5:
return self.overlay_rotated_instances(
boxes=boxes, labels=labels, assigned_colors=assigned_colors
)
# Display in largest to smallest order to reduce occlusion.
areas = None
if boxes is not None:
areas = np.prod(boxes[:, 2:] - boxes[:, :2], axis=1)
elif masks is not None:
areas = np.asarray([x.area() for x in masks])
if areas is not None:
sorted_idxs = np.argsort(-areas).tolist()
# Re-order overlapped instances in descending order.
boxes = boxes[sorted_idxs] if boxes is not None else None
labels = [labels[k] for k in sorted_idxs] if labels is not None else None
masks = [masks[idx] for idx in sorted_idxs] if masks is not None else None
assigned_colors = [assigned_colors[idx] for idx in sorted_idxs]
keypoints = keypoints[sorted_idxs] if keypoints is not None else None
for i in range(num_instances):
color = assigned_colors[i]
if boxes is not None:
self.draw_box(boxes[i], edge_color=color)
if masks is not None:
for segment in masks[i].polygons:
self.draw_polygon(segment.reshape(-1, 2), color, alpha=alpha)
if labels is not None:
# first get a box
if boxes is not None:
x0, y0, x1, y1 = boxes[i]
text_pos = (x0, y0) # if drawing boxes, put text on the box corner.
horiz_align = "left"
elif masks is not None:
# skip small mask without polygon
if len(masks[i].polygons) == 0:
continue
x0, y0, x1, y1 = masks[i].bbox()
# draw text in the center (defined by median) when box is not drawn
# median is less sensitive to outliers.
text_pos = np.median(masks[i].mask.nonzero(), axis=1)[::-1]
horiz_align = "center"
else:
continue # drawing the box confidence for keypoints isn't very useful.
# for small objects, draw text at the side to avoid occlusion
instance_area = (y1 - y0) * (x1 - x0)
if (
instance_area < _SMALL_OBJECT_AREA_THRESH * self.output.scale
or y1 - y0 < 40 * self.output.scale
):
if y1 >= self.output.height - 5:
text_pos = (x1, y0)
else:
text_pos = (x0, y1)
height_ratio = (y1 - y0) / np.sqrt(self.output.height * self.output.width)
lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
font_size = (
np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2)
* 0.5
* self._default_font_size
)
if is_text:
self.draw_text(
labels[i],
text_pos,
color=lighter_color,
horizontal_alignment=horiz_align,
font_size=font_size,
)
# draw keypoints
if keypoints is not None:
for keypoints_per_instance in keypoints:
self.draw_and_connect_keypoints(keypoints_per_instance)
return self.output
def overlay_rotated_instances(self, boxes=None, labels=None, assigned_colors=None):
"""
Args:
boxes (ndarray): an Nx5 numpy array of
(x_center, y_center, width, height, angle_degrees) format
for the N objects in a single image.
labels (list[str]): the text to be displayed for each instance.
assigned_colors (list[matplotlib.colors]): a list of colors, where each color
corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
for full list of formats that the colors are accepted in.
Returns:
output (VisImage): image object with visualizations.
"""
num_instances = len(boxes)
if assigned_colors is None:
# assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
assigned_colors = [instance_color(rgb=True, idx=i, maximum=1) for i in range(num_instances)]
if num_instances == 0:
return self.output
# Display in largest to smallest order to reduce occlusion.
if boxes is not None:
areas = boxes[:, 2] * boxes[:, 3]
sorted_idxs = np.argsort(-areas).tolist()
# Re-order overlapped instances in descending order.
boxes = boxes[sorted_idxs]
labels = [labels[k] for k in sorted_idxs] if labels is not None else None
colors = [assigned_colors[idx] for idx in sorted_idxs]
for i in range(num_instances):
self.draw_rotated_box_with_label(
boxes[i], edge_color=colors[i], label=labels[i] if labels is not None else None
)
return self.output
def draw_and_connect_keypoints(self, keypoints):
"""
Draws keypoints of an instance and follows the rules for keypoint connections
to draw lines between appropriate keypoints. This follows color heuristics for
line color.
Args:
keypoints (Tensor): a tensor of shape (K, 3), where K is the number of keypoints
and the last dimension corresponds to (x, y, probability).
Returns:
output (VisImage): image object with visualizations.
"""
visible = {}
keypoint_names = self.metadata.get("keypoint_names")
for idx, keypoint in enumerate(keypoints):
# draw keypoint
x, y, prob = keypoint
if prob > self.keypoint_threshold:
self.draw_circle((x, y), color=_RED)
if keypoint_names:
keypoint_name = keypoint_names[idx]
visible[keypoint_name] = (x, y)
if self.metadata.get("keypoint_connection_rules"):
for kp0, kp1, color in self.metadata.keypoint_connection_rules:
if kp0 in visible and kp1 in visible:
x0, y0 = visible[kp0]
x1, y1 = visible[kp1]
color = tuple(x / 255.0 for x in color)
self.draw_line([x0, x1], [y0, y1], color=color)
# draw lines from nose to mid-shoulder and mid-shoulder to mid-hip
# Note that this strategy is specific to person keypoints.
# For other keypoints, it should just do nothing
try:
ls_x, ls_y = visible["left_shoulder"]
rs_x, rs_y = visible["right_shoulder"]
mid_shoulder_x, mid_shoulder_y = (ls_x + rs_x) / 2, (ls_y + rs_y) / 2
except KeyError:
pass
else:
# draw line from nose to mid-shoulder
nose_x, nose_y = visible.get("nose", (None, None))
if nose_x is not None:
self.draw_line([nose_x, mid_shoulder_x], [nose_y, mid_shoulder_y], color=_RED)
try:
# draw line from mid-shoulder to mid-hip
lh_x, lh_y = visible["left_hip"]
rh_x, rh_y = visible["right_hip"]
except KeyError:
pass
else:
mid_hip_x, mid_hip_y = (lh_x + rh_x) / 2, (lh_y + rh_y) / 2
self.draw_line([mid_hip_x, mid_shoulder_x], [mid_hip_y, mid_shoulder_y], color=_RED)
return self.output
"""
Primitive drawing functions:
"""
def draw_text(
self,
text,
position,
*,
font_size=None,
color="g",
horizontal_alignment="center",
rotation=0,
):
"""
Args:
text (str): class label
position (tuple): a tuple of the x and y coordinates to place text on image.
font_size (int, optional): font of the text. If not provided, a font size
proportional to the image width is calculated and used.
color: color of the text. Refer to `matplotlib.colors` for full list
of formats that are accepted.
horizontal_alignment (str): see `matplotlib.text.Text`
rotation: rotation angle in degrees CCW
Returns:
output (VisImage): image object with text drawn.
"""
if not font_size:
font_size = self._default_font_size
# since the text background is dark, we don't want the text to be dark
color = np.maximum(list(mplc.to_rgb(color)), 0.2)
color[np.argmax(color)] = max(0.8, np.max(color))
x, y = position
self.output.ax.text(
x,
y,
text,
size=font_size * self.output.scale,
family="sans-serif",
bbox={"facecolor": "black", "alpha": 0.8, "pad": 0.7, "edgecolor": "none"},
verticalalignment="top",
horizontalalignment=horizontal_alignment,
color=color,
zorder=10,
rotation=rotation,
)
return self.output
def draw_box(self, box_coord, alpha=1.0, edge_color="g", line_style="-"):
"""
Args:
box_coord (tuple): a tuple containing x0, y0, x1, y1 coordinates, where x0 and y0
are the coordinates of the image's top left corner. x1 and y1 are the
coordinates of the image's bottom right corner.
alpha (float): blending efficient. Smaller values lead to more transparent masks.
edge_color: color of the outline of the box. Refer to `matplotlib.colors`
for full list of formats that are accepted.
line_style (string): the string to use to create the outline of the boxes.
Returns:
output (VisImage): image object with box drawn.
"""
x0, y0, x1, y1 = box_coord
width = x1 - x0
height = y1 - y0
linewidth = 2
self.output.ax.add_patch(
mpl.patches.Rectangle(
(x0, y0),
width,
height,
fill=False,
edgecolor=edge_color,
linewidth=linewidth * self.output.scale,
alpha=alpha,
linestyle=line_style,
)
)
return self.output
def draw_rotated_box_with_label(
self, rotated_box, alpha=0.5, edge_color="g", line_style="-", label=None
):
"""
Draw a rotated box with label on its top-left corner.
Args:
rotated_box (tuple): a tuple containing (cnt_x, cnt_y, w, h, angle),
where cnt_x and cnt_y are the center coordinates of the box.
w and h are the width and height of the box. angle represents how
many degrees the box is rotated CCW with regard to the 0-degree box.
alpha (float): blending efficient. Smaller values lead to more transparent masks.
edge_color: color of the outline of the box. Refer to `matplotlib.colors`
for full list of formats that are accepted.
line_style (string): the string to use to create the outline of the boxes.
label (string): label for rotated box. It will not be rendered when set to None.
Returns:
output (VisImage): image object with box drawn.
"""
cnt_x, cnt_y, w, h, angle = rotated_box
area = w * h
# use thinner lines when the box is small
linewidth = self._default_font_size / (
6 if area < _SMALL_OBJECT_AREA_THRESH * self.output.scale else 3
)
theta = angle * math.pi / 180.0
c = math.cos(theta)
s = math.sin(theta)
rect = [(-w / 2, h / 2), (-w / 2, -h / 2), (w / 2, -h / 2), (w / 2, h / 2)]
# x: left->right ; y: top->down
rotated_rect = [(s * yy + c * xx + cnt_x, c * yy - s * xx + cnt_y) for (xx, yy) in rect]
for k in range(4):
j = (k + 1) % 4
self.draw_line(
[rotated_rect[k][0], rotated_rect[j][0]],
[rotated_rect[k][1], rotated_rect[j][1]],
color=edge_color,
linestyle="--" if k == 1 else line_style,
linewidth=linewidth,
)
if label is not None:
text_pos = rotated_rect[1] # topleft corner
height_ratio = h / np.sqrt(self.output.height * self.output.width)
label_color = self._change_color_brightness(edge_color, brightness_factor=0.7)
font_size = (
np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2) * 0.5 * self._default_font_size
)
self.draw_text(label, text_pos, color=label_color, font_size=font_size, rotation=angle)
return self.output
def draw_circle(self, circle_coord, color, radius=3):
"""
Args:
circle_coord (list(int) or tuple(int)): contains the x and y coordinates
of the center of the circle.
color: color of the polygon. Refer to `matplotlib.colors` for a full list of
formats that are accepted.
radius (int): radius of the circle.
Returns:
output (VisImage): image object with box drawn.
"""
x, y = circle_coord
self.output.ax.add_patch(
mpl.patches.Circle(circle_coord, radius=radius, fill=True, color=color)
)
return self.output
def draw_line(self, x_data, y_data, color, linestyle="-", linewidth=None):
"""
Args:
x_data (list[int]): a list containing x values of all the points being drawn.
Length of list should match the length of y_data.
y_data (list[int]): a list containing y values of all the points being drawn.
Length of list should match the length of x_data.
color: color of the line. Refer to `matplotlib.colors` for a full list of
formats that are accepted.
linestyle: style of the line. Refer to `matplotlib.lines.Line2D`
for a full list of formats that are accepted.
linewidth (float or None): width of the line. When it's None,
a default value will be computed and used.
Returns:
output (VisImage): image object with line drawn.
"""
if linewidth is None:
linewidth = self._default_font_size / 3
linewidth = max(linewidth, 1)
self.output.ax.add_line(
mpl.lines.Line2D(
x_data,
y_data,
linewidth=linewidth * self.output.scale,
color=color,
linestyle=linestyle,
)
)
return self.output
def draw_binary_mask(
self, binary_mask, color=None, *, edge_color=None, text=None, alpha=0.5, area_threshold=10, is_text=True,
):
"""
Args:
binary_mask (ndarray): numpy array of shape (H, W), where H is the image height and
W is the image width. Each value in the array is either a 0 or 1 value of uint8
type.
color: color of the mask. Refer to `matplotlib.colors` for a full list of
formats that are accepted. If None, will pick a random color.
edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
full list of formats that are accepted.
text (str): if None, will be drawn on the object
alpha (float): blending efficient. Smaller values lead to more transparent masks.
area_threshold (float): a connected component smaller than this area will not be shown.
Returns:
output (VisImage): image object with mask drawn.
"""
if color is None:
color = random_color(rgb=True, maximum=1)
color = mplc.to_rgb(color)
has_valid_segment = False
binary_mask = binary_mask.astype("uint8") # opencv needs uint8
mask = GenericMask(binary_mask, self.output.height, self.output.width)
shape2d = (binary_mask.shape[0], binary_mask.shape[1])
if not mask.has_holes:
# draw polygons for regular masks
for segment in mask.polygons:
# area = mask_util.area(mask_util.frPyObjects([segment], shape2d[0], shape2d[1]))
# if area < (area_threshold or 0):
# continue
has_valid_segment = True
segment = segment.reshape(-1, 2)
self.draw_polygon(segment, color=color, edge_color=edge_color, alpha=alpha)
else:
# TODO: Use Path/PathPatch to draw vector graphics:
# https://stackoverflow.com/questions/8919719/how-to-plot-a-complex-polygon
rgba = np.zeros(shape2d + (4,), dtype="float32")
rgba[:, :, :3] = color
rgba[:, :, 3] = (mask.mask == 1).astype("float32") * alpha
has_valid_segment = True
self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
if is_text:
if text is not None and has_valid_segment:
lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
self._draw_text_in_mask(binary_mask, text, lighter_color)
return self.output
def draw_soft_mask(self, soft_mask, color=None, *, text=None, alpha=0.5):
"""
Args:
soft_mask (ndarray): float array of shape (H, W), each value in [0, 1].
color: color of the mask. Refer to `matplotlib.colors` for a full list of
formats that are accepted. If None, will pick a random color.
text (str): if None, will be drawn on the object
alpha (float): blending efficient. Smaller values lead to more transparent masks.
Returns:
output (VisImage): image object with mask drawn.
"""
if color is None:
color = random_color(rgb=True, maximum=1)
color = mplc.to_rgb(color)
shape2d = (soft_mask.shape[0], soft_mask.shape[1])
rgba = np.zeros(shape2d + (4,), dtype="float32")
rgba[:, :, :3] = color
rgba[:, :, 3] = soft_mask * alpha
self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
if text is not None:
lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
binary_mask = (soft_mask > 0.5).astype("uint8")
# self._draw_text_in_mask(binary_mask, text, lighter_color)
return self.output
def draw_polygon(self, segment, color, edge_color=None, alpha=0.5):
"""
Args:
segment: numpy array of shape Nx2, containing all the points in the polygon.
color: color of the polygon. Refer to `matplotlib.colors` for a full list of
formats that are accepted.
edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
full list of formats that are accepted. If not provided, a darker shade
of the polygon color will be used instead.
alpha (float): blending efficient. Smaller values lead to more transparent masks.
Returns:
output (VisImage): image object with polygon drawn.
"""
if edge_color is None:
# make edge color darker than the polygon color
if alpha > 0.8:
edge_color = self._change_color_brightness(color, brightness_factor=-0.7)
else:
edge_color = color
edge_color = mplc.to_rgb(edge_color) + (1,)
polygon = mpl.patches.Polygon(
segment,
fill=True,
facecolor=mplc.to_rgb(color) + (alpha,),
edgecolor=edge_color,
linewidth=max(self._default_font_size // 15 * self.output.scale, 1),
)
self.output.ax.add_patch(polygon)
return self.output
"""
Internal methods:
"""
def _jitter(self, color):
"""
Randomly modifies given color to produce a slightly different color than the color given.
Args:
color (tuple[double]): a tuple of 3 elements, containing the RGB values of the color
picked. The values in the list are in the [0.0, 1.0] range.
Returns:
jittered_color (tuple[double]): a tuple of 3 elements, containing the RGB values of the
color after being jittered. The values in the list are in the [0.0, 1.0] range.
"""
color = mplc.to_rgb(color)
vec = np.random.rand(3)
# better to do it in another color space
vec = vec / np.linalg.norm(vec) * 0.5
res = np.clip(vec + color, 0, 1)
return tuple(res)
def _create_grayscale_image(self, mask=None):
"""
Create a grayscale version of the original image.
The colors in masked area, if given, will be kept.
"""
img_bw = self.img.astype("f4").mean(axis=2)
img_bw = np.stack([img_bw] * 3, axis=2)
if mask is not None:
img_bw[mask] = self.img[mask]
return img_bw
def _change_color_brightness(self, color, brightness_factor):
"""
Depending on the brightness_factor, gives a lighter or darker color i.e. a color with
less or more saturation than the original color.
Args:
color: color of the polygon. Refer to `matplotlib.colors` for a full list of
formats that are accepted.
brightness_factor (float): a value in [-1.0, 1.0] range. A lightness factor of
0 will correspond to no change, a factor in [-1.0, 0) range will result in
a darker color and a factor in (0, 1.0] range will result in a lighter color.
Returns:
modified_color (tuple[double]): a tuple containing the RGB values of the
modified color. Each value in the tuple is in the [0.0, 1.0] range.
"""
assert brightness_factor >= -1.0 and brightness_factor <= 1.0
color = mplc.to_rgb(color)
polygon_color = colorsys.rgb_to_hls(*mplc.to_rgb(color))
modified_lightness = polygon_color[1] + (brightness_factor * polygon_color[1])
modified_lightness = 0.0 if modified_lightness < 0.0 else modified_lightness
modified_lightness = 1.0 if modified_lightness > 1.0 else modified_lightness
modified_color = colorsys.hls_to_rgb(polygon_color[0], modified_lightness, polygon_color[2])
return modified_color
def _convert_boxes(self, boxes):
"""
Convert different format of boxes to an NxB array, where B = 4 or 5 is the box dimension.
"""
| if isinstance(boxes, Boxes) or isinstance(boxes, RotatedBoxes):
| 6 | 2023-12-05 02:51:53+00:00 | 24k |
DiffusionLight/DiffusionLight | relighting/inpainter.py | [
{
"identifier": "CustomStableDiffusionControlNetInpaintPipeline",
"path": "relighting/pipeline.py",
"snippet": "class CustomStableDiffusionControlNetInpaintPipeline(StableDiffusionControlNetInpaintPipeline):\n @torch.no_grad()\n def __call__(\n self,\n prompt: Union[str, List[str]] =... | import torch
import numpy as np
import os
import pickle
from diffusers import ControlNetModel, AutoencoderKL
from PIL import Image
from tqdm.auto import tqdm
from transformers import pipeline as transformers_pipeline
from relighting.pipeline import CustomStableDiffusionControlNetInpaintPipeline
from relighting.pipeline_inpaintonly import CustomStableDiffusionInpaintPipeline, CustomStableDiffusionXLInpaintPipeline
from relighting.argument import SAMPLERS, VAE_MODELS, DEPTH_ESTIMATOR, get_control_signal_type
from relighting.image_processor import (
estimate_scene_depth,
estimate_scene_normal,
merge_normal_map,
fill_depth_circular
)
from relighting.ball_processor import get_ideal_normal_ball, crop_ball
from relighting.pipeline_xl import CustomStableDiffusionXLControlNetInpaintPipeline | 18,155 |
class NoWaterMark:
def apply_watermark(self, *args, **kwargs):
return args[0]
class ControlSignalGenerator():
def __init__(self, sd_arch, control_signal_type, device):
self.sd_arch = sd_arch
self.control_signal_type = control_signal_type
self.device = device
def process_sd_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):
if getattr(self, 'depth_estimator', None) is None:
self.depth_estimator = transformers_pipeline("depth-estimation", device=self.device.index)
control_image = self.depth_estimator(input_image)['depth']
control_image = np.array(control_image)
control_image = control_image[:, :, None]
control_image = np.concatenate([control_image, control_image, control_image], axis=2)
control_image = Image.fromarray(control_image)
control_image = fill_depth_circular(control_image, x, y, r)
return control_image
def process_sdxl_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):
if getattr(self, 'depth_estimator', None) is None:
self.depth_estimator = transformers_pipeline("depth-estimation", model=DEPTH_ESTIMATOR, device=self.device.index)
control_image = estimate_scene_depth(input_image, depth_estimator=self.depth_estimator)
xs = [x] if not isinstance(x, list) else x
ys = [y] if not isinstance(y, list) else y
rs = [r] if not isinstance(r, list) else r
for x, y, r in zip(xs, ys, rs):
#print(f"depth at {x}, {y}, {r}")
control_image = fill_depth_circular(control_image, x, y, r)
return control_image
def process_sd_normal(self, input_image, normal_ball, mask_ball, x, y, r=None, normal_ball_path=None):
if getattr(self, 'depth_estimator', None) is None:
self.depth_estimator = transformers_pipeline("depth-estimation", model=DEPTH_ESTIMATOR, device=self.device.index)
normal_scene = estimate_scene_normal(input_image, depth_estimator=self.depth_estimator)
normal_image = merge_normal_map(normal_scene, normal_ball, mask_ball, x, y)
normal_image = (normal_image * 127.5 + 127.5).clip(0, 255).astype(np.uint8)
control_image = Image.fromarray(normal_image)
return control_image
def __call__(self, *args, **kwargs):
process_fn = getattr(self, f"process_{self.sd_arch}_{self.control_signal_type}", None)
if process_fn is None:
raise ValueError
else:
return process_fn(*args, **kwargs)
class BallInpainter():
def __init__(self, pipeline, sd_arch, control_generator, disable_water_mask=True):
self.pipeline = pipeline
self.sd_arch = sd_arch
self.control_generator = control_generator
self.median = {}
if disable_water_mask:
self._disable_water_mask()
def _disable_water_mask(self):
if hasattr(self.pipeline, "watermark"):
self.pipeline.watermark = NoWaterMark()
print("Disabled watermasking")
@classmethod
def from_sd(cls,
model,
controlnet=None,
device=0,
sampler="unipc",
torch_dtype=torch.float16,
disable_water_mask=True,
offload=False
):
if controlnet is not None:
control_signal_type = get_control_signal_type(controlnet)
controlnet = ControlNetModel.from_pretrained(controlnet, torch_dtype=torch.float16)
pipe = CustomStableDiffusionControlNetInpaintPipeline.from_pretrained(
model,
controlnet=controlnet,
torch_dtype=torch_dtype,
).to(device)
control_generator = ControlSignalGenerator("sd", control_signal_type, device=device)
else:
|
class NoWaterMark:
def apply_watermark(self, *args, **kwargs):
return args[0]
class ControlSignalGenerator():
def __init__(self, sd_arch, control_signal_type, device):
self.sd_arch = sd_arch
self.control_signal_type = control_signal_type
self.device = device
def process_sd_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):
if getattr(self, 'depth_estimator', None) is None:
self.depth_estimator = transformers_pipeline("depth-estimation", device=self.device.index)
control_image = self.depth_estimator(input_image)['depth']
control_image = np.array(control_image)
control_image = control_image[:, :, None]
control_image = np.concatenate([control_image, control_image, control_image], axis=2)
control_image = Image.fromarray(control_image)
control_image = fill_depth_circular(control_image, x, y, r)
return control_image
def process_sdxl_depth(self, input_image, normal_ball=None, mask_ball=None, x=None, y=None, r=None):
if getattr(self, 'depth_estimator', None) is None:
self.depth_estimator = transformers_pipeline("depth-estimation", model=DEPTH_ESTIMATOR, device=self.device.index)
control_image = estimate_scene_depth(input_image, depth_estimator=self.depth_estimator)
xs = [x] if not isinstance(x, list) else x
ys = [y] if not isinstance(y, list) else y
rs = [r] if not isinstance(r, list) else r
for x, y, r in zip(xs, ys, rs):
#print(f"depth at {x}, {y}, {r}")
control_image = fill_depth_circular(control_image, x, y, r)
return control_image
def process_sd_normal(self, input_image, normal_ball, mask_ball, x, y, r=None, normal_ball_path=None):
if getattr(self, 'depth_estimator', None) is None:
self.depth_estimator = transformers_pipeline("depth-estimation", model=DEPTH_ESTIMATOR, device=self.device.index)
normal_scene = estimate_scene_normal(input_image, depth_estimator=self.depth_estimator)
normal_image = merge_normal_map(normal_scene, normal_ball, mask_ball, x, y)
normal_image = (normal_image * 127.5 + 127.5).clip(0, 255).astype(np.uint8)
control_image = Image.fromarray(normal_image)
return control_image
def __call__(self, *args, **kwargs):
process_fn = getattr(self, f"process_{self.sd_arch}_{self.control_signal_type}", None)
if process_fn is None:
raise ValueError
else:
return process_fn(*args, **kwargs)
class BallInpainter():
def __init__(self, pipeline, sd_arch, control_generator, disable_water_mask=True):
self.pipeline = pipeline
self.sd_arch = sd_arch
self.control_generator = control_generator
self.median = {}
if disable_water_mask:
self._disable_water_mask()
def _disable_water_mask(self):
if hasattr(self.pipeline, "watermark"):
self.pipeline.watermark = NoWaterMark()
print("Disabled watermasking")
@classmethod
def from_sd(cls,
model,
controlnet=None,
device=0,
sampler="unipc",
torch_dtype=torch.float16,
disable_water_mask=True,
offload=False
):
if controlnet is not None:
control_signal_type = get_control_signal_type(controlnet)
controlnet = ControlNetModel.from_pretrained(controlnet, torch_dtype=torch.float16)
pipe = CustomStableDiffusionControlNetInpaintPipeline.from_pretrained(
model,
controlnet=controlnet,
torch_dtype=torch_dtype,
).to(device)
control_generator = ControlSignalGenerator("sd", control_signal_type, device=device)
else: | pipe = CustomStableDiffusionInpaintPipeline.from_pretrained( | 1 | 2023-12-07 14:03:31+00:00 | 24k |
modelscope/normal-depth-diffusion | ldm/models/diffusion/wovae_ddpm.py | [
{
"identifier": "AutoencoderKL",
"path": "ldm/models/autoencoder.py",
"snippet": "class AutoencoderKL(pl.LightningModule):\n\n def __init__(self,\n ddconfig,\n lossconfig,\n embed_dim,\n ckpt_path=None,\n ignore_keys=[],\... | import pdb
import numpy as np
import pytorch_lightning as pl
import torch
import torch.nn as nn
import torch.nn.functional as F
from contextlib import contextmanager
from functools import partial
from einops import rearrange, repeat
from ldm.models.autoencoder import (AutoencoderKL, IdentityFirstStage,
VQModelInterface)
from ldm.models.diffusion.ddim import DDIMSampler
from ldm.models.diffusion.dpm_solver import DPMSolverSampler
from ldm.models.diffusion.plms import PLMSSampler
from ldm.modules.attention import CrossAttention
from ldm.modules.diffusionmodules.util import (extract_into_tensor,
make_beta_schedule, noise_like)
from ldm.modules.distributions.distributions import (
DiagonalGaussianDistribution, normal_kl)
from ldm.modules.ema import LitEma
from ldm.util import (count_params, default, exists, filter_nan_loss,
instantiate_from_config, isimage, ismap, log_txt_as_img,
mean_flat)
from torch.optim.lr_scheduler import LambdaLR
from torchvision.utils import make_grid
from tqdm import tqdm
from pytorch_lightning.utilities.distributed import rank_zero_only
from pytorch_lightning.utilities.rank_zero import rank_zero_only | 16,919 | 'image', 'LR_image', 'segmentation', 'bbox_img', 'ic'
] and self.model.conditioning_key: # todo check for completeness
c_key = next(iter(cond.keys())) # get key
c = next(iter(cond.values())) # get value
assert (len(c) == 1
) # todo extend to list with more than one elem
c = c[0] # get element
c = unfold(c)
c = c.view((c.shape[0], -1, ks[0], ks[1],
c.shape[-1])) # (bn, nc, ks[0], ks[1], L )
cond_list = [{
c_key: [c[:, :, :, :, i]]
} for i in range(c.shape[-1])]
elif self.cond_stage_key == 'coordinates_bbox':
assert 'original_image_size' in self.split_input_params, 'BoudingBoxRescaling is missing original_image_size'
# assuming padding of unfold is always 0 and its dilation is always 1
n_patches_per_row = int((w - ks[0]) / stride[0] + 1)
full_img_h, full_img_w = self.split_input_params[
'original_image_size']
# as we are operating on latents, we need the factor from the original image size to the
# spatial latent size to properly rescale the crops for regenerating the bbox annotations
num_downs = self.first_stage_model.encoder.num_resolutions - 1
rescale_latent = 2**(num_downs)
# get top left postions of patches as conforming for the bbbox tokenizer, therefore we
# need to rescale the tl patch coordinates to be in between (0,1)
tl_patch_coordinates = [
(rescale_latent * stride[0] *
(patch_nr % n_patches_per_row) / full_img_w,
rescale_latent * stride[1] *
(patch_nr // n_patches_per_row) / full_img_h)
for patch_nr in range(z.shape[-1])
]
# patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w)
patch_limits = [
(x_tl, y_tl, rescale_latent * ks[0] / full_img_w,
rescale_latent * ks[1] / full_img_h)
for x_tl, y_tl in tl_patch_coordinates
]
# patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates]
# tokenize crop coordinates for the bounding boxes of the respective patches
patch_limits_tknzd = [
torch.LongTensor(
self.bbox_tokenizer._crop_encoder(bbox))[None].to(
self.device) for bbox in patch_limits
] # list of length l with tensors of shape (1, 2)
print(patch_limits_tknzd[0].shape)
# cut tknzd crop position from conditioning
assert isinstance(
cond, dict), 'cond must be dict to be fed into model'
cut_cond = cond['c_crossattn'][0][..., :-2].to(self.device)
print(cut_cond.shape)
adapted_cond = torch.stack([
torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd
])
adapted_cond = rearrange(adapted_cond, 'l b n -> (l b) n')
print(adapted_cond.shape)
adapted_cond = self.get_learned_conditioning(adapted_cond)
print(adapted_cond.shape)
adapted_cond = rearrange(
adapted_cond, '(l b) n d -> l b n d', l=z.shape[-1])
print(adapted_cond.shape)
cond_list = [{'c_crossattn': [e]} for e in adapted_cond]
else:
cond_list = [cond for i in range(z.shape[-1])
] # Todo make this more efficient
# apply model by loop over crops
output_list = [
self.model(z_list[i], t, **cond_list[i])
for i in range(z.shape[-1])
]
assert not isinstance(
output_list[0], tuple
) # todo cant deal with multiple model outputs check this never happens
o = torch.stack(output_list, axis=-1)
o = o * weighting
# Reverse reshape to img shape
o = o.view(
(o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
x_recon = fold(o) / normalization
else:
x_recon = self.model(x_noisy, t, **cond)
if isinstance(x_recon, tuple) and not return_ids:
return x_recon[0]
else:
return x_recon
def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
def _prior_bpd(self, x_start):
"""
Get the prior KL term for the variational lower-bound, measured in
bits-per-dim.
This term can't be optimized, as it only depends on the encoder.
:param x_start: the [N x C x ...] tensor of inputs.
:return: a batch of [N] KL values (in bits), one per batch element.
"""
batch_size = x_start.shape[0]
t = torch.tensor(
[self.num_timesteps - 1] * batch_size, device=x_start.device)
qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
kl_prior = normal_kl(
mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)
| """
wild mixture of
https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py
https://github.com/CompVis/taming-transformers
this is without vae ddpm
-- merci
"""
try:
except:
__conditioning_keys__ = {
'concat': 'c_concat',
'crossattn': 'c_crossattn',
'adm': 'y'
}
def disabled_train(self, mode=True):
"""Overwrite model.train with this function to make sure train/eval mode
does not change anymore."""
return self
def uniform_on_device(r1, r2, shape, device):
return (r1 - r2) * torch.rand(*shape, device=device) + r2
class anneal_identity():
def __call__(self, x, global_step):
return x
def upper_bound(arr, key):
left = 0
right = len(arr)
while left < right:
mid = (left + right) >> 1
if arr[mid] < key:
left = mid + 1
else:
right = mid
return left
class anneal_warmup():
def __init__(self, anneal_ratio, anneal_global_step, num_steps):
self.anneal_ratio = anneal_ratio
self.anneal_global_step = anneal_global_step
self.steps = num_steps // (len(anneal_global_step) + 1)
self.start_steps = self.steps
def __call__(self, x, global_step):
if (torch.rand(1) > self.anneal_ratio).item():
return x
else:
return int(self.start_steps + self.start_steps
* upper_bound(self.anneal_global_step, global_step))
class DDPM(pl.LightningModule):
# classic DDPM with Gaussian diffusion, in image space
def __init__(
self,
unet_config,
timesteps=1000,
beta_schedule='linear',
loss_type='l2',
ckpt_path=None,
ignore_keys=[],
load_only_unet=False,
monitor='val/loss',
use_ema=True,
first_stage_key='image',
image_size=256,
channels=3,
log_every_t=100,
clip_denoised=True,
linear_start=1e-4,
linear_end=2e-2,
cosine_s=8e-3,
given_betas=None,
original_elbo_weight=0.,
v_posterior=0., # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta
l_simple_weight=1.,
conditioning_key=None,
parameterization='eps', # all assuming fixed variance schedules
scheduler_config=None,
use_positional_encodings=False,
learn_logvar=False,
logvar_init=0.,
anneal_t=False, # we find at the begining, smaller t, larger denoise mse loss.
anneal_global_step=[],
anneal_ratio=0.9,
prior_model=None,
prior_normal=None,
input_keys=['rgb'],
):
super().__init__()
assert parameterization in [
'eps', 'x0'
], 'currently only supporting "eps" and "x0"'
self.parameterization = parameterization
print(
f'{self.__class__.__name__}: Running in {self.parameterization}-prediction mode'
)
self.cond_stage_model = None
self.clip_denoised = clip_denoised
self.log_every_t = log_every_t
self.first_stage_key = first_stage_key
self.image_size = image_size # try conv?
self.channels = channels
self.use_positional_encodings = use_positional_encodings
self.model = DiffusionWrapper(unet_config, conditioning_key)
count_params(self.model, verbose=True)
self.use_ema = use_ema
if self.use_ema:
self.model_ema = LitEma(self.model)
print(f'Keeping EMAs of {len(list(self.model_ema.buffers()))}.')
self.use_scheduler = scheduler_config is not None
if self.use_scheduler:
self.scheduler_config = scheduler_config
self.v_posterior = v_posterior
self.original_elbo_weight = original_elbo_weight
self.l_simple_weight = l_simple_weight
self.input_keys = input_keys
if monitor is not None:
self.monitor = monitor
if ckpt_path is not None:
self.init_from_ckpt(
ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
self.register_schedule(
given_betas=given_betas,
beta_schedule=beta_schedule,
timesteps=timesteps,
linear_start=linear_start,
linear_end=linear_end,
cosine_s=cosine_s)
self.loss_type = loss_type
self.learn_logvar = learn_logvar
self.logvar = torch.full(
fill_value=logvar_init, size=(self.num_timesteps, ))
if self.learn_logvar:
self.logvar = nn.Parameter(self.logvar, requires_grad=True)
### anneal t function
if not anneal_t:
self.anneal_func = anneal_identity()
else:
self.anneal_func = anneal_warmup(anneal_ratio, anneal_global_step,
self.num_timesteps)
if prior_model is not None:
self.prior_model = instantiate_from_config(prior_model)
else:
self.prior_model = None
if prior_normal is not None:
self.prior_normal = instantiate_from_config(prior_normal)
else:
self.prior_normal = None
def register_schedule(self,
given_betas=None,
beta_schedule='linear',
timesteps=1000,
linear_start=1e-4,
linear_end=2e-2,
cosine_s=8e-3):
if exists(given_betas):
betas = given_betas
else:
betas = make_beta_schedule(
beta_schedule,
timesteps,
linear_start=linear_start,
linear_end=linear_end,
cosine_s=cosine_s)
alphas = 1. - betas
alphas_cumprod = np.cumprod(alphas, axis=0)
alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1])
timesteps, = betas.shape
self.num_timesteps = int(timesteps)
self.linear_start = linear_start
self.linear_end = linear_end
assert alphas_cumprod.shape[
0] == self.num_timesteps, 'alphas have to be defined for each timestep'
to_torch = partial(torch.tensor, dtype=torch.float32)
self.register_buffer('betas', to_torch(betas))
self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
self.register_buffer('alphas_cumprod_prev',
to_torch(alphas_cumprod_prev))
# calculations for diffusion q(x_t | x_{t-1}) and others
self.register_buffer('sqrt_alphas_cumprod',
to_torch(np.sqrt(alphas_cumprod)))
self.register_buffer('sqrt_one_minus_alphas_cumprod',
to_torch(np.sqrt(1. - alphas_cumprod)))
self.register_buffer('log_one_minus_alphas_cumprod',
to_torch(np.log(1. - alphas_cumprod)))
self.register_buffer('sqrt_recip_alphas_cumprod',
to_torch(np.sqrt(1. / alphas_cumprod)))
self.register_buffer('sqrt_recipm1_alphas_cumprod',
to_torch(np.sqrt(1. / alphas_cumprod - 1)))
# calculations for posterior q(x_{t-1} | x_t, x_0)
posterior_variance = (1 - self.v_posterior) * betas * (
1. - alphas_cumprod_prev) / (
1. - alphas_cumprod) + self.v_posterior * betas
# above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
self.register_buffer('posterior_variance',
to_torch(posterior_variance))
# below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain
self.register_buffer(
'posterior_log_variance_clipped',
to_torch(np.log(np.maximum(posterior_variance, 1e-20))))
self.register_buffer(
'posterior_mean_coef1',
to_torch(betas * np.sqrt(alphas_cumprod_prev) /
(1. - alphas_cumprod)))
self.register_buffer(
'posterior_mean_coef2',
to_torch((1. - alphas_cumprod_prev) * np.sqrt(alphas) /
(1. - alphas_cumprod)))
if self.parameterization == 'eps':
lvlb_weights = self.betas**2 / (2 * self.posterior_variance
* to_torch(alphas) *
(1 - self.alphas_cumprod))
elif self.parameterization == 'x0':
lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (
2. * 1 - torch.Tensor(alphas_cumprod))
else:
raise NotImplementedError('mu not supported')
# TODO how to choose this term
lvlb_weights[0] = lvlb_weights[1]
self.register_buffer('lvlb_weights', lvlb_weights, persistent=False)
assert not torch.isnan(self.lvlb_weights).all()
@contextmanager
def ema_scope(self, context=None):
if self.use_ema:
self.model_ema.store(self.model.parameters())
self.model_ema.copy_to(self.model)
if context is not None:
print(f'{context}: Switched to EMA weights')
try:
yield None
finally:
if self.use_ema:
self.model_ema.restore(self.model.parameters())
if context is not None:
print(f'{context}: Restored training weights')
def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
sd = torch.load(path, map_location='cpu')
if 'state_dict' in list(sd.keys()):
sd = sd['state_dict']
keys = list(sd.keys())
for k in keys:
for ik in ignore_keys:
if k.startswith(ik):
print('Deleting key {} from state_dict.'.format(k))
del sd[k]
missing, unexpected = self.load_state_dict(
sd,
strict=False) if not only_model else self.model.load_state_dict(
sd, strict=False)
print(
f'Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys'
)
if len(missing) > 0:
print(f'Missing Keys: {missing}')
if len(unexpected) > 0:
print(f'Unexpected Keys: {unexpected}')
if self.use_ema:
if len(missing) > 0:
model_ema_str = sorted(missing)[-1]
# missing model_ema
if 'model_ema' in model_ema_str:
print(f'Reinitialize model_ema')
self.model_ema = LitEma(self.model)
print(
f'Keeping EMAs of {len(list(self.model_ema.buffers()))}.'
)
else:
if self.ema_copy == True:
print(f'Reinitialize model_ema')
self.model_ema = LitEma(self.model)
print(
f'Keeping EMAs of {len(list(self.model_ema.buffers()))}.'
)
def q_mean_variance(self, x_start, t):
"""
Get the distribution q(x_t | x_0).
:param x_start: the [N x C x ...] tensor of noiseless inputs.
:param t: the number of diffusion steps (minus 1). Here, 0 means one step.
:return: A tuple (mean, variance, log_variance), all of x_start's shape.
"""
mean = (
extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape)
* x_start)
variance = extract_into_tensor(1.0 - self.alphas_cumprod, t,
x_start.shape)
log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod,
t, x_start.shape)
return mean, variance, log_variance
def predict_start_from_noise(self, x_t, t, noise):
return (
extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape)
* x_t - extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t,
x_t.shape) * noise)
def q_posterior(self, x_start, x_t, t):
posterior_mean = (
extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape)
* x_start +
extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t)
posterior_variance = extract_into_tensor(self.posterior_variance, t,
x_t.shape)
posterior_log_variance_clipped = extract_into_tensor(
self.posterior_log_variance_clipped, t, x_t.shape)
return posterior_mean, posterior_variance, posterior_log_variance_clipped
def p_mean_variance(self, x, t, clip_denoised: bool):
model_out = self.model(x, t)
if self.parameterization == 'eps':
x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
elif self.parameterization == 'x0':
x_recon = model_out
if clip_denoised:
x_recon.clamp_(-1., 1.)
model_mean, posterior_variance, posterior_log_variance = self.q_posterior(
x_start=x_recon, x_t=x, t=t)
return model_mean, posterior_variance, posterior_log_variance
@torch.no_grad()
def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
b, *_, device = *x.shape, x.device
model_mean, _, model_log_variance = self.p_mean_variance(
x=x, t=t, clip_denoised=clip_denoised)
noise = noise_like(x.shape, device, repeat_noise)
# no noise when t == 0
nonzero_mask = (1 - (t == 0).float()).reshape(
b, *((1, ) * (len(x.shape) - 1)))
return model_mean + nonzero_mask * (0.5
* model_log_variance).exp() * noise
@torch.no_grad()
def p_sample_loop(self, shape, return_intermediates=False):
device = self.betas.device
b = shape[0]
img = torch.randn(shape, device=device)
intermediates = [img]
for i in tqdm(
reversed(range(0, self.num_timesteps)),
desc='Sampling t',
total=self.num_timesteps):
img = self.p_sample(
img,
torch.full((b, ), i, device=device, dtype=torch.long),
clip_denoised=self.clip_denoised)
if i % self.log_every_t == 0 or i == self.num_timesteps - 1:
intermediates.append(img)
if return_intermediates:
return img, intermediates
return img
@torch.no_grad()
def sample(self, batch_size=16, return_intermediates=False):
image_size = self.image_size
channels = self.channels
return self.p_sample_loop(
(batch_size, channels, image_size, image_size),
return_intermediates=return_intermediates)
def q_sample(self, x_start, t, noise=None):
noise = default(noise, lambda: torch.randn_like(x_start))
return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape)
* x_start
+ extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t,
x_start.shape) * noise)
def get_loss(self, pred, target, mean=True):
if self.loss_type == 'l1':
loss = (target - pred).abs()
if mean:
loss = loss.mean()
elif self.loss_type == 'l2':
if mean:
loss = torch.nn.functional.mse_loss(target, pred)
else:
loss = torch.nn.functional.mse_loss(
target, pred, reduction='none')
else:
raise NotImplementedError("unknown loss type '{loss_type}'")
return loss
def p_losses(self, x_start, t, noise=None):
noise = default(noise, lambda: torch.randn_like(x_start))
x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
model_out = self.model(x_noisy, t)
loss_dict = {}
if self.parameterization == 'eps':
target = noise
elif self.parameterization == 'x0':
target = x_start
else:
raise NotImplementedError(
f'Paramterization {self.parameterization} not yet supported')
loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3])
log_prefix = 'train' if self.training else 'val'
loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()})
loss_simple = loss.mean() * self.l_simple_weight
loss_vlb = (self.lvlb_weights[t] * loss).mean()
loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb})
loss = loss_simple + self.original_elbo_weight * loss_vlb
loss_dict.update({f'{log_prefix}/loss': loss})
return loss, loss_dict
def forward(self, x, *args, **kwargs):
# b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size
# assert h == img_size and w == img_size, f'height and width of image must be {img_size}'
t = torch.randint(
0, self.num_timesteps, (x.shape[0], ), device=self.device).long()
return self.p_losses(x, t, *args, **kwargs)
def get_input(self, batch, k):
x = batch[k]
if len(x.shape) == 3:
x = x[..., None]
x = rearrange(x, 'b h w c -> b c h w')
x = x.to(memory_format=torch.contiguous_format).float()
return x
def shared_step(self, batch):
x = self.get_input(batch, self.first_stage_key)
loss, loss_dict = self(x)
return loss, loss_dict
# property of model for (to, cuda, cpu, float, half, ...)
def to(self, *args, **kwargs): # type: ignore[valid-type]
"""See :meth:`torch.nn.Module.to`."""
# this converts `str` device to `torch.device`
if self.prior_model is not None:
self.prior_model.to(*args, **kwargs)
if self.prior_normal is not None:
self.prior_normal.to(*args, **kwargs)
return super().to(*args, **kwargs)
def cuda(self, device=None): # type: ignore[valid-type]
"""Moves all model parameters and buffers to the GPU. This also makes associated parameters and buffers
different objects. So it should be called before constructing optimizer if the module will live on GPU
while being optimized.
Arguments:
device: If specified, all parameters will be copied to that device. If `None`, the current CUDA device
index will be used.
Returns:
Module: self
"""
if device is None:
device = torch.device('cuda', torch.cuda.current_device())
elif isinstance(device, int):
device = torch.device('cuda', index=device)
if self.prior_model is not None:
self.prior_model.cuda(device)
if self.prior_normal is not None:
self.prior_normal.cuda(device)
return super().cuda(device=device)
def cpu(self): # type: ignore[valid-type]
"""See :meth:`torch.nn.Module.cpu`."""
if self.prior_model is not None:
self.prior_model.cpu()
if self.prior_normal is not None:
self.prior_normal.cpu()
return super().cpu()
def float(self): # type: ignore[valid-type]
"""See :meth:`torch.nn.Module.float`."""
if self.prior_model is not None:
self.prior_model.float()
if self.prior_normal is not None:
self.prior_normal.float()
return super().float()
def double(self): # type: ignore[valid-type]
"""See :meth:`torch.nn.Module.double`."""
if self.prior_model is not None:
self.prior_model.double()
if self.prior_normal is not None:
self.prior_normal.double()
return super().double()
def half(self): # type: ignore[valid-type]
"""See :meth:`torch.nn.Module.half`."""
if self.prior_model is not None:
self.prior_model.half()
if self.prior_normal is not None:
self.prior_normal.half()
return super().half()
def prior_to_eval(self):
if self.prior_model is not None:
self.prior_model.eval()
if self.prior_normal is not None:
self.prior_normal.eval()
@torch.no_grad()
def prior_inference(self, inputs, prior_inputs):
# depth prior model
# midas or zoe is 384 model
inputs = inputs.permute(0, 3, 1, 2)
prior_results = {}
self.prior_to_eval()
# using depth prior
if self.prior_model is not None:
model_prior_results = self.prior_model(prior_inputs)
prior_results.update(model_prior_results)
# using normal map
if self.prior_normal is not None:
normal_prior_results = self.prior_normal(prior_inputs)
prior_results.update(normal_prior_results)
resize_prior_results = {}
_, __, h, w = inputs.shape
for key in prior_results.keys():
resize_prior_results[key] = F.interpolate(
prior_results[key], (w, h), mode='bilinear')
# add a rgb input
resize_prior_results.update({'rgb': inputs})
input_container = []
for key in self.input_keys:
input_container.append(resize_prior_results[key])
return torch.cat(input_container, dim=1).permute(0, 2, 3, 1)
@torch.no_grad()
def collect_inputs(self, batch):
input_container = []
for key in self.input_keys:
# [B H W C]
input_container.append(batch[key])
return torch.cat(input_container, dim=-1)
def training_step(self, batch, batch_idx):
if self.prior_model is not None:
batch['image'] = self.prior_inference(batch['image'],
batch['prior'])
# image_condition
batch['ic'] = batch['image'][..., :3]
else:
batch['image'] = self.collect_inputs(batch)
# image_condition
batch['ic'] = batch['image'][..., :3]
loss, loss_dict = self.shared_step(batch)
self.log_dict(
loss_dict, prog_bar=True, logger=True, on_step=True, on_epoch=True)
self.log(
'global_step',
self.global_step,
prog_bar=True,
logger=True,
on_step=True,
on_epoch=False)
if self.use_scheduler:
lr = self.optimizers().param_groups[0]['lr']
self.log(
'lr_abs',
lr,
prog_bar=True,
logger=True,
on_step=True,
on_epoch=False)
return loss
@torch.no_grad()
def validation_step(self, batch, batch_idx):
if self.prior_model is not None:
batch['image'] = self.prior_inference(batch['image'],
batch['prior'])
# image_condition
batch['ic'] = batch['image'][..., :3]
else:
batch['image'] = self.collect_inputs(batch)
# image_condition
batch['ic'] = batch['image'][..., :3]
_, loss_dict_no_ema = self.shared_step(batch)
with self.ema_scope():
_, loss_dict_ema = self.shared_step(batch)
loss_dict_ema = {
key + '_ema': loss_dict_ema[key]
for key in loss_dict_ema
}
self.log_dict(
loss_dict_no_ema,
prog_bar=False,
logger=True,
on_step=False,
on_epoch=True)
self.log_dict(
loss_dict_ema,
prog_bar=False,
logger=True,
on_step=False,
on_epoch=True)
@torch.no_grad()
def test_step(self, batch, batch_idx):
if self.prior_model is not None:
batch['image'] = self.prior_inference(batch['image'],
batch['prior'])
# image_condition
batch['ic'] = batch['image'][..., :3]
else:
batch['image'] = self.collect_inputs(batch)
# image_condition
batch['ic'] = batch['image'][..., :3]
with self.ema_scope():
_, loss_dict_ema = self.shared_step(batch)
loss_dict_ema = {
key + '_ema': loss_dict_ema[key]
for key in loss_dict_ema
}
self.log_dict(
loss_dict_ema,
prog_bar=False,
logger=True,
on_step=False,
on_epoch=True)
def on_train_batch_end(self, *args, **kwargs):
# args: outputs, batch, batch_idx
if self.use_ema:
self.model_ema(self.model)
def _get_rows_from_list(self, samples):
n_imgs_per_row = len(samples)
denoise_grid = rearrange(samples, 'n b c h w -> b n c h w')
denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
return denoise_grid
@torch.no_grad()
def log_images(self,
batch,
N=8,
n_row=2,
sample=True,
return_keys=None,
**kwargs):
log = dict()
x = self.get_input(batch, self.first_stage_key)
N = min(x.shape[0], N)
n_row = min(x.shape[0], n_row)
x = x.to(self.device)[:N]
log['inputs'] = x
# get diffusion row
diffusion_row = list()
x_start = x[:n_row]
for t in range(self.num_timesteps):
if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
t = t.to(self.device).long()
noise = torch.randn_like(x_start)
x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
diffusion_row.append(x_noisy)
log['diffusion_row'] = self._get_rows_from_list(diffusion_row)
if sample:
# get denoise row
with self.ema_scope('Plotting'):
samples, denoise_row = self.sample(
batch_size=N, return_intermediates=True)
log['samples'] = samples
log['denoise_row'] = self._get_rows_from_list(denoise_row)
if return_keys:
if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
return log
else:
return {key: log[key] for key in return_keys}
return log
def configure_optimizers(self):
lr = self.learning_rate
params = list(self.model.parameters())
if self.learn_logvar:
params = params + [self.logvar]
opt = torch.optim.AdamW(params, lr=lr)
return opt
class LatentDiffusion(DDPM):
"""main class"""
def __init__(self,
first_stage_config,
cond_stage_config,
num_timesteps_cond=None,
cond_stage_key='image',
cond_stage_trainable=False,
concat_mode=True,
cond_stage_forward=None,
conditioning_key=None,
scale_factor=1.0,
scale_by_std=False,
first_stage_ckpts=None,
without_crossattn=False,
ema_copy=False,
*args,
**kwargs):
self.num_timesteps_cond = default(num_timesteps_cond, 1)
self.scale_by_std = scale_by_std
assert self.num_timesteps_cond <= kwargs['timesteps']
# for backwards compatibility after implementation of DiffusionWrapper
if conditioning_key is None:
conditioning_key = 'concat' if concat_mode else 'crossattn'
if cond_stage_config == '__is_unconditional__':
conditioning_key = None
ckpt_path = kwargs.pop('ckpt_path', None)
ignore_keys = kwargs.pop('ignore_keys', [])
super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
self.concat_mode = concat_mode
self.cond_stage_trainable = cond_stage_trainable
self.cond_stage_key = cond_stage_key
try:
self.num_downs = len(
first_stage_config.params.ddconfig.ch_mult) - 1
except:
self.num_downs = 0
if not scale_by_std:
self.scale_factor = scale_factor
else:
self.register_buffer('scale_factor', torch.tensor(scale_factor))
self.first_stage_ckpts = first_stage_ckpts
# VAE Load
self.instantiate_first_stage(first_stage_config)
# CLIP load
self.instantiate_cond_stage(cond_stage_config)
self.cond_stage_forward = cond_stage_forward
self.clip_denoised = False
self.bbox_tokenizer = None
self.restarted_from_ckpt = False
self.ema_copy = ema_copy
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys)
self.restarted_from_ckpt = True
if self.first_stage_ckpts is not None:
first_stage_ckpts = torch.load(
self.first_stage_ckpts, map_location='cpu')
no_match = self.first_stage_model.load_state_dict(
first_stage_ckpts['state_dict'], strict=False)
print('encode-decode, no match keys:\n {}'.format(no_match))
for param in self.first_stage_model.parameters():
param.requires_grad = False
# lambda-stage-1 without crossattn
if without_crossattn:
for m in self.modules():
if isinstance(m, CrossAttention):
for para in m.parameters():
para.requires_grad = False
# RuntimeError: One of the differentiated Tensors does not require grad
def make_cond_schedule(self, ):
self.cond_ids = torch.full(
size=(self.num_timesteps, ),
fill_value=self.num_timesteps - 1,
dtype=torch.long)
ids = torch.round(
torch.linspace(0, self.num_timesteps - 1,
self.num_timesteps_cond)).long()
self.cond_ids[:self.num_timesteps_cond] = ids
@rank_zero_only
@torch.no_grad()
def on_train_batch_start(self, batch, batch_idx):
# only for very first batch
if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:
assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'
# set rescale weight to 1./std of encodings
print('### USING STD-RESCALING ###')
x = super().get_input(batch, self.first_stage_key)
x = x.to(self.device)
encoder_posterior = self.encode_first_stage(x)
z = self.get_first_stage_encoding(encoder_posterior).detach()
del self.scale_factor
self.register_buffer('scale_factor', 1. / z.flatten().std())
print(f'setting self.scale_factor to {self.scale_factor}')
print('### USING STD-RESCALING ###')
def register_schedule(self,
given_betas=None,
beta_schedule='linear',
timesteps=1000,
linear_start=1e-4,
linear_end=2e-2,
cosine_s=8e-3):
super().register_schedule(given_betas, beta_schedule, timesteps,
linear_start, linear_end, cosine_s)
self.shorten_cond_schedule = self.num_timesteps_cond > 1
if self.shorten_cond_schedule:
self.make_cond_schedule()
def instantiate_first_stage(self, config):
model = instantiate_from_config(config)
self.first_stage_model = model.eval()
self.first_stage_model.train = disabled_train
for param in self.first_stage_model.parameters():
param.requires_grad = False
def instantiate_cond_stage(self, config):
if not self.cond_stage_trainable:
if config == '__is_first_stage__':
print('Using first stage also as cond stage.')
self.cond_stage_model = self.first_stage_model
elif config == '__is_unconditional__':
print(
f'Training {self.__class__.__name__} as an unconditional model.'
)
self.cond_stage_model = None
# self.be_unconditional = True
else:
model = instantiate_from_config(config)
self.cond_stage_model = model.eval()
self.cond_stage_model.train = disabled_train
for param in self.cond_stage_model.parameters():
param.requires_grad = False
else:
assert config != '__is_first_stage__'
assert config != '__is_unconditional__'
model = instantiate_from_config(config)
self.cond_stage_model = model
def _get_denoise_row_from_list(self,
samples,
desc='',
force_no_decoder_quantization=False):
denoise_row = []
for zd in tqdm(samples, desc=desc):
denoise_row.append(
self.decode_first_stage(
zd.to(self.device),
force_not_quantize=force_no_decoder_quantization))
n_imgs_per_row = len(denoise_row)
denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W
denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')
denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
return denoise_grid
def get_first_stage_encoding(self, encoder_posterior):
if isinstance(encoder_posterior, DiagonalGaussianDistribution):
z = encoder_posterior.sample()
elif isinstance(encoder_posterior, torch.Tensor):
z = encoder_posterior
else:
raise NotImplementedError(
f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented"
)
return self.scale_factor * z
def get_learned_conditioning(self, c):
'''
# CLIP embedding
'''
if self.cond_stage_forward is None:
if hasattr(self.cond_stage_model, 'encode') and callable(
self.cond_stage_model.encode):
c = self.cond_stage_model.encode(c)
if isinstance(c, DiagonalGaussianDistribution):
c = c.mode()
else:
c = self.cond_stage_model(c)
else:
assert hasattr(self.cond_stage_model, self.cond_stage_forward)
c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
return c
def meshgrid(self, h, w):
y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)
x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)
arr = torch.cat([y, x], dim=-1)
return arr
def delta_border(self, h, w):
"""
:param h: height
:param w: width
:return: normalized distance to image border,
wtith min distance = 0 at border and max dist = 0.5 at image center
"""
lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)
arr = self.meshgrid(h, w) / lower_right_corner
dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]
dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]
edge_dist = torch.min(
torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]
return edge_dist
def get_weighting(self, h, w, Ly, Lx, device):
weighting = self.delta_border(h, w)
weighting = torch.clip(
weighting,
self.split_input_params['clip_min_weight'],
self.split_input_params['clip_max_weight'],
)
weighting = weighting.view(1, h * w, 1).repeat(1, 1,
Ly * Lx).to(device)
if self.split_input_params['tie_braker']:
L_weighting = self.delta_border(Ly, Lx)
L_weighting = torch.clip(
L_weighting, self.split_input_params['clip_min_tie_weight'],
self.split_input_params['clip_max_tie_weight'])
L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)
weighting = weighting * L_weighting
return weighting
def get_fold_unfold(self,
x,
kernel_size,
stride,
uf=1,
df=1): # todo load once not every time, shorten code
"""
:param x: img of size (bs, c, h, w)
:return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])
"""
bs, nc, h, w = x.shape
# number of crops in image
Ly = (h - kernel_size[0]) // stride[0] + 1
Lx = (w - kernel_size[1]) // stride[1] + 1
if uf == 1 and df == 1:
fold_params = dict(
kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
unfold = torch.nn.Unfold(**fold_params)
fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)
weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly,
Lx, x.device).to(x.dtype)
normalization = fold(weighting).view(1, 1, h,
w) # normalizes the overlap
weighting = weighting.view(
(1, 1, kernel_size[0], kernel_size[1], Ly * Lx))
elif uf > 1 and df == 1:
fold_params = dict(
kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
unfold = torch.nn.Unfold(**fold_params)
fold_params2 = dict(
kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),
dilation=1,
padding=0,
stride=(stride[0] * uf, stride[1] * uf))
fold = torch.nn.Fold(
output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)
weighting = self.get_weighting(kernel_size[0] * uf,
kernel_size[1] * uf, Ly, Lx,
x.device).to(x.dtype)
normalization = fold(weighting).view(
1, 1, h * uf, w * uf) # normalizes the overlap
weighting = weighting.view(
(1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))
elif df > 1 and uf == 1:
fold_params = dict(
kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
unfold = torch.nn.Unfold(**fold_params)
fold_params2 = dict(
kernel_size=(kernel_size[0] // df, kernel_size[0] // df),
dilation=1,
padding=0,
stride=(stride[0] // df, stride[1] // df))
fold = torch.nn.Fold(
output_size=(x.shape[2] // df, x.shape[3] // df),
**fold_params2)
weighting = self.get_weighting(kernel_size[0] // df,
kernel_size[1] // df, Ly, Lx,
x.device).to(x.dtype)
normalization = fold(weighting).view(
1, 1, h // df, w // df) # normalizes the overlap
weighting = weighting.view(
(1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))
else:
raise NotImplementedError
return fold, unfold, normalization, weighting
'''
@torch.no_grad()
def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,
cond_key=None, return_original_cond=False, bs=None):
x = super().get_input(batch, k)
if bs is not None:
x = x[:bs]
x = x.to(self.device)
encoder_posterior = self.encode_first_stage(x)
z = self.get_first_stage_encoding(encoder_posterior).detach()
if self.model.conditioning_key is not None:
if cond_key is None:
cond_key = self.cond_stage_key
if cond_key != self.first_stage_key:
if cond_key in ['caption', 'coordinates_bbox']:
xc = batch[cond_key]
elif cond_key == 'class_label':
xc = batch
else:
xc = super().get_input(batch, cond_key).to(self.device)
else:
xc = x
if not self.cond_stage_trainable or force_c_encode:
if isinstance(xc, dict) or isinstance(xc, list):
# import pudb; pudb.set_trace()
c = self.get_learned_conditioning(xc)
else:
c = self.get_learned_conditioning(xc.to(self.device))
else:
c = xc
if bs is not None:
c = c[:bs]
if self.use_positional_encodings:
pos_x, pos_y = self.compute_latent_shifts(batch)
ckey = __conditioning_keys__[self.model.conditioning_key]
c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}
else:
c = None
xc = None
if self.use_positional_encodings:
pos_x, pos_y = self.compute_latent_shifts(batch)
c = {'pos_x': pos_x, 'pos_y': pos_y}
out = [z, c]
if return_first_stage_outputs:
xrec = self.decode_first_stage(z)
out.extend([x, xrec])
if return_original_cond:
out.append(xc)
return out
'''
@torch.no_grad()
def get_input(self,
batch,
k,
return_first_stage_outputs=False,
force_c_encode=False,
cond_key=None,
return_original_cond=False,
bs=None,
uncond=0.1):
''' we add uncondition prompts to improve classifer-free guidance results
'''
x = super().get_input(batch, k)
if bs is not None:
x = x[:bs]
x = x.to(self.device)
'''
encoder_posterior = self.encode_first_stage(x)
z = self.get_first_stage_encoding(encoder_posterior).detach()
'''
_, _c, _h, _w = x.shape
z = F.interpolate(
x, (_w // 8, _h // 8), mode='bilinear', align_corners=False)
if self.model.conditioning_key is not None:
if cond_key is None:
cond_key = self.cond_stage_key
if cond_key != self.first_stage_key:
if cond_key in ['caption', 'coordinates_bbox']:
xc = batch[cond_key]
elif cond_key == 'class_label':
xc = batch
else:
xc = super().get_input(batch, cond_key).to(self.device)
else:
xc = x
if not self.cond_stage_trainable or force_c_encode:
if isinstance(xc, dict) or isinstance(xc, list):
# import pudb; pudb.set_trace()
c = self.get_learned_conditioning(xc)
else:
c = self.get_learned_conditioning(xc.to(self.device))
else:
c = xc
if bs is not None:
c = c[:bs]
if self.use_positional_encodings:
pos_x, pos_y = self.compute_latent_shifts(batch)
ckey = __conditioning_keys__[self.model.conditioning_key]
c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}
else:
c = None
xc = None
if self.use_positional_encodings:
pos_x, pos_y = self.compute_latent_shifts(batch)
c = {'pos_x': pos_x, 'pos_y': pos_y}
# To support classifier-free guidance, randomly drop out only text conditioning 10% like sd-v1.5
random = torch.rand(x.size(0), device=x.device)
prompt_mask = rearrange(random < uncond, 'n -> n 1 1')
null_prompts = self.get_learned_conditioning(['']).to(c.device)
cc = torch.where(prompt_mask, null_prompts, c)
out = [z, cc]
if return_first_stage_outputs:
xrec = F.interpolate(
z, (_w, _h), mode='bilinear', align_corners=False)
out.extend([x, xrec])
if return_original_cond:
out.append(xc)
return out
@torch.no_grad()
def decode_first_stage(self,
z,
predict_cids=False,
force_not_quantize=False):
if predict_cids:
if z.dim() == 4:
z = torch.argmax(z.exp(), dim=1).long()
z = self.first_stage_model.quantize.get_codebook_entry(
z, shape=None)
z = rearrange(z, 'b h w c -> b c h w').contiguous()
z = 1. / self.scale_factor * z
if hasattr(self, 'split_input_params'):
if self.split_input_params['patch_distributed_vq']:
ks = self.split_input_params['ks'] # eg. (128, 128)
stride = self.split_input_params['stride'] # eg. (64, 64)
uf = self.split_input_params['vqf']
bs, nc, h, w = z.shape
if ks[0] > h or ks[1] > w:
ks = (min(ks[0], h), min(ks[1], w))
print('reducing Kernel')
if stride[0] > h or stride[1] > w:
stride = (min(stride[0], h), min(stride[1], w))
print('reducing stride')
fold, unfold, normalization, weighting = self.get_fold_unfold(
z, ks, stride, uf=uf)
z = unfold(z) # (bn, nc * prod(**ks), L)
# 1. Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1],
z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
# 2. apply model loop over last dim
if isinstance(self.first_stage_model, VQModelInterface):
output_list = [
self.first_stage_model.decode(
z[:, :, :, :, i],
force_not_quantize=predict_cids
or force_not_quantize) for i in range(z.shape[-1])
]
else:
output_list = [
self.first_stage_model.decode(z[:, :, :, :, i])
for i in range(z.shape[-1])
]
o = torch.stack(
output_list, axis=-1) # # (bn, nc, ks[0], ks[1], L)
o = o * weighting
# Reverse 1. reshape to img shape
o = o.view((o.shape[0], -1,
o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
decoded = fold(o)
decoded = decoded / normalization # norm is shape (1, 1, h, w)
return decoded
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(
z,
force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(
z, force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
# same as above but without decorator
def differentiable_decode_first_stage(self,
z,
predict_cids=False,
force_not_quantize=False):
if predict_cids:
if z.dim() == 4:
z = torch.argmax(z.exp(), dim=1).long()
z = self.first_stage_model.quantize.get_codebook_entry(
z, shape=None)
z = rearrange(z, 'b h w c -> b c h w').contiguous()
z = 1. / self.scale_factor * z
if hasattr(self, 'split_input_params'):
if self.split_input_params['patch_distributed_vq']:
ks = self.split_input_params['ks'] # eg. (128, 128)
stride = self.split_input_params['stride'] # eg. (64, 64)
uf = self.split_input_params['vqf']
bs, nc, h, w = z.shape
if ks[0] > h or ks[1] > w:
ks = (min(ks[0], h), min(ks[1], w))
print('reducing Kernel')
if stride[0] > h or stride[1] > w:
stride = (min(stride[0], h), min(stride[1], w))
print('reducing stride')
fold, unfold, normalization, weighting = self.get_fold_unfold(
z, ks, stride, uf=uf)
z = unfold(z) # (bn, nc * prod(**ks), L)
# 1. Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1],
z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
# 2. apply model loop over last dim
if isinstance(self.first_stage_model, VQModelInterface):
output_list = [
self.first_stage_model.decode(
z[:, :, :, :, i],
force_not_quantize=predict_cids
or force_not_quantize) for i in range(z.shape[-1])
]
else:
output_list = [
self.first_stage_model.decode(z[:, :, :, :, i])
for i in range(z.shape[-1])
]
o = torch.stack(
output_list, axis=-1) # # (bn, nc, ks[0], ks[1], L)
o = o * weighting
# Reverse 1. reshape to img shape
o = o.view((o.shape[0], -1,
o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
decoded = fold(o)
decoded = decoded / normalization # norm is shape (1, 1, h, w)
return decoded
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(
z,
force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(
z, force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
@torch.no_grad()
def encode_first_stage(self, x):
if hasattr(self, 'split_input_params'):
if self.split_input_params['patch_distributed_vq']:
ks = self.split_input_params['ks'] # eg. (128, 128)
stride = self.split_input_params['stride'] # eg. (64, 64)
df = self.split_input_params['vqf']
self.split_input_params['original_image_size'] = x.shape[-2:]
bs, nc, h, w = x.shape
if ks[0] > h or ks[1] > w:
ks = (min(ks[0], h), min(ks[1], w))
print('reducing Kernel')
if stride[0] > h or stride[1] > w:
stride = (min(stride[0], h), min(stride[1], w))
print('reducing stride')
fold, unfold, normalization, weighting = self.get_fold_unfold(
x, ks, stride, df=df)
z = unfold(x) # (bn, nc * prod(**ks), L)
# Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1],
z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
output_list = [
self.first_stage_model.encode(z[:, :, :, :, i])
for i in range(z.shape[-1])
]
o = torch.stack(output_list, axis=-1)
o = o * weighting
# Reverse reshape to img shape
o = o.view((o.shape[0], -1,
o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
decoded = fold(o)
decoded = decoded / normalization
return decoded
else:
return self.first_stage_model.encode(x)
else:
return self.first_stage_model.encode(x)
def shared_step(self, batch, **kwargs):
# obtain encode(x), conditon
x, c = self.get_input(batch, self.first_stage_key)
# ddpm
loss = self(x, c)
return loss
def guassian_distributed(self, x, sigma=100):
y = torch.exp(-(x)**2 / (2 * sigma**2))
return y / y.sum()
def forward(self, x, c, *args, **kwargs):
# anneal t finetune
num_timesteps = self.anneal_func(self.num_timesteps, self.global_step)
t = torch.randint(
0, num_timesteps, (x.shape[0], ), device=self.device).long()
if self.model.conditioning_key is not None:
assert c is not None
if self.cond_stage_trainable:
c = self.get_learned_conditioning(c)
if self.shorten_cond_schedule: # TODO: drop this option
tc = self.cond_ids[t].to(self.device)
c = self.q_sample(
x_start=c, t=tc, noise=torch.randn_like(c.float()))
return self.p_losses(x, c, t, *args, **kwargs)
def _rescale_annotations(self, bboxes,
crop_coordinates): # TODO: move to dataset
def rescale_bbox(bbox):
x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2])
y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3])
w = min(bbox[2] / crop_coordinates[2], 1 - x0)
h = min(bbox[3] / crop_coordinates[3], 1 - y0)
return x0, y0, w, h
return [rescale_bbox(b) for b in bboxes]
def apply_model(self, x_noisy, t, cond, return_ids=False):
if isinstance(cond, dict):
# hybrid case, cond is exptected to be a dict
pass
else:
if not isinstance(cond, list):
cond = [cond]
key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
cond = {key: cond}
if hasattr(self, 'split_input_params'):
assert len(
cond) == 1 # todo can only deal with one conditioning atm
assert not return_ids
ks = self.split_input_params['ks'] # eg. (128, 128)
stride = self.split_input_params['stride'] # eg. (64, 64)
h, w = x_noisy.shape[-2:]
fold, unfold, normalization, weighting = self.get_fold_unfold(
x_noisy, ks, stride)
z = unfold(x_noisy) # (bn, nc * prod(**ks), L)
# Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1],
z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
z_list = [z[:, :, :, :, i] for i in range(z.shape[-1])]
if self.cond_stage_key in [
'image', 'LR_image', 'segmentation', 'bbox_img', 'ic'
] and self.model.conditioning_key: # todo check for completeness
c_key = next(iter(cond.keys())) # get key
c = next(iter(cond.values())) # get value
assert (len(c) == 1
) # todo extend to list with more than one elem
c = c[0] # get element
c = unfold(c)
c = c.view((c.shape[0], -1, ks[0], ks[1],
c.shape[-1])) # (bn, nc, ks[0], ks[1], L )
cond_list = [{
c_key: [c[:, :, :, :, i]]
} for i in range(c.shape[-1])]
elif self.cond_stage_key == 'coordinates_bbox':
assert 'original_image_size' in self.split_input_params, 'BoudingBoxRescaling is missing original_image_size'
# assuming padding of unfold is always 0 and its dilation is always 1
n_patches_per_row = int((w - ks[0]) / stride[0] + 1)
full_img_h, full_img_w = self.split_input_params[
'original_image_size']
# as we are operating on latents, we need the factor from the original image size to the
# spatial latent size to properly rescale the crops for regenerating the bbox annotations
num_downs = self.first_stage_model.encoder.num_resolutions - 1
rescale_latent = 2**(num_downs)
# get top left postions of patches as conforming for the bbbox tokenizer, therefore we
# need to rescale the tl patch coordinates to be in between (0,1)
tl_patch_coordinates = [
(rescale_latent * stride[0] *
(patch_nr % n_patches_per_row) / full_img_w,
rescale_latent * stride[1] *
(patch_nr // n_patches_per_row) / full_img_h)
for patch_nr in range(z.shape[-1])
]
# patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w)
patch_limits = [
(x_tl, y_tl, rescale_latent * ks[0] / full_img_w,
rescale_latent * ks[1] / full_img_h)
for x_tl, y_tl in tl_patch_coordinates
]
# patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates]
# tokenize crop coordinates for the bounding boxes of the respective patches
patch_limits_tknzd = [
torch.LongTensor(
self.bbox_tokenizer._crop_encoder(bbox))[None].to(
self.device) for bbox in patch_limits
] # list of length l with tensors of shape (1, 2)
print(patch_limits_tknzd[0].shape)
# cut tknzd crop position from conditioning
assert isinstance(
cond, dict), 'cond must be dict to be fed into model'
cut_cond = cond['c_crossattn'][0][..., :-2].to(self.device)
print(cut_cond.shape)
adapted_cond = torch.stack([
torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd
])
adapted_cond = rearrange(adapted_cond, 'l b n -> (l b) n')
print(adapted_cond.shape)
adapted_cond = self.get_learned_conditioning(adapted_cond)
print(adapted_cond.shape)
adapted_cond = rearrange(
adapted_cond, '(l b) n d -> l b n d', l=z.shape[-1])
print(adapted_cond.shape)
cond_list = [{'c_crossattn': [e]} for e in adapted_cond]
else:
cond_list = [cond for i in range(z.shape[-1])
] # Todo make this more efficient
# apply model by loop over crops
output_list = [
self.model(z_list[i], t, **cond_list[i])
for i in range(z.shape[-1])
]
assert not isinstance(
output_list[0], tuple
) # todo cant deal with multiple model outputs check this never happens
o = torch.stack(output_list, axis=-1)
o = o * weighting
# Reverse reshape to img shape
o = o.view(
(o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
x_recon = fold(o) / normalization
else:
x_recon = self.model(x_noisy, t, **cond)
if isinstance(x_recon, tuple) and not return_ids:
return x_recon[0]
else:
return x_recon
def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
def _prior_bpd(self, x_start):
"""
Get the prior KL term for the variational lower-bound, measured in
bits-per-dim.
This term can't be optimized, as it only depends on the encoder.
:param x_start: the [N x C x ...] tensor of inputs.
:return: a batch of [N] KL values (in bits), one per batch element.
"""
batch_size = x_start.shape[0]
t = torch.tensor(
[self.num_timesteps - 1] * batch_size, device=x_start.device)
qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
kl_prior = normal_kl(
mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0) | return mean_flat(kl_prior) / np.log(2.0) | 21 | 2023-12-06 07:29:34+00:00 | 24k |
RobertCsordas/moe_attention | tasks/simple/language_model/transformer_lm_mixin.py | [
{
"identifier": "TransformerLanguageModel",
"path": "models/transformer_language_model.py",
"snippet": "class TransformerLanguageModel(LoggingLayer, torch.nn.Module):\n def __init__(self, voc_size: int, embedding_size: Optional[int], state_size: int, dropout: float,\n tied_embedding: ... | import framework
import torch
import torch.nn
import torch.nn.functional as F
import torch.utils.data
import math
from typing import List, Tuple, Dict, Any
from models import TransformerLanguageModel
from ... import task, args
from layers.transformer import RelativeTransformerEncoderLayer, PrelnRelativeTransformerEncoderLayer
from layers.transformer.relative_moe_transformer import RelativeMoeTransformerEncoderLayer
from layers.transformer.fast_rope_transformer import FastRopeTransformerEncoderLayer
from layers.transformer.moe_attention_relative_transformer import MoeAttentionRelativeTransformerEncoderLayer
from layers.moe_layer import MoE
from interfaces import Result
from layers import LayerVisualizer
from layers.transformer.full_moe_relative_attention import FullMoeRelativeAttentionCore | 19,108 |
@args
def a(parser: framework.helpers.ArgumentParser):
parser.add_argument("-lm.trafo.context_blocks", default=1)
parser.add_argument("-lm.trafo.test_context_blocks", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-lm.trafo.test_pos_clamp", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-lm.trafo.same_length_eval", default=False)
parser.add_argument("-lm.trafo.same_length", default=False)
parser.add_argument("-lm.trafo.last_layer_context", default=False)
parser.add_argument("-lm.trafo.xl_init", default=False)
parser.add_argument("-lm.trafo.embedding_mode_init", default="default", choice=["default", "scale_to_sqrt_dmodel", "init_to_sqrt_dmodel", "one_and_scale_to_sqrt_dmodel", "like_preln"])
parser.add_argument("-pkm.n_heads", default=1)
parser.add_argument("-moe.n_experts", default=128)
parser.add_argument("-moe.expert_size", default=128)
parser.add_argument("-moe.selection_mode", default="sigmoid", choice=["gate", "sigmoid", "mul"])
parser.add_argument("-moe.perplexity_reg", default=0.0)
parser.add_argument("-moe.perplexity_reg_mode", default="step", choice=["step", "global", "time", "global_time"])
parser.add_argument("-moe.reg_type", default="entropy", choice=["perplexity", "variance", "entropy", "l2", "switch", "normal"])
parser.add_argument("-moe.norm_keys", default=False)
parser.add_argument("-moe.n_random", default=0)
parser.add_argument("-moe.topk_mode", default="full", choice=["full", "l1_approx", "approx"])
parser.add_argument("-moe.activation_after_topk", default=False)
parser.add_argument("-moe.drop_parallel", default=True)
parser.add_argument("-moe.norm_key_init", default=False)
parser.add_argument("-moe.norm_value_init", default=False)
parser.add_argument("-moe.identical_init", default=False)
parser.add_argument("-moe.sel_lr_multipler", default=1.0)
parser.add_argument("-moe.expert_lr_multipler", default=1.0)
parser.add_argument("-moe.sel_norm", default="none", choice=["none", "cos", "input", "weights"])
parser.add_argument("-moe.dropout_factor", default=1.0)
parser.add_argument("-moe.drop_expert", default=0.0)
parser.add_argument("-moe.sync_distributed", default=True)
parser.add_argument("-moe.modulation_amplitude", default=0.5)
parser.add_argument("-moe.init_scale", default=1.0)
parser.add_argument("-moe.norm_expert_sel_init", default=False)
parser.add_argument("-kvmem.dropout", default="none", choice=["none", "early", "late", "weight", "score"])
parser.add_argument("-kvmem.norm_values", default=False)
parser.add_argument("-transformer.topk_value", default=32)
parser.add_argument("-transformer.activation", default="relu", choice=["relu", "topk", "gelu", "identity", "sigmoid", "softmax"])
parser.add_argument("-transformer.p_drop_layer", default=0.0)
parser.add_argument("-transformer.head_projection_size", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-transformer.ln_affine", default=True)
parser.add_argument("-transformer.ln_after_attention", default=True)
parser.add_argument("-moe.att.n_experts", default=4)
parser.add_argument("-moe.att.variant", default="moa", choice=["moa", "simple", "qside", "full", "full_rope", "seq", "target"])
parser.add_argument("-moe.att.enable", default=False)
parser.add_argument("-moe.att.q_expert", default=True)
parser.add_argument("-moe.att.k_expert", default=True)
parser.add_argument("-moe.att.v_expert", default=True)
parser.add_argument("-moe.att.o_expert", default=True)
parser.add_argument("-moe.att.k", default=2)
parser.add_argument("-moe.att.norm_qk", default=False)
parser.add_argument("-moe.att.v_size", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-moe.att.same_sel", default=False)
parser.add_argument("-moe.att.expert_dropout", default="none", parser=parser.float_or_none_parser)
parser.add_argument("-moe.att.selection_mode", default="sigmoid", choice=["sigmoid", "softmax"])
parser.add_argument("-moe.att.perplexity_reg", default="none", parser=parser.float_or_none_parser)
parser.add_argument("-moe.att.qside_n_experts", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-moe.att.k", default=2)
parser.add_argument("-moe.att.norm_ret", default=False)
parser.add_argument("-moe.att.shared_experts", default=False)
parser.add_argument("-moe.att.drop_expert", default="none", parser=parser.float_or_none_parser)
parser.add_argument("-moe.att.kq_n_experts", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-moe.att.separate_kq_sel", default=False)
parser.add_argument("-moe.att.norm_init", default=False)
parser.add_argument("-rope.rotate_fraction", default=0.5)
parser.add_argument("-rope.base", default=10000.0)
parser.add_argument("-moa.mode", default="my", choice=["my", "moa"])
parser.add_argument("-moa.cvloss", default=0.0)
parser.add_argument("-moa.switchloss", default=0.0)
parser.add_argument("-moa.zloss", default=0.0)
parser.add_argument("-debug_plot_interval", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-transformer.plot_head_details", default=False)
parser.add_argument("-plot.n_steps", default=-128)
|
@args
def a(parser: framework.helpers.ArgumentParser):
parser.add_argument("-lm.trafo.context_blocks", default=1)
parser.add_argument("-lm.trafo.test_context_blocks", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-lm.trafo.test_pos_clamp", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-lm.trafo.same_length_eval", default=False)
parser.add_argument("-lm.trafo.same_length", default=False)
parser.add_argument("-lm.trafo.last_layer_context", default=False)
parser.add_argument("-lm.trafo.xl_init", default=False)
parser.add_argument("-lm.trafo.embedding_mode_init", default="default", choice=["default", "scale_to_sqrt_dmodel", "init_to_sqrt_dmodel", "one_and_scale_to_sqrt_dmodel", "like_preln"])
parser.add_argument("-pkm.n_heads", default=1)
parser.add_argument("-moe.n_experts", default=128)
parser.add_argument("-moe.expert_size", default=128)
parser.add_argument("-moe.selection_mode", default="sigmoid", choice=["gate", "sigmoid", "mul"])
parser.add_argument("-moe.perplexity_reg", default=0.0)
parser.add_argument("-moe.perplexity_reg_mode", default="step", choice=["step", "global", "time", "global_time"])
parser.add_argument("-moe.reg_type", default="entropy", choice=["perplexity", "variance", "entropy", "l2", "switch", "normal"])
parser.add_argument("-moe.norm_keys", default=False)
parser.add_argument("-moe.n_random", default=0)
parser.add_argument("-moe.topk_mode", default="full", choice=["full", "l1_approx", "approx"])
parser.add_argument("-moe.activation_after_topk", default=False)
parser.add_argument("-moe.drop_parallel", default=True)
parser.add_argument("-moe.norm_key_init", default=False)
parser.add_argument("-moe.norm_value_init", default=False)
parser.add_argument("-moe.identical_init", default=False)
parser.add_argument("-moe.sel_lr_multipler", default=1.0)
parser.add_argument("-moe.expert_lr_multipler", default=1.0)
parser.add_argument("-moe.sel_norm", default="none", choice=["none", "cos", "input", "weights"])
parser.add_argument("-moe.dropout_factor", default=1.0)
parser.add_argument("-moe.drop_expert", default=0.0)
parser.add_argument("-moe.sync_distributed", default=True)
parser.add_argument("-moe.modulation_amplitude", default=0.5)
parser.add_argument("-moe.init_scale", default=1.0)
parser.add_argument("-moe.norm_expert_sel_init", default=False)
parser.add_argument("-kvmem.dropout", default="none", choice=["none", "early", "late", "weight", "score"])
parser.add_argument("-kvmem.norm_values", default=False)
parser.add_argument("-transformer.topk_value", default=32)
parser.add_argument("-transformer.activation", default="relu", choice=["relu", "topk", "gelu", "identity", "sigmoid", "softmax"])
parser.add_argument("-transformer.p_drop_layer", default=0.0)
parser.add_argument("-transformer.head_projection_size", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-transformer.ln_affine", default=True)
parser.add_argument("-transformer.ln_after_attention", default=True)
parser.add_argument("-moe.att.n_experts", default=4)
parser.add_argument("-moe.att.variant", default="moa", choice=["moa", "simple", "qside", "full", "full_rope", "seq", "target"])
parser.add_argument("-moe.att.enable", default=False)
parser.add_argument("-moe.att.q_expert", default=True)
parser.add_argument("-moe.att.k_expert", default=True)
parser.add_argument("-moe.att.v_expert", default=True)
parser.add_argument("-moe.att.o_expert", default=True)
parser.add_argument("-moe.att.k", default=2)
parser.add_argument("-moe.att.norm_qk", default=False)
parser.add_argument("-moe.att.v_size", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-moe.att.same_sel", default=False)
parser.add_argument("-moe.att.expert_dropout", default="none", parser=parser.float_or_none_parser)
parser.add_argument("-moe.att.selection_mode", default="sigmoid", choice=["sigmoid", "softmax"])
parser.add_argument("-moe.att.perplexity_reg", default="none", parser=parser.float_or_none_parser)
parser.add_argument("-moe.att.qside_n_experts", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-moe.att.k", default=2)
parser.add_argument("-moe.att.norm_ret", default=False)
parser.add_argument("-moe.att.shared_experts", default=False)
parser.add_argument("-moe.att.drop_expert", default="none", parser=parser.float_or_none_parser)
parser.add_argument("-moe.att.kq_n_experts", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-moe.att.separate_kq_sel", default=False)
parser.add_argument("-moe.att.norm_init", default=False)
parser.add_argument("-rope.rotate_fraction", default=0.5)
parser.add_argument("-rope.base", default=10000.0)
parser.add_argument("-moa.mode", default="my", choice=["my", "moa"])
parser.add_argument("-moa.cvloss", default=0.0)
parser.add_argument("-moa.switchloss", default=0.0)
parser.add_argument("-moa.zloss", default=0.0)
parser.add_argument("-debug_plot_interval", default="none", parser=parser.int_or_none_parser)
parser.add_argument("-transformer.plot_head_details", default=False)
parser.add_argument("-plot.n_steps", default=-128)
| @task() | 1 | 2023-12-13 08:45:02+00:00 | 24k |
AIFSH/NativeDancer | nativedancer/third_part/detectron2/modeling/meta_arch/retinanet.py | [
{
"identifier": "configurable",
"path": "nativedancer/third_part/detectron2/config/config.py",
"snippet": "def configurable(init_func=None, *, from_config=None):\n \"\"\"\n Decorate a function or a class's __init__ method so that it can be called\n with a :class:`CfgNode` object using a :func:`... | import logging
import math
import torch
from typing import List, Tuple
from fvcore.nn import sigmoid_focal_loss_jit
from torch import Tensor, nn
from torch.nn import functional as F
from ...config import configurable
from ...layers import CycleBatchNormList, ShapeSpec, batched_nms, cat, get_norm
from ...structures import Boxes, ImageList, Instances, pairwise_iou
from ...utils.events import get_event_storage
from ..anchor_generator import build_anchor_generator
from ..backbone import Backbone, build_backbone
from ..box_regression import Box2BoxTransform, _dense_box_regression_loss
from ..matcher import Matcher
from .build import META_ARCH_REGISTRY
from .dense_detector import DenseDetector, permute_to_N_HWA_K # noqa | 16,303 | backbone: a backbone module, must follow detectron2's backbone interface
head (nn.Module): a module that predicts logits and regression deltas
for each level from a list of per-level features
head_in_features (Tuple[str]): Names of the input feature maps to be used in head
anchor_generator (nn.Module): a module that creates anchors from a
list of features. Usually an instance of :class:`AnchorGenerator`
box2box_transform (Box2BoxTransform): defines the transform from anchors boxes to
instance boxes
anchor_matcher (Matcher): label the anchors by matching them with ground truth.
num_classes (int): number of classes. Used to label background proposals.
# Loss parameters:
focal_loss_alpha (float): focal_loss_alpha
focal_loss_gamma (float): focal_loss_gamma
smooth_l1_beta (float): smooth_l1_beta
box_reg_loss_type (str): Options are "smooth_l1", "giou", "diou", "ciou"
# Inference parameters:
test_score_thresh (float): Inference cls score threshold, only anchors with
score > INFERENCE_TH are considered for inference (to improve speed)
test_topk_candidates (int): Select topk candidates before NMS
test_nms_thresh (float): Overlap threshold used for non-maximum suppression
(suppress boxes with IoU >= this threshold)
max_detections_per_image (int):
Maximum number of detections to return per image during inference
(100 is based on the limit established for the COCO dataset).
pixel_mean, pixel_std: see :class:`DenseDetector`.
"""
super().__init__(
backbone, head, head_in_features, pixel_mean=pixel_mean, pixel_std=pixel_std
)
self.num_classes = num_classes
# Anchors
self.anchor_generator = anchor_generator
self.box2box_transform = box2box_transform
self.anchor_matcher = anchor_matcher
# Loss parameters:
self.focal_loss_alpha = focal_loss_alpha
self.focal_loss_gamma = focal_loss_gamma
self.smooth_l1_beta = smooth_l1_beta
self.box_reg_loss_type = box_reg_loss_type
# Inference parameters:
self.test_score_thresh = test_score_thresh
self.test_topk_candidates = test_topk_candidates
self.test_nms_thresh = test_nms_thresh
self.max_detections_per_image = max_detections_per_image
# Vis parameters
self.vis_period = vis_period
self.input_format = input_format
@classmethod
def from_config(cls, cfg):
backbone = build_backbone(cfg)
backbone_shape = backbone.output_shape()
feature_shapes = [backbone_shape[f] for f in cfg.MODEL.RETINANET.IN_FEATURES]
head = RetinaNetHead(cfg, feature_shapes)
anchor_generator = build_anchor_generator(cfg, feature_shapes)
return {
"backbone": backbone,
"head": head,
"anchor_generator": anchor_generator,
"box2box_transform": Box2BoxTransform(weights=cfg.MODEL.RETINANET.BBOX_REG_WEIGHTS),
"anchor_matcher": Matcher(
cfg.MODEL.RETINANET.IOU_THRESHOLDS,
cfg.MODEL.RETINANET.IOU_LABELS,
allow_low_quality_matches=True,
),
"pixel_mean": cfg.MODEL.PIXEL_MEAN,
"pixel_std": cfg.MODEL.PIXEL_STD,
"num_classes": cfg.MODEL.RETINANET.NUM_CLASSES,
"head_in_features": cfg.MODEL.RETINANET.IN_FEATURES,
# Loss parameters:
"focal_loss_alpha": cfg.MODEL.RETINANET.FOCAL_LOSS_ALPHA,
"focal_loss_gamma": cfg.MODEL.RETINANET.FOCAL_LOSS_GAMMA,
"smooth_l1_beta": cfg.MODEL.RETINANET.SMOOTH_L1_LOSS_BETA,
"box_reg_loss_type": cfg.MODEL.RETINANET.BBOX_REG_LOSS_TYPE,
# Inference parameters:
"test_score_thresh": cfg.MODEL.RETINANET.SCORE_THRESH_TEST,
"test_topk_candidates": cfg.MODEL.RETINANET.TOPK_CANDIDATES_TEST,
"test_nms_thresh": cfg.MODEL.RETINANET.NMS_THRESH_TEST,
"max_detections_per_image": cfg.TEST.DETECTIONS_PER_IMAGE,
# Vis parameters
"vis_period": cfg.VIS_PERIOD,
"input_format": cfg.INPUT.FORMAT,
}
def forward_training(self, images, features, predictions, gt_instances):
# Transpose the Hi*Wi*A dimension to the middle:
pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(
predictions, [self.num_classes, 4]
)
anchors = self.anchor_generator(features)
gt_labels, gt_boxes = self.label_anchors(anchors, gt_instances)
return self.losses(anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes)
def losses(self, anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes):
"""
Args:
anchors (list[Boxes]): a list of #feature level Boxes
gt_labels, gt_boxes: see output of :meth:`RetinaNet.label_anchors`.
Their shapes are (N, R) and (N, R, 4), respectively, where R is
the total number of anchors across levels, i.e. sum(Hi x Wi x Ai)
pred_logits, pred_anchor_deltas: both are list[Tensor]. Each element in the
list corresponds to one level and has shape (N, Hi * Wi * Ai, K or 4).
Where K is the number of classes used in `pred_logits`.
Returns:
dict[str, Tensor]:
mapping from a named loss to a scalar tensor storing the loss.
Used during training only. The dict keys are: "loss_cls" and "loss_box_reg"
"""
num_images = len(gt_labels)
gt_labels = torch.stack(gt_labels) # (N, R)
valid_mask = gt_labels >= 0
pos_mask = (gt_labels >= 0) & (gt_labels != self.num_classes)
num_pos_anchors = pos_mask.sum().item()
| # Copyright (c) Facebook, Inc. and its affiliates.
__all__ = ["RetinaNet"]
logger = logging.getLogger(__name__)
@META_ARCH_REGISTRY.register()
class RetinaNet(DenseDetector):
"""
Implement RetinaNet in :paper:`RetinaNet`.
"""
@configurable
def __init__(
self,
*,
backbone: Backbone,
head: nn.Module,
head_in_features,
anchor_generator,
box2box_transform,
anchor_matcher,
num_classes,
focal_loss_alpha=0.25,
focal_loss_gamma=2.0,
smooth_l1_beta=0.0,
box_reg_loss_type="smooth_l1",
test_score_thresh=0.05,
test_topk_candidates=1000,
test_nms_thresh=0.5,
max_detections_per_image=100,
pixel_mean,
pixel_std,
vis_period=0,
input_format="BGR",
):
"""
NOTE: this interface is experimental.
Args:
backbone: a backbone module, must follow detectron2's backbone interface
head (nn.Module): a module that predicts logits and regression deltas
for each level from a list of per-level features
head_in_features (Tuple[str]): Names of the input feature maps to be used in head
anchor_generator (nn.Module): a module that creates anchors from a
list of features. Usually an instance of :class:`AnchorGenerator`
box2box_transform (Box2BoxTransform): defines the transform from anchors boxes to
instance boxes
anchor_matcher (Matcher): label the anchors by matching them with ground truth.
num_classes (int): number of classes. Used to label background proposals.
# Loss parameters:
focal_loss_alpha (float): focal_loss_alpha
focal_loss_gamma (float): focal_loss_gamma
smooth_l1_beta (float): smooth_l1_beta
box_reg_loss_type (str): Options are "smooth_l1", "giou", "diou", "ciou"
# Inference parameters:
test_score_thresh (float): Inference cls score threshold, only anchors with
score > INFERENCE_TH are considered for inference (to improve speed)
test_topk_candidates (int): Select topk candidates before NMS
test_nms_thresh (float): Overlap threshold used for non-maximum suppression
(suppress boxes with IoU >= this threshold)
max_detections_per_image (int):
Maximum number of detections to return per image during inference
(100 is based on the limit established for the COCO dataset).
pixel_mean, pixel_std: see :class:`DenseDetector`.
"""
super().__init__(
backbone, head, head_in_features, pixel_mean=pixel_mean, pixel_std=pixel_std
)
self.num_classes = num_classes
# Anchors
self.anchor_generator = anchor_generator
self.box2box_transform = box2box_transform
self.anchor_matcher = anchor_matcher
# Loss parameters:
self.focal_loss_alpha = focal_loss_alpha
self.focal_loss_gamma = focal_loss_gamma
self.smooth_l1_beta = smooth_l1_beta
self.box_reg_loss_type = box_reg_loss_type
# Inference parameters:
self.test_score_thresh = test_score_thresh
self.test_topk_candidates = test_topk_candidates
self.test_nms_thresh = test_nms_thresh
self.max_detections_per_image = max_detections_per_image
# Vis parameters
self.vis_period = vis_period
self.input_format = input_format
@classmethod
def from_config(cls, cfg):
backbone = build_backbone(cfg)
backbone_shape = backbone.output_shape()
feature_shapes = [backbone_shape[f] for f in cfg.MODEL.RETINANET.IN_FEATURES]
head = RetinaNetHead(cfg, feature_shapes)
anchor_generator = build_anchor_generator(cfg, feature_shapes)
return {
"backbone": backbone,
"head": head,
"anchor_generator": anchor_generator,
"box2box_transform": Box2BoxTransform(weights=cfg.MODEL.RETINANET.BBOX_REG_WEIGHTS),
"anchor_matcher": Matcher(
cfg.MODEL.RETINANET.IOU_THRESHOLDS,
cfg.MODEL.RETINANET.IOU_LABELS,
allow_low_quality_matches=True,
),
"pixel_mean": cfg.MODEL.PIXEL_MEAN,
"pixel_std": cfg.MODEL.PIXEL_STD,
"num_classes": cfg.MODEL.RETINANET.NUM_CLASSES,
"head_in_features": cfg.MODEL.RETINANET.IN_FEATURES,
# Loss parameters:
"focal_loss_alpha": cfg.MODEL.RETINANET.FOCAL_LOSS_ALPHA,
"focal_loss_gamma": cfg.MODEL.RETINANET.FOCAL_LOSS_GAMMA,
"smooth_l1_beta": cfg.MODEL.RETINANET.SMOOTH_L1_LOSS_BETA,
"box_reg_loss_type": cfg.MODEL.RETINANET.BBOX_REG_LOSS_TYPE,
# Inference parameters:
"test_score_thresh": cfg.MODEL.RETINANET.SCORE_THRESH_TEST,
"test_topk_candidates": cfg.MODEL.RETINANET.TOPK_CANDIDATES_TEST,
"test_nms_thresh": cfg.MODEL.RETINANET.NMS_THRESH_TEST,
"max_detections_per_image": cfg.TEST.DETECTIONS_PER_IMAGE,
# Vis parameters
"vis_period": cfg.VIS_PERIOD,
"input_format": cfg.INPUT.FORMAT,
}
def forward_training(self, images, features, predictions, gt_instances):
# Transpose the Hi*Wi*A dimension to the middle:
pred_logits, pred_anchor_deltas = self._transpose_dense_predictions(
predictions, [self.num_classes, 4]
)
anchors = self.anchor_generator(features)
gt_labels, gt_boxes = self.label_anchors(anchors, gt_instances)
return self.losses(anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes)
def losses(self, anchors, pred_logits, gt_labels, pred_anchor_deltas, gt_boxes):
"""
Args:
anchors (list[Boxes]): a list of #feature level Boxes
gt_labels, gt_boxes: see output of :meth:`RetinaNet.label_anchors`.
Their shapes are (N, R) and (N, R, 4), respectively, where R is
the total number of anchors across levels, i.e. sum(Hi x Wi x Ai)
pred_logits, pred_anchor_deltas: both are list[Tensor]. Each element in the
list corresponds to one level and has shape (N, Hi * Wi * Ai, K or 4).
Where K is the number of classes used in `pred_logits`.
Returns:
dict[str, Tensor]:
mapping from a named loss to a scalar tensor storing the loss.
Used during training only. The dict keys are: "loss_cls" and "loss_box_reg"
"""
num_images = len(gt_labels)
gt_labels = torch.stack(gt_labels) # (N, R)
valid_mask = gt_labels >= 0
pos_mask = (gt_labels >= 0) & (gt_labels != self.num_classes)
num_pos_anchors = pos_mask.sum().item() | get_event_storage().put_scalar("num_pos_anchors", num_pos_anchors / num_images) | 10 | 2023-12-10 20:14:00+00:00 | 24k |
mkang315/ASF-YOLO | segment/val.py | [
{
"identifier": "DetectMultiBackend",
"path": "models/common.py",
"snippet": "class DetectMultiBackend(nn.Module):\n # YOLOv5 MultiBackend class for python inference on various backends\n def __init__(self, weights='yolov5s.pt', device=torch.device('cpu'), dnn=False, data=None, fp16=False, fuse=Tr... | import argparse
import json
import os
import sys
import numpy as np
import torch
import torch.nn.functional as F
import time
from multiprocessing.pool import ThreadPool
from pathlib import Path
from tqdm import tqdm
from models.common import DetectMultiBackend
from models.yolo import SegmentationModel
from utils.callbacks import Callbacks
from utils.general import (LOGGER, NUM_THREADS, TQDM_BAR_FORMAT, Profile, check_dataset, check_img_size,
check_requirements, check_yaml, coco80_to_coco91_class, colorstr, increment_path,
non_max_suppression, print_args, scale_boxes, xywh2xyxy, xyxy2xywh)
from utils.metrics import ConfusionMatrix, box_iou
from utils.plots import output_to_target, plot_val_study
from utils.segment.dataloaders import create_dataloader
from utils.segment.general import mask_iou, process_mask, process_mask_upsample, scale_image
from utils.segment.metrics import Metrics, ap_per_class_box_and_mask
from utils.segment.plots import plot_images_and_masks
from utils.torch_utils import de_parallel, select_device, smart_inference_mode
from pycocotools.mask import encode
from pycocotools.coco import COCO
from pycocotools.cocoeval import COCOeval | 19,567 | rle["counts"] = rle["counts"].decode("utf-8")
return rle
image_id = int(path.stem) if path.stem.isnumeric() else path.stem
box = xyxy2xywh(predn[:, :4]) # xywh
box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
pred_masks = np.transpose(pred_masks, (2, 0, 1))
with ThreadPool(NUM_THREADS) as pool:
rles = pool.map(single_encode, pred_masks)
for i, (p, b) in enumerate(zip(predn.tolist(), box.tolist())):
jdict.append({
'image_id': image_id,
'category_id': class_map[int(p[5])],
'bbox': [round(x, 3) for x in b],
'score': round(p[4], 5),
'segmentation': rles[i]})
def process_batch(detections, labels, iouv, pred_masks=None, gt_masks=None, overlap=False, masks=False):
"""
Return correct prediction matrix
Arguments:
detections (array[N, 6]), x1, y1, x2, y2, conf, class
labels (array[M, 5]), class, x1, y1, x2, y2
Returns:
correct (array[N, 10]), for 10 IoU levels
"""
if masks:
if overlap:
nl = len(labels)
index = torch.arange(nl, device=gt_masks.device).view(nl, 1, 1) + 1
gt_masks = gt_masks.repeat(nl, 1, 1) # shape(1,640,640) -> (n,640,640)
gt_masks = torch.where(gt_masks == index, 1.0, 0.0)
if gt_masks.shape[1:] != pred_masks.shape[1:]:
gt_masks = F.interpolate(gt_masks[None], pred_masks.shape[1:], mode="bilinear", align_corners=False)[0]
gt_masks = gt_masks.gt_(0.5)
iou = mask_iou(gt_masks.view(gt_masks.shape[0], -1), pred_masks.view(pred_masks.shape[0], -1))
else: # boxes
iou = box_iou(labels[:, 1:], detections[:, :4])
correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)
correct_class = labels[:, 0:1] == detections[:, 5]
for i in range(len(iouv)):
x = torch.where((iou >= iouv[i]) & correct_class) # IoU > threshold and classes match
if x[0].shape[0]:
matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy() # [label, detect, iou]
if x[0].shape[0] > 1:
matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
# matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
correct[matches[:, 1].astype(int), i] = True
return torch.tensor(correct, dtype=torch.bool, device=iouv.device)
@smart_inference_mode()
def run(
data,
weights=None, # model.pt path(s)
batch_size=32, # batch size
imgsz=640, # inference size (pixels)
conf_thres=0.001, # confidence threshold
iou_thres=0.6, # NMS IoU threshold
max_det=300, # maximum detections per image
task='val', # train, val, test, speed or study
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
workers=8, # max dataloader workers (per RANK in DDP mode)
single_cls=False, # treat as single-class dataset
augment=False, # augmented inference
verbose=False, # verbose output
save_txt=False, # save results to *.txt
save_hybrid=False, # save label+prediction hybrid results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_json=False, # save a COCO-JSON results file
project=ROOT / 'runs/val-seg', # save to project/name
name='exp', # save to project/name
exist_ok=False, # existing project/name ok, do not increment
half=True, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
model=None,
dataloader=None,
save_dir=Path(''),
plots=True,
overlap=False,
mask_downsample_ratio=1,
compute_loss=None,
callbacks=Callbacks(),
):
if save_json:
check_requirements(['pycocotools'])
process = process_mask_upsample # more accurate
else:
process = process_mask # faster
# Initialize/load model and set device
training = model is not None
if training: # called by train.py
device, pt, jit, engine = next(model.parameters()).device, True, False, False # get model device, PyTorch model
half &= device.type != 'cpu' # half precision only supported on CUDA
model.half() if half else model.float()
nm = de_parallel(model).model[-1].nm # number of masks
else: # called directly
device = select_device(device, batch_size=batch_size)
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
# Load model
model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine
imgsz = check_img_size(imgsz, s=stride) # check image size
half = model.fp16 # FP16 supported on limited backends with CUDA
nm = de_parallel(model).model.model[-1].nm if isinstance(model, SegmentationModel) else 32 # number of masks
if engine:
batch_size = model.batch_size
else:
device = model.device
if not (pt or jit):
batch_size = 1 # export.py models default to batch-size 1
| # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Validate a trained YOLOv5 segment model on a segment dataset
Usage:
$ bash data/scripts/get_coco.sh --val --segments # download COCO-segments val split (1G, 5000 images)
$ python segment/val.py --weights yolov5s-seg.pt --data coco.yaml --img 640 # validate COCO-segments
Usage - formats:
$ python segment/val.py --weights yolov5s-seg.pt # PyTorch
yolov5s-seg.torchscript # TorchScript
yolov5s-seg.onnx # ONNX Runtime or OpenCV DNN with --dnn
yolov5s-seg_openvino_label # OpenVINO
yolov5s-seg.engine # TensorRT
yolov5s-seg.mlmodel # CoreML (macOS-only)
yolov5s-seg_saved_model # TensorFlow SavedModel
yolov5s-seg.pb # TensorFlow GraphDef
yolov5s-seg.tflite # TensorFlow Lite
yolov5s-seg_edgetpu.tflite # TensorFlow Edge TPU
yolov5s-seg_paddle_model # PaddlePaddle
"""
FILE = Path(__file__).resolve()
ROOT = FILE.parents[1] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
def save_one_txt(predn, save_conf, shape, file):
# Save one txt result
gn = torch.tensor(shape)[[1, 0, 1, 0]] # normalization gain whwh
for *xyxy, conf, cls in predn.tolist():
xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
line = (cls, *xywh, conf) if save_conf else (cls, *xywh) # label format
with open(file, 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
def save_one_json(predn, jdict, path, class_map, pred_masks):
# Save one JSON result {"image_id": 42, "category_id": 18, "bbox": [258.15, 41.29, 348.26, 243.78], "score": 0.236}
def single_encode(x):
rle = encode(np.asarray(x[:, :, None], order="F", dtype="uint8"))[0]
rle["counts"] = rle["counts"].decode("utf-8")
return rle
image_id = int(path.stem) if path.stem.isnumeric() else path.stem
box = xyxy2xywh(predn[:, :4]) # xywh
box[:, :2] -= box[:, 2:] / 2 # xy center to top-left corner
pred_masks = np.transpose(pred_masks, (2, 0, 1))
with ThreadPool(NUM_THREADS) as pool:
rles = pool.map(single_encode, pred_masks)
for i, (p, b) in enumerate(zip(predn.tolist(), box.tolist())):
jdict.append({
'image_id': image_id,
'category_id': class_map[int(p[5])],
'bbox': [round(x, 3) for x in b],
'score': round(p[4], 5),
'segmentation': rles[i]})
def process_batch(detections, labels, iouv, pred_masks=None, gt_masks=None, overlap=False, masks=False):
"""
Return correct prediction matrix
Arguments:
detections (array[N, 6]), x1, y1, x2, y2, conf, class
labels (array[M, 5]), class, x1, y1, x2, y2
Returns:
correct (array[N, 10]), for 10 IoU levels
"""
if masks:
if overlap:
nl = len(labels)
index = torch.arange(nl, device=gt_masks.device).view(nl, 1, 1) + 1
gt_masks = gt_masks.repeat(nl, 1, 1) # shape(1,640,640) -> (n,640,640)
gt_masks = torch.where(gt_masks == index, 1.0, 0.0)
if gt_masks.shape[1:] != pred_masks.shape[1:]:
gt_masks = F.interpolate(gt_masks[None], pred_masks.shape[1:], mode="bilinear", align_corners=False)[0]
gt_masks = gt_masks.gt_(0.5)
iou = mask_iou(gt_masks.view(gt_masks.shape[0], -1), pred_masks.view(pred_masks.shape[0], -1))
else: # boxes
iou = box_iou(labels[:, 1:], detections[:, :4])
correct = np.zeros((detections.shape[0], iouv.shape[0])).astype(bool)
correct_class = labels[:, 0:1] == detections[:, 5]
for i in range(len(iouv)):
x = torch.where((iou >= iouv[i]) & correct_class) # IoU > threshold and classes match
if x[0].shape[0]:
matches = torch.cat((torch.stack(x, 1), iou[x[0], x[1]][:, None]), 1).cpu().numpy() # [label, detect, iou]
if x[0].shape[0] > 1:
matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
# matches = matches[matches[:, 2].argsort()[::-1]]
matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
correct[matches[:, 1].astype(int), i] = True
return torch.tensor(correct, dtype=torch.bool, device=iouv.device)
@smart_inference_mode()
def run(
data,
weights=None, # model.pt path(s)
batch_size=32, # batch size
imgsz=640, # inference size (pixels)
conf_thres=0.001, # confidence threshold
iou_thres=0.6, # NMS IoU threshold
max_det=300, # maximum detections per image
task='val', # train, val, test, speed or study
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
workers=8, # max dataloader workers (per RANK in DDP mode)
single_cls=False, # treat as single-class dataset
augment=False, # augmented inference
verbose=False, # verbose output
save_txt=False, # save results to *.txt
save_hybrid=False, # save label+prediction hybrid results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_json=False, # save a COCO-JSON results file
project=ROOT / 'runs/val-seg', # save to project/name
name='exp', # save to project/name
exist_ok=False, # existing project/name ok, do not increment
half=True, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
model=None,
dataloader=None,
save_dir=Path(''),
plots=True,
overlap=False,
mask_downsample_ratio=1,
compute_loss=None,
callbacks=Callbacks(),
):
if save_json:
check_requirements(['pycocotools'])
process = process_mask_upsample # more accurate
else:
process = process_mask # faster
# Initialize/load model and set device
training = model is not None
if training: # called by train.py
device, pt, jit, engine = next(model.parameters()).device, True, False, False # get model device, PyTorch model
half &= device.type != 'cpu' # half precision only supported on CUDA
model.half() if half else model.float()
nm = de_parallel(model).model[-1].nm # number of masks
else: # called directly
device = select_device(device, batch_size=batch_size)
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
# Load model
model = DetectMultiBackend(weights, device=device, dnn=dnn, data=data, fp16=half)
stride, pt, jit, engine = model.stride, model.pt, model.jit, model.engine
imgsz = check_img_size(imgsz, s=stride) # check image size
half = model.fp16 # FP16 supported on limited backends with CUDA
nm = de_parallel(model).model.model[-1].nm if isinstance(model, SegmentationModel) else 32 # number of masks
if engine:
batch_size = model.batch_size
else:
device = model.device
if not (pt or jit):
batch_size = 1 # export.py models default to batch-size 1 | LOGGER.info(f'Forcing --batch-size 1 square inference (1,3,{imgsz},{imgsz}) for non-PyTorch models') | 3 | 2023-12-10 14:18:29+00:00 | 24k |
youngskkim/CRN | exps/base_exp.py | [
{
"identifier": "NuscDatasetRadarDet",
"path": "datasets/nusc_det_dataset.py",
"snippet": "class NuscDatasetRadarDet(Dataset):\n def __init__(self,\n ida_aug_conf,\n bda_aug_conf,\n rda_aug_conf,\n classes,\n data_root,\n... | from functools import partial
from pytorch_lightning.core import LightningModule
from torch.cuda.amp.autocast_mode import autocast
from torch.optim.lr_scheduler import MultiStepLR
from mmcv.runner import build_optimizer
from datasets.nusc_det_dataset import NuscDatasetRadarDet, collate_fn
from evaluators.det_evaluators import DetNuscEvaluator
from models.base_bev_depth import BaseBEVDepth
from utils.torch_dist import all_gather_object, synchronize
import mmcv
import torch
import torch.nn.functional as F
import torch.nn.parallel
import torch.utils.data
import torch.utils.data.distributed
import torchvision.models as models | 14,786 | out_indices=[0, 1, 2, 3],
norm_eval=False,
init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
),
'img_neck_conf': dict(
type='SECONDFPN',
in_channels=[256, 512, 1024, 2048],
upsample_strides=[0.25, 0.5, 1, 2],
out_channels=[128, 128, 128, 128],
),
'depth_net_conf':
dict(in_channels=512, mid_channels=512),
'camera_aware': True
}
CLASSES = [
'car', 'truck', 'construction_vehicle', 'bus', 'trailer',
'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone',
]
head_conf = {
'bev_backbone_conf': dict(
type='ResNet',
in_channels=80,
depth=18,
num_stages=3,
strides=(1, 2, 2),
dilations=(1, 1, 1),
out_indices=[0, 1, 2],
norm_eval=False,
base_channels=160),
'bev_neck_conf': dict(
type='SECONDFPN',
in_channels=[80, 160, 320, 640],
upsample_strides=[1, 2, 4, 8],
out_channels=[64, 64, 64, 64]),
'tasks': [
dict(num_class=1, class_names=['car']),
dict(num_class=2, class_names=['truck', 'construction_vehicle']),
dict(num_class=2, class_names=['bus', 'trailer']),
dict(num_class=1, class_names=['barrier']),
dict(num_class=2, class_names=['motorcycle', 'bicycle']),
dict(num_class=2, class_names=['pedestrian', 'traffic_cone']),],
'common_heads': dict(
reg=(2, 2), height=(1, 2), dim=(3, 2), rot=(2, 2), vel=(2, 2)),
'bbox_coder': dict(
type='CenterPointBBoxCoder',
post_center_range=[-61.2, -61.2, -10.0, 61.2, 61.2, 10.0],
max_num=500,
score_threshold=0.1,
out_size_factor=4,
voxel_size=[0.2, 0.2, 8],
pc_range=[-51.2, -51.2, -5, 51.2, 51.2, 3],
code_size=9),
'train_cfg': dict(
point_cloud_range=[-51.2, -51.2, -5, 51.2, 51.2, 3],
grid_size=[512, 512, 1],
voxel_size=[0.2, 0.2, 8],
out_size_factor=4,
dense_reg=1,
gaussian_overlap=0.1,
max_objs=500,
min_radius=2,
code_weights=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 0.5]),
'test_cfg': dict(
post_center_limit_range=[-61.2, -61.2, -10.0, 61.2, 61.2, 10.0],
max_per_img=500,
max_pool_nms=False,
min_radius=[4, 12, 10, 1, 0.85, 0.175],
score_threshold=0.1,
out_size_factor=4,
voxel_size=[0.2, 0.2, 8],
nms_type='circle',
pre_max_size=1000,
post_max_size=83,
nms_thr=0.2),
'in_channels': 256, # Equal to bev_neck output_channels.
'loss_cls': dict(type='GaussianFocalLoss', reduction='mean'),
'loss_bbox': dict(type='L1Loss', reduction='mean', loss_weight=0.25),
'gaussian_overlap': 0.1,
'min_radius': 2,
}
class BEVDepthLightningModel(LightningModule):
MODEL_NAMES = sorted(name for name in models.__dict__
if name.islower() and not name.startswith('__')
and callable(models.__dict__[name]))
def __init__(self,
gpus: int = 1,
data_root='data/nuScenes',
eval_interval=1,
batch_size_per_device=8,
class_names=CLASSES,
backbone_img_conf=backbone_img_conf,
head_conf=head_conf,
ida_aug_conf=ida_aug_conf,
bda_aug_conf=bda_aug_conf,
rda_aug_conf=rda_aug_conf,
default_root_dir='./outputs/',
**kwargs):
super().__init__()
self.save_hyperparameters()
self.gpus = gpus
self.optimizer_config = optimizer_config
self.pretrain_config = pretrain_config
self.eval_interval = eval_interval
self.batch_size_per_device = batch_size_per_device
self.data_root = data_root
self.class_names = class_names
self.backbone_img_conf = backbone_img_conf
self.head_conf = head_conf
self.ida_aug_conf = ida_aug_conf
self.bda_aug_conf = bda_aug_conf
self.rda_aug_conf = rda_aug_conf
mmcv.mkdir_or_exist(default_root_dir)
self.default_root_dir = default_root_dir
self.evaluator = DetNuscEvaluator(class_names=self.class_names,
output_dir=self.default_root_dir)
| # Copyright (c) Megvii Inc. All rights reserved.
pretrain_config = dict(
img_model_path=None,
img_load_key=[],
img_freeze_key=None,
pts_model_path=None,
pts_load_key=[])
optimizer_config = dict(
type='AdamW',
lr=2e-4,
weight_decay=1e-2)
H = 900
W = 1600
final_dim = (256, 704)
img_conf = dict(img_mean=[123.675, 116.28, 103.53],
img_std=[58.395, 57.12, 57.375],
to_rgb=True)
ida_aug_conf = {
'resize_lim': (0.386, 0.55),
'final_dim': final_dim,
'rot_lim': (-5.4, 5.4),
'H': 900,
'W': 1600,
'rand_flip': True,
'bot_pct_lim': (0.0, 0.0),
'cams': ['CAM_FRONT_LEFT', 'CAM_FRONT', 'CAM_FRONT_RIGHT',
'CAM_BACK_LEFT', 'CAM_BACK', 'CAM_BACK_RIGHT'],
'Ncams': 6,
}
bda_aug_conf = {
'rot_ratio': 1.0,
'rot_lim': (-22.5, 22.5),
'scale_lim': (0.95, 1.05),
'flip_dx_ratio': 0.5,
'flip_dy_ratio': 0.5
}
rda_aug_conf = {
'N_sweeps': 6,
'N_use': 5,
'drop_ratio': 0.1,
}
backbone_img_conf = {
'x_bound': [-51.2, 51.2, 0.8],
'y_bound': [-51.2, 51.2, 0.8],
'z_bound': [-5, 3, 8],
'd_bound': [2.0, 58.0, 0.8],
'final_dim': final_dim,
'output_channels': 80,
'downsample_factor': 16,
'img_backbone_conf': dict(
type='ResNet',
depth=50,
frozen_stages=0,
out_indices=[0, 1, 2, 3],
norm_eval=False,
init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50'),
),
'img_neck_conf': dict(
type='SECONDFPN',
in_channels=[256, 512, 1024, 2048],
upsample_strides=[0.25, 0.5, 1, 2],
out_channels=[128, 128, 128, 128],
),
'depth_net_conf':
dict(in_channels=512, mid_channels=512),
'camera_aware': True
}
CLASSES = [
'car', 'truck', 'construction_vehicle', 'bus', 'trailer',
'barrier', 'motorcycle', 'bicycle', 'pedestrian', 'traffic_cone',
]
head_conf = {
'bev_backbone_conf': dict(
type='ResNet',
in_channels=80,
depth=18,
num_stages=3,
strides=(1, 2, 2),
dilations=(1, 1, 1),
out_indices=[0, 1, 2],
norm_eval=False,
base_channels=160),
'bev_neck_conf': dict(
type='SECONDFPN',
in_channels=[80, 160, 320, 640],
upsample_strides=[1, 2, 4, 8],
out_channels=[64, 64, 64, 64]),
'tasks': [
dict(num_class=1, class_names=['car']),
dict(num_class=2, class_names=['truck', 'construction_vehicle']),
dict(num_class=2, class_names=['bus', 'trailer']),
dict(num_class=1, class_names=['barrier']),
dict(num_class=2, class_names=['motorcycle', 'bicycle']),
dict(num_class=2, class_names=['pedestrian', 'traffic_cone']),],
'common_heads': dict(
reg=(2, 2), height=(1, 2), dim=(3, 2), rot=(2, 2), vel=(2, 2)),
'bbox_coder': dict(
type='CenterPointBBoxCoder',
post_center_range=[-61.2, -61.2, -10.0, 61.2, 61.2, 10.0],
max_num=500,
score_threshold=0.1,
out_size_factor=4,
voxel_size=[0.2, 0.2, 8],
pc_range=[-51.2, -51.2, -5, 51.2, 51.2, 3],
code_size=9),
'train_cfg': dict(
point_cloud_range=[-51.2, -51.2, -5, 51.2, 51.2, 3],
grid_size=[512, 512, 1],
voxel_size=[0.2, 0.2, 8],
out_size_factor=4,
dense_reg=1,
gaussian_overlap=0.1,
max_objs=500,
min_radius=2,
code_weights=[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.5, 0.5]),
'test_cfg': dict(
post_center_limit_range=[-61.2, -61.2, -10.0, 61.2, 61.2, 10.0],
max_per_img=500,
max_pool_nms=False,
min_radius=[4, 12, 10, 1, 0.85, 0.175],
score_threshold=0.1,
out_size_factor=4,
voxel_size=[0.2, 0.2, 8],
nms_type='circle',
pre_max_size=1000,
post_max_size=83,
nms_thr=0.2),
'in_channels': 256, # Equal to bev_neck output_channels.
'loss_cls': dict(type='GaussianFocalLoss', reduction='mean'),
'loss_bbox': dict(type='L1Loss', reduction='mean', loss_weight=0.25),
'gaussian_overlap': 0.1,
'min_radius': 2,
}
class BEVDepthLightningModel(LightningModule):
MODEL_NAMES = sorted(name for name in models.__dict__
if name.islower() and not name.startswith('__')
and callable(models.__dict__[name]))
def __init__(self,
gpus: int = 1,
data_root='data/nuScenes',
eval_interval=1,
batch_size_per_device=8,
class_names=CLASSES,
backbone_img_conf=backbone_img_conf,
head_conf=head_conf,
ida_aug_conf=ida_aug_conf,
bda_aug_conf=bda_aug_conf,
rda_aug_conf=rda_aug_conf,
default_root_dir='./outputs/',
**kwargs):
super().__init__()
self.save_hyperparameters()
self.gpus = gpus
self.optimizer_config = optimizer_config
self.pretrain_config = pretrain_config
self.eval_interval = eval_interval
self.batch_size_per_device = batch_size_per_device
self.data_root = data_root
self.class_names = class_names
self.backbone_img_conf = backbone_img_conf
self.head_conf = head_conf
self.ida_aug_conf = ida_aug_conf
self.bda_aug_conf = bda_aug_conf
self.rda_aug_conf = rda_aug_conf
mmcv.mkdir_or_exist(default_root_dir)
self.default_root_dir = default_root_dir
self.evaluator = DetNuscEvaluator(class_names=self.class_names,
output_dir=self.default_root_dir) | self.model = BaseBEVDepth(self.backbone_img_conf, | 3 | 2023-12-06 14:57:49+00:00 | 24k |
jinxixiang/magic_animate_unofficial | animatediff/magic_animate/pipeline.py | [
{
"identifier": "UNet3DConditionModel",
"path": "animatediff/magic_animate/unet_controlnet.py",
"snippet": "class UNet3DConditionModel(ModelMixin, ConfigMixin):\n _supports_gradient_checkpointing = True\n\n @register_to_config\n def __init__(\n self,\n sample_size: Optiona... | import inspect, math
import numpy as np
import torch
import torch.distributed as dist
import einops
from typing import Callable, List, Optional, Union
from dataclasses import dataclass
from PIL import Image
from tqdm import tqdm
from diffusers.utils import is_accelerate_available
from packaging import version
from transformers import CLIPTextModel, CLIPTokenizer
from diffusers.configuration_utils import FrozenDict
from diffusers.models import AutoencoderKL
from diffusers.pipeline_utils import DiffusionPipeline
from diffusers.schedulers import (
DDIMScheduler,
DPMSolverMultistepScheduler,
EulerAncestralDiscreteScheduler,
EulerDiscreteScheduler,
LMSDiscreteScheduler,
PNDMScheduler,
)
from diffusers.utils import deprecate, logging, BaseOutput
from einops import rearrange
from animatediff.magic_animate.unet_controlnet import UNet3DConditionModel
from animatediff.magic_animate.controlnet import ControlNetModel
from animatediff.magic_animate.mutual_self_attention import ReferenceAttentionControl
from animatediff.magic_animate.context import (
get_context_scheduler,
get_total_steps
)
from animatediff.utils.util import get_tensor_interpolation_method
from accelerate import cpu_offload | 17,193 | # *************************************************************************
# This file may have been modified by Bytedance Inc. (“Bytedance Inc.'s Mo-
# difications”). All Bytedance Inc.'s Modifications are Copyright (2023) B-
# ytedance Inc..
# *************************************************************************
# Adapted from https://github.com/showlab/Tune-A-Video/blob/main/tuneavideo/pipelines/pipeline_tuneavideo.py
# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
TODO:
1. support multi-controlnet
2. [DONE] support DDIM inversion
3. support Prompt-to-prompt
"""
logger = logging.get_logger(__name__) # pylint: disable=invalid-name
@dataclass
class AnimationPipelineOutput(BaseOutput):
videos: Union[torch.Tensor, np.ndarray]
class AnimationPipeline(DiffusionPipeline):
_optional_components = []
def __init__(
self,
vae: AutoencoderKL,
text_encoder: CLIPTextModel,
tokenizer: CLIPTokenizer,
| # *************************************************************************
# This file may have been modified by Bytedance Inc. (“Bytedance Inc.'s Mo-
# difications”). All Bytedance Inc.'s Modifications are Copyright (2023) B-
# ytedance Inc..
# *************************************************************************
# Adapted from https://github.com/showlab/Tune-A-Video/blob/main/tuneavideo/pipelines/pipeline_tuneavideo.py
# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
TODO:
1. support multi-controlnet
2. [DONE] support DDIM inversion
3. support Prompt-to-prompt
"""
logger = logging.get_logger(__name__) # pylint: disable=invalid-name
@dataclass
class AnimationPipelineOutput(BaseOutput):
videos: Union[torch.Tensor, np.ndarray]
class AnimationPipeline(DiffusionPipeline):
_optional_components = []
def __init__(
self,
vae: AutoencoderKL,
text_encoder: CLIPTextModel,
tokenizer: CLIPTokenizer, | unet: UNet3DConditionModel, | 0 | 2023-12-12 00:16:39+00:00 | 24k |
qitan/devops-backend-lite | common/ext_fun.py | [
{
"identifier": "generate_docu",
"path": "common/utils/ElasticSearchAPI.py",
"snippet": "def generate_docu(table, index_version=None):\n index_name = f\"{table.name}-{index_version}\" if index_version else table.name\n _tbindex = Index(index_name)\n _tbindex.analyzer(my_normalizer)\n _tbinde... | from gitlab.exceptions import GitlabGetError
from functools import reduce
from common.utils.ElasticSearchAPI import generate_docu, Search
from common.utils.GitLabAPI import GitLabAPI
from common.utils.HarborAPI import HarborAPI
from common.utils.JenkinsAPI import GlueJenkins
from common.custom_format import convert_xml_to_str_with_pipeline
from common.variables import DASHBOARD_TIME_FORMAT, DASHBOARD_TIME_FORMAT_T, DASHBOARD_TIME_FREQNAMES, \
DASHBOARD_TIME_FREQNAMES_T, SENSITIVE_KEYS, JENKINS_CALLBACK_KEY, \
JENKINS_STATUS_MAP, DEV_LANGUAGE_KEY
from dbapp.models import AppInfo, Product, KubernetesCluster, KubernetesDeploy, MicroApp, Project, ProjectConfig, DevLanguage, BuildJob, UserProfile, SystemConfig, Role, Permission, Menu, DataDict
from django.conf import settings
from django.core.cache import cache
from django.utils import timezone
from django.db.models import Q
from social_django.utils import load_strategy
from rest_framework.utils.serializer_helpers import ReturnDict
from config import SOCIAL_AUTH_GITLAB_API_URL, GITLAB_ADMIN_TOKEN
from common.utils.K8sAPI import K8sAPI
from urllib.parse import urlparse, quote_plus
from dateutil.relativedelta import relativedelta
from dateutil.rrule import rrule
from ruamel import yaml
from datetime import datetime, timedelta
from celery import current_app
import copy
import operator
import re
import time
import pytz
import os
import json
import requests
import math
import shortuuid
import logging | 15,168 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@Author : Charles Lai
@Contact : qqing_lai@hotmail.com
@Time : 2020/12/21 上午10:00
@FileName: ext_fun.py
@Blog ：https://imaojia.com
"""
logger = logging.getLogger('drf')
class ThirdPartyUser(object):
def get_user(self):
user = UserProfile.objects.get_or_create(username='thirdparty')[0]
self.set_permission(user, self.get_role())
return user
def get_role(self):
return Role.objects.get_or_create(name='thirdparty')[0]
def get_perm(self):
return Permission.objects.get_or_create(name='Jenkins回调', method='jenkins_callback')[0]
def set_permission(self, user, role):
role.permissions.set([self.get_perm().id])
user.roles.set([role.id])
def set_redis_data(name, config):
cache.set(f"system:{name}", config, None)
def get_redis_data(name):
ret = cache.get(f"system:{name}")
if not ret:
try:
if name == 'cicd-harbor':
qs = SystemConfig.objects.filter(type=name)[0]
else:
qs = SystemConfig.objects.get(name=name)
except BaseException as e:
return None
ret = json.loads(qs.config)
set_redis_data(name, ret)
return ret
def get_datadict(name, config=0, default_value=None):
"""
从数据字典获取数据
"""
try:
qs = DataDict.objects.get(key=name)
except BaseException as e:
return default_value
if config:
ret = json.loads(qs.extra)
else:
ret = {'id': qs.id, 'key': qs.key,
'value': qs.value, 'desc': qs.desc}
return ret
def check_pods(cluster_id, k8s_config, namespace, **kwargs):
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@Author : Charles Lai
@Contact : qqing_lai@hotmail.com
@Time : 2020/12/21 上午10:00
@FileName: ext_fun.py
@Blog ：https://imaojia.com
"""
logger = logging.getLogger('drf')
class ThirdPartyUser(object):
def get_user(self):
user = UserProfile.objects.get_or_create(username='thirdparty')[0]
self.set_permission(user, self.get_role())
return user
def get_role(self):
return Role.objects.get_or_create(name='thirdparty')[0]
def get_perm(self):
return Permission.objects.get_or_create(name='Jenkins回调', method='jenkins_callback')[0]
def set_permission(self, user, role):
role.permissions.set([self.get_perm().id])
user.roles.set([role.id])
def set_redis_data(name, config):
cache.set(f"system:{name}", config, None)
def get_redis_data(name):
ret = cache.get(f"system:{name}")
if not ret:
try:
if name == 'cicd-harbor':
qs = SystemConfig.objects.filter(type=name)[0]
else:
qs = SystemConfig.objects.get(name=name)
except BaseException as e:
return None
ret = json.loads(qs.config)
set_redis_data(name, ret)
return ret
def get_datadict(name, config=0, default_value=None):
"""
从数据字典获取数据
"""
try:
qs = DataDict.objects.get(key=name)
except BaseException as e:
return default_value
if config:
ret = json.loads(qs.extra)
else:
ret = {'id': qs.id, 'key': qs.key,
'value': qs.value, 'desc': qs.desc}
return ret
def check_pods(cluster_id, k8s_config, namespace, **kwargs): | k8s = KubernetesCluster.objects.get(id=cluster_id) | 14 | 2023-12-13 03:09:32+00:00 | 24k |
MarilynKeller/aitviewer-skel | aitviewer/renderables/sdf.py | [
{
"identifier": "BoundingBoxes",
"path": "aitviewer/renderables/bounding_boxes.py",
"snippet": "class BoundingBoxes(Node):\n \"\"\"\n Draw bounding boxes.\n \"\"\"\n\n def __init__(self, vertices, thickness=0.005, color=(0.0, 0.0, 1.0, 1.0), **kwargs):\n \"\"\"\n Initializer.\n... | import numpy as np
from skimage import measure
from aitviewer.renderables.bounding_boxes import BoundingBoxes
from aitviewer.renderables.lines import Lines
from aitviewer.renderables.meshes import Meshes
from aitviewer.scene.node import Node
from aitviewer.utils.decorators import hooked | 19,337 | # Copyright (C) 2023 ETH Zurich, Manuel Kaufmann, Velko Vechev, Dario Mylonopoulos
class SDF(Node):
"""
Renderable that can be used to draw level sets of a dense SDF volume meshed using marching cubes.
This renderable internally uses the marching cubes algorithm from skimage.
For a faster marching cubes implementation see the Volume renderable.
"""
def __init__(
self,
volume,
size=(1, 1, 1),
level=0.0,
color=(0.7, 0.7, 0.7, 1.0),
level_sets=None,
level_set_colors=None,
mc_step_size=1,
**kwargs,
):
"""Initializer.
:param volume: np array of shape (X, Y, Z) of signed distance values
:param size: size of the volume in local units.
:param level: the level set used for the main mesh.
:param color: color of the main mesh.
:param level_sets: a list or array of additional level set values to display.
:param level_set_colors: a list or array of shape (L, 4) of the same length as
the level_set parameter with colors to use for the additional level sets.
:param mc_step_size: step size used for marching cubes.
:param **kwargs: arguments forwarded to the Node constructor.
"""
assert len(volume.shape) == 3 and len(size) == 3
kwargs["gui_material"] = False
super().__init__(**kwargs)
self.volume = volume
self.size = np.array((size), np.float32)
# Mesh.
verts, faces, normals, _ = measure.marching_cubes(
volume, level, spacing=self.size / (np.array(self.volume.shape) - 1.0), step_size=mc_step_size
)
self.mesh = Meshes(verts, faces, vertex_normals=-normals, color=color, name="Mesh")
# Level sets.
self.level_sets: list[Meshes] = []
if level_sets is not None:
if level_set_colors is not None:
assert len(level_sets) == len(level_set_colors)
for i, s in enumerate(level_sets):
verts, faces, normals, _ = measure.marching_cubes(
volume, s, spacing=self.size / (np.array(self.volume.shape) - 1.0), step_size=mc_step_size
)
shell = Meshes(verts, faces, vertex_normals=-normals, name=f"Level {s:.03f}", cast_shadow=False)
if level_set_colors is not None:
shell.color = tuple(level_set_colors[i])
shell.clip_control = np.array((1, 1, 1))
shell.clip_value = self.size.copy()
shell.backface_culling = False
self.level_sets.append(shell)
# Bounding box.
| # Copyright (C) 2023 ETH Zurich, Manuel Kaufmann, Velko Vechev, Dario Mylonopoulos
class SDF(Node):
"""
Renderable that can be used to draw level sets of a dense SDF volume meshed using marching cubes.
This renderable internally uses the marching cubes algorithm from skimage.
For a faster marching cubes implementation see the Volume renderable.
"""
def __init__(
self,
volume,
size=(1, 1, 1),
level=0.0,
color=(0.7, 0.7, 0.7, 1.0),
level_sets=None,
level_set_colors=None,
mc_step_size=1,
**kwargs,
):
"""Initializer.
:param volume: np array of shape (X, Y, Z) of signed distance values
:param size: size of the volume in local units.
:param level: the level set used for the main mesh.
:param color: color of the main mesh.
:param level_sets: a list or array of additional level set values to display.
:param level_set_colors: a list or array of shape (L, 4) of the same length as
the level_set parameter with colors to use for the additional level sets.
:param mc_step_size: step size used for marching cubes.
:param **kwargs: arguments forwarded to the Node constructor.
"""
assert len(volume.shape) == 3 and len(size) == 3
kwargs["gui_material"] = False
super().__init__(**kwargs)
self.volume = volume
self.size = np.array((size), np.float32)
# Mesh.
verts, faces, normals, _ = measure.marching_cubes(
volume, level, spacing=self.size / (np.array(self.volume.shape) - 1.0), step_size=mc_step_size
)
self.mesh = Meshes(verts, faces, vertex_normals=-normals, color=color, name="Mesh")
# Level sets.
self.level_sets: list[Meshes] = []
if level_sets is not None:
if level_set_colors is not None:
assert len(level_sets) == len(level_set_colors)
for i, s in enumerate(level_sets):
verts, faces, normals, _ = measure.marching_cubes(
volume, s, spacing=self.size / (np.array(self.volume.shape) - 1.0), step_size=mc_step_size
)
shell = Meshes(verts, faces, vertex_normals=-normals, name=f"Level {s:.03f}", cast_shadow=False)
if level_set_colors is not None:
shell.color = tuple(level_set_colors[i])
shell.clip_control = np.array((1, 1, 1))
shell.clip_value = self.size.copy()
shell.backface_culling = False
self.level_sets.append(shell)
# Bounding box. | self.bounding_box = BoundingBoxes.from_min_max_diagonal( | 0 | 2023-12-07 16:13:50+00:00 | 24k |
nexB/dejacode | product_portfolio/filters.py | [
{
"identifier": "ComponentKeyword",
"path": "component_catalog/models.py",
"snippet": "class ComponentKeyword(DataspacedModel):\n label = models.CharField(\n max_length=50,\n blank=True,\n help_text=_(\n \"A short, descriptive label to categorize components and support... | from django import forms
from django.contrib import admin
from django.utils.translation import gettext_lazy as _
from component_catalog.models import ComponentKeyword
from component_catalog.programming_languages import PROGRAMMING_LANGUAGES
from dje.filters import BooleanChoiceFilter
from dje.filters import DataspacedFilterSet
from dje.filters import DefaultOrderingFilter
from dje.filters import HasRelationFilter
from dje.filters import MatchOrderedSearchFilter
from dje.filters import SearchFilter
from dje.widgets import BootstrapSelectMultipleWidget
from dje.widgets import DropDownWidget
from license_library.models import License
from product_portfolio.models import CodebaseResource
from product_portfolio.models import Product
from product_portfolio.models import ProductComponent
from product_portfolio.models import ProductPackage
from product_portfolio.models import ProductStatus
import django_filters | 14,960 | #
# Copyright (c) nexB Inc. and others. All rights reserved.
# DejaCode is a trademark of nexB Inc.
# SPDX-License-Identifier: AGPL-3.0-only
# See https://github.com/nexB/dejacode for support or download.
# See https://aboutcode.org for more information about AboutCode FOSS projects.
#
class ProductFilterSet(DataspacedFilterSet):
q = MatchOrderedSearchFilter(
label=_("Search"),
match_order_fields=[
"name",
"components__name",
"packages__filename",
],
search_fields=[
"name",
"version",
"components__name",
"packages__filename",
],
distinct=True,
widget=forms.widgets.HiddenInput,
)
sort = DefaultOrderingFilter(
label=_("Sort"),
fields=[
"name",
"version",
"license_expression",
"primary_language",
"owner",
"configuration_status",
],
field_labels={
"primary_language": "Language",
"configuration_status": "Configuration Status",
},
empty_label="Default",
)
configuration_status = django_filters.ModelMultipleChoiceFilter(
label=_("Configuration status"),
field_name="configuration_status__label",
to_field_name="label",
queryset=ProductStatus.objects.all(),
widget=BootstrapSelectMultipleWidget(
search=False,
search_placeholder="Search configuration status",
),
)
primary_language = django_filters.MultipleChoiceFilter(
label=_("Language"),
choices=[(language, language) for language in PROGRAMMING_LANGUAGES],
widget=BootstrapSelectMultipleWidget(
search_placeholder="Search languages",
),
)
licenses = django_filters.ModelMultipleChoiceFilter(
label=_("License"),
field_name="licenses__key",
to_field_name="key",
queryset=License.objects.all(),
widget=BootstrapSelectMultipleWidget(
search_placeholder="Search licenses",
),
)
keywords = django_filters.ModelMultipleChoiceFilter(
label=_("Keyword"),
to_field_name="label",
lookup_expr="contains",
queryset=ComponentKeyword.objects.all().only("label", "dataspace"),
widget=BootstrapSelectMultipleWidget(
search_placeholder="Search keywords",
),
)
class Meta:
model = Product
fields = [
"q",
"licenses",
"primary_language",
"configuration_status",
"keywords",
]
class BaseProductRelationFilterSet(DataspacedFilterSet):
is_deployed = BooleanChoiceFilter(
empty_label="All (Inventory)",
choices=(
("yes", _("Yes (BOM)")),
("no", _("No (Internal Use Only)")),
),
| #
# Copyright (c) nexB Inc. and others. All rights reserved.
# DejaCode is a trademark of nexB Inc.
# SPDX-License-Identifier: AGPL-3.0-only
# See https://github.com/nexB/dejacode for support or download.
# See https://aboutcode.org for more information about AboutCode FOSS projects.
#
class ProductFilterSet(DataspacedFilterSet):
q = MatchOrderedSearchFilter(
label=_("Search"),
match_order_fields=[
"name",
"components__name",
"packages__filename",
],
search_fields=[
"name",
"version",
"components__name",
"packages__filename",
],
distinct=True,
widget=forms.widgets.HiddenInput,
)
sort = DefaultOrderingFilter(
label=_("Sort"),
fields=[
"name",
"version",
"license_expression",
"primary_language",
"owner",
"configuration_status",
],
field_labels={
"primary_language": "Language",
"configuration_status": "Configuration Status",
},
empty_label="Default",
)
configuration_status = django_filters.ModelMultipleChoiceFilter(
label=_("Configuration status"),
field_name="configuration_status__label",
to_field_name="label",
queryset=ProductStatus.objects.all(),
widget=BootstrapSelectMultipleWidget(
search=False,
search_placeholder="Search configuration status",
),
)
primary_language = django_filters.MultipleChoiceFilter(
label=_("Language"),
choices=[(language, language) for language in PROGRAMMING_LANGUAGES],
widget=BootstrapSelectMultipleWidget(
search_placeholder="Search languages",
),
)
licenses = django_filters.ModelMultipleChoiceFilter(
label=_("License"),
field_name="licenses__key",
to_field_name="key",
queryset=License.objects.all(),
widget=BootstrapSelectMultipleWidget(
search_placeholder="Search licenses",
),
)
keywords = django_filters.ModelMultipleChoiceFilter(
label=_("Keyword"),
to_field_name="label",
lookup_expr="contains",
queryset=ComponentKeyword.objects.all().only("label", "dataspace"),
widget=BootstrapSelectMultipleWidget(
search_placeholder="Search keywords",
),
)
class Meta:
model = Product
fields = [
"q",
"licenses",
"primary_language",
"configuration_status",
"keywords",
]
class BaseProductRelationFilterSet(DataspacedFilterSet):
is_deployed = BooleanChoiceFilter(
empty_label="All (Inventory)",
choices=(
("yes", _("Yes (BOM)")),
("no", _("No (Internal Use Only)")),
), | widget=DropDownWidget( | 9 | 2023-12-07 16:57:42+00:00 | 24k |
wusize/CLIM | src/open_clip/model.py | [
{
"identifier": "HFTextEncoder",
"path": "src/open_clip/hf_model.py",
"snippet": "class HFTextEncoder(nn.Module):\n \"\"\"HuggingFace model adapter\"\"\"\n output_tokens: torch.jit.Final[bool]\n\n def __init__(\n self,\n model_name_or_path: str,\n output_dim: in... | from dataclasses import dataclass
from typing import Optional, Tuple, Union
from torch import nn
from torch.utils.checkpoint import checkpoint
from .hf_model import HFTextEncoder
from .modified_resnet import ModifiedResNet
from .timm_model import TimmModel
from .transformer import LayerNormFp32, LayerNorm, QuickGELU, Attention, VisionTransformer, TextTransformer
from .utils import to_2tuple
import logging
import math
import numpy as np
import torch
import torch.nn.functional as F | 16,255 | timm_drop_path: Optional[float] = None # backbone stochastic depth
output_tokens: bool = False
freeze_output = True
freeze_all_bns = True
@dataclass
class CLIPTextCfg:
context_length: int = 77
vocab_size: int = 49408
width: int = 512
heads: int = 8
layers: int = 12
ls_init_value: Optional[float] = None # layer scale initial value
hf_model_name: str = None
hf_tokenizer_name: str = None
hf_model_pretrained: bool = True
proj: str = 'mlp'
pooler_type: str = 'mean_pooler'
embed_cls: bool = False
pad_id: int = 0
output_tokens: bool = False
def get_cast_dtype(precision: str):
cast_dtype = None
if precision == 'bf16':
cast_dtype = torch.bfloat16
elif precision == 'fp16':
cast_dtype = torch.float16
return cast_dtype
def _build_vision_tower(
embed_dim: int,
vision_cfg: CLIPVisionCfg,
quick_gelu: bool = False,
cast_dtype: Optional[torch.dtype] = None
):
if isinstance(vision_cfg, dict):
vision_cfg = CLIPVisionCfg(**vision_cfg)
# OpenAI models are pretrained w/ QuickGELU but native nn.GELU is both faster and more
# memory efficient in recent PyTorch releases (>= 1.10).
# NOTE: timm models always use native GELU regardless of quick_gelu flag.
act_layer = QuickGELU if quick_gelu else nn.GELU
if vision_cfg.timm_model_name:
visual = TimmModel(
vision_cfg.timm_model_name,
pretrained=vision_cfg.timm_model_pretrained,
pool=vision_cfg.timm_pool,
proj=vision_cfg.timm_proj,
proj_bias=vision_cfg.timm_proj_bias,
drop=vision_cfg.timm_drop,
drop_path=vision_cfg.timm_drop_path,
patch_drop=vision_cfg.patch_dropout if vision_cfg.patch_dropout > 0 else None,
embed_dim=embed_dim,
image_size=vision_cfg.image_size,
)
act_layer = nn.GELU # so that text transformer doesn't use QuickGELU w/ timm models
elif isinstance(vision_cfg.layers, (tuple, list)):
vision_heads = vision_cfg.width * 32 // vision_cfg.head_width
visual = ModifiedResNet(
layers=vision_cfg.layers,
output_dim=embed_dim,
heads=vision_heads,
image_size=vision_cfg.image_size,
width=vision_cfg.width,
freeze_output=vision_cfg.freeze_output,
freeze_all_bns=vision_cfg.freeze_all_bns
)
else:
vision_heads = vision_cfg.width // vision_cfg.head_width
norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm
visual = VisionTransformer(
image_size=vision_cfg.image_size,
patch_size=vision_cfg.patch_size,
width=vision_cfg.width,
layers=vision_cfg.layers,
heads=vision_heads,
mlp_ratio=vision_cfg.mlp_ratio,
ls_init_value=vision_cfg.ls_init_value,
patch_dropout=vision_cfg.patch_dropout,
input_patchnorm=vision_cfg.input_patchnorm,
global_average_pool=vision_cfg.global_average_pool,
attentional_pool=vision_cfg.attentional_pool,
n_queries=vision_cfg.n_queries,
attn_pooler_heads=vision_cfg.attn_pooler_heads,
output_tokens=vision_cfg.output_tokens,
output_dim=embed_dim,
act_layer=act_layer,
norm_layer=norm_layer,
)
return visual
def _build_text_tower(
embed_dim: int,
text_cfg: CLIPTextCfg,
quick_gelu: bool = False,
cast_dtype: Optional[torch.dtype] = None,
):
if isinstance(text_cfg, dict):
text_cfg = CLIPTextCfg(**text_cfg)
if text_cfg.hf_model_name:
text = HFTextEncoder(
text_cfg.hf_model_name,
output_dim=embed_dim,
proj=text_cfg.proj,
pooler_type=text_cfg.pooler_type,
pretrained=text_cfg.hf_model_pretrained,
output_tokens=text_cfg.output_tokens,
)
else:
act_layer = QuickGELU if quick_gelu else nn.GELU
norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm
| """ CLIP Model
Adapted from https://github.com/openai/CLIP. Originally MIT License, Copyright (c) 2021 OpenAI.
"""
@dataclass
class CLIPVisionCfg:
layers: Union[Tuple[int, int, int, int], int] = 12
width: int = 768
head_width: int = 64
mlp_ratio: float = 4.0
patch_size: int = 16
image_size: Union[Tuple[int, int], int] = 224
ls_init_value: Optional[float] = None # layer scale initial value
patch_dropout: float = 0. # what fraction of patches to dropout during training (0 would mean disabled and no patches dropped) - 0.5 to 0.75 recommended in the paper for optimal results
input_patchnorm: bool = False # whether to use dual patchnorm - would only apply the input layernorm on each patch, as post-layernorm already exist in original clip vit design
global_average_pool: bool = False # whether to global average pool the last embedding layer, instead of using CLS token (https://arxiv.org/abs/2205.01580)
attentional_pool: bool = False # whether to use attentional pooler in the last embedding layer
n_queries: int = 256 # n_queries for attentional pooler
attn_pooler_heads: int = 8 # n heads for attentional_pooling
timm_model_name: str = None # a valid model name overrides layers, width, patch_size
timm_model_pretrained: bool = False # use (imagenet) pretrained weights for named model
timm_pool: str = 'avg' # feature pooling for timm model ('abs_attn', 'rot_attn', 'avg', '')
timm_proj: str = 'linear' # linear projection for timm model output ('linear', 'mlp', '')
timm_proj_bias: bool = False # enable bias final projection
timm_drop: float = 0. # head dropout
timm_drop_path: Optional[float] = None # backbone stochastic depth
output_tokens: bool = False
freeze_output = True
freeze_all_bns = True
@dataclass
class CLIPTextCfg:
context_length: int = 77
vocab_size: int = 49408
width: int = 512
heads: int = 8
layers: int = 12
ls_init_value: Optional[float] = None # layer scale initial value
hf_model_name: str = None
hf_tokenizer_name: str = None
hf_model_pretrained: bool = True
proj: str = 'mlp'
pooler_type: str = 'mean_pooler'
embed_cls: bool = False
pad_id: int = 0
output_tokens: bool = False
def get_cast_dtype(precision: str):
cast_dtype = None
if precision == 'bf16':
cast_dtype = torch.bfloat16
elif precision == 'fp16':
cast_dtype = torch.float16
return cast_dtype
def _build_vision_tower(
embed_dim: int,
vision_cfg: CLIPVisionCfg,
quick_gelu: bool = False,
cast_dtype: Optional[torch.dtype] = None
):
if isinstance(vision_cfg, dict):
vision_cfg = CLIPVisionCfg(**vision_cfg)
# OpenAI models are pretrained w/ QuickGELU but native nn.GELU is both faster and more
# memory efficient in recent PyTorch releases (>= 1.10).
# NOTE: timm models always use native GELU regardless of quick_gelu flag.
act_layer = QuickGELU if quick_gelu else nn.GELU
if vision_cfg.timm_model_name:
visual = TimmModel(
vision_cfg.timm_model_name,
pretrained=vision_cfg.timm_model_pretrained,
pool=vision_cfg.timm_pool,
proj=vision_cfg.timm_proj,
proj_bias=vision_cfg.timm_proj_bias,
drop=vision_cfg.timm_drop,
drop_path=vision_cfg.timm_drop_path,
patch_drop=vision_cfg.patch_dropout if vision_cfg.patch_dropout > 0 else None,
embed_dim=embed_dim,
image_size=vision_cfg.image_size,
)
act_layer = nn.GELU # so that text transformer doesn't use QuickGELU w/ timm models
elif isinstance(vision_cfg.layers, (tuple, list)):
vision_heads = vision_cfg.width * 32 // vision_cfg.head_width
visual = ModifiedResNet(
layers=vision_cfg.layers,
output_dim=embed_dim,
heads=vision_heads,
image_size=vision_cfg.image_size,
width=vision_cfg.width,
freeze_output=vision_cfg.freeze_output,
freeze_all_bns=vision_cfg.freeze_all_bns
)
else:
vision_heads = vision_cfg.width // vision_cfg.head_width
norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm
visual = VisionTransformer(
image_size=vision_cfg.image_size,
patch_size=vision_cfg.patch_size,
width=vision_cfg.width,
layers=vision_cfg.layers,
heads=vision_heads,
mlp_ratio=vision_cfg.mlp_ratio,
ls_init_value=vision_cfg.ls_init_value,
patch_dropout=vision_cfg.patch_dropout,
input_patchnorm=vision_cfg.input_patchnorm,
global_average_pool=vision_cfg.global_average_pool,
attentional_pool=vision_cfg.attentional_pool,
n_queries=vision_cfg.n_queries,
attn_pooler_heads=vision_cfg.attn_pooler_heads,
output_tokens=vision_cfg.output_tokens,
output_dim=embed_dim,
act_layer=act_layer,
norm_layer=norm_layer,
)
return visual
def _build_text_tower(
embed_dim: int,
text_cfg: CLIPTextCfg,
quick_gelu: bool = False,
cast_dtype: Optional[torch.dtype] = None,
):
if isinstance(text_cfg, dict):
text_cfg = CLIPTextCfg(**text_cfg)
if text_cfg.hf_model_name:
text = HFTextEncoder(
text_cfg.hf_model_name,
output_dim=embed_dim,
proj=text_cfg.proj,
pooler_type=text_cfg.pooler_type,
pretrained=text_cfg.hf_model_pretrained,
output_tokens=text_cfg.output_tokens,
)
else:
act_layer = QuickGELU if quick_gelu else nn.GELU
norm_layer = LayerNormFp32 if cast_dtype in (torch.float16, torch.bfloat16) else LayerNorm
| text = TextTransformer( | 8 | 2023-12-09 05:43:08+00:00 | 24k |
LkPrtctrd/BSL-V53 | Heart/Logic/LogicLaserMessageFactory.py | [
{
"identifier": "ClientHelloMessage",
"path": "Heart/Packets/Client/Authentification/ClientHelloMessage.py",
"snippet": "class ClientHelloMessage(PiranhaMessage):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageVersion = 0\n\n def encode(self, fields)... | from Heart.Packets.Client.Authentification.ClientHelloMessage import ClientHelloMessage
from Heart.Packets.Client.Authentification.LoginMessage import LoginMessage
from Heart.Packets.Client.Battle.AskForBattleEndMessage import AskForBattleEndMessage
from Heart.Packets.Client.Home.ChangeAvatarNameMessage import ChangeAvatarNameMessage
from Heart.Packets.Client.Home.EndClientTurnMessage import EndClientTurnMessage
from Heart.Packets.Client.Home.GoHomeFromOfflinePractiseMessage import GoHomeFromOfflinePractiseMessage
from Heart.Packets.Client.Home.GoHomeMessage import GoHomeMessage
from Heart.Packets.Client.Home.GetPlayerProfileMessage import GetPlayerProfileMessage
from Heart.Packets.Client.Home.AskForAllianceDataMessage import AskForAllianceDataMessage
from Heart.Packets.Client.Socket.KeepAliveMessage import KeepAliveMessage
from Heart.Packets.Server.Authentification.LoginFailedMessage import LoginFailedMessage
from Heart.Packets.Server.Authentification.LoginOkMessage import LoginOkMessage
from Heart.Packets.Server.Authentification.OutOfSyncMessage import OutOfSyncMessage
from Heart.Packets.Server.Authentification.ServerHelloMessage import ServerHelloMessage
from Heart.Packets.Server.Battle.BattleEndMessage import BattleEndMessage
from Heart.Packets.Server.Home.AvailableServerCommandMessage import AvailableServerCommandMessage
from Heart.Packets.Server.Home.LobbyInfoMessage import LobbyInfoMessage
from Heart.Packets.Server.Home.OwnHomeDataMessage import OwnHomeDataMessage
from Heart.Packets.Server.Socket.KeepAliveServerMessage import KeepAliveServerMessage
from Heart.Packets.Server.Home.PlayerProfileMessage import PlayerProfileMessage
from Heart.Packets.Server.Home.MyAllianceMessage import MyAllianceMessage
from Heart.Packets.Server.Home.AllianceDataMessage import AllianceDataMessage | 16,026 | 12111: 'SignoffPlayerMapMessage',
12125: 'ReportPlayerMapMessage',
12152: 'RankedMatchBanHeroMessage',
12155: 'RankedMatchPickHeroMessage',
12157: 'RankedMatchUpdateHeroDataMessage',
12905: 'GetCurrentBattleReplayDataMessage',
12998: 'SetCountryMessage',
13922: 'AcceptTokenFriendMessage',
14101: GoHomeMessage,
14102: EndClientTurnMessage,
14103: 'StartGameMessage',
14104: 'StartSpectateMessage',
14105: 'HomeLogicStoppedMessage',
14106: 'CancelMatchmakingMessage',
14107: 'StopSpectateMessage',
14108: 'GoHomeFromSpectateMessage',
#14109: GoHomeFromOfflinePractiseMessage, //before v50
14110: AskForBattleEndMessage,
#14113: GetPlayerProfileMessage, //before v50
14114: 'GetBattleLogMessage',
14115: 'BattleLogViewReplayMessage',
14116: 'ViewReplayByStringMessage',
14117: 'RequestMatchCancelMessage',
14118: 'SinglePlayerMatchRequestMessage',
14166: 'ChronosEventSeenMessage',
14167: 'ChronosEventSeenMessage',
14177: 'PlayAgainMessage',
14178: 'DebugCommandMessage',
14199: 'LookForGameRoomRequestMessage',
14211: 'UnbindFacebookAccountMessage',
14201: 'BindFacebookAccountMessage',
14202: 'BindKakaoAccountMessage',
14203: 'BingLineAccountMessage',
14212: 'BindGamecenterAccountMessage',
14213: 'UnbindKakaoAccountMessage',
14214: 'UnbindLineAccountMessage',
14262: 'BindGoogleServiceAccountMessage',
14266: 'BindTencentAccountMessage',
14268: 'TencentCheckCanPayMessage',
14276: 'TencentAntiAddictionInstructionExecutedMessage',
14277: 'GetSeasonRewardsMessage',
14299: 'SetAllianceCountryMessage',
14301: 'CreateAllianceMessage',
14302: AskForAllianceDataMessage,
14303: 'AskForJoinableAlliancesListMessage',
14304: 'AskForAllianceStreamMessage',
14305: 'JoinAllianceMessage',
14306: 'ChangeAllianceMemberRoleMessage',
14307: 'KickAllianceMemberMessage',
14308: 'LeaveAllianceMessage',
14315: 'ChatToAllianceStreamMessage',
14316: 'ChangeAllianceSettingsMessage',
14317: 'RequestJoinAllianceMessage',
14321: 'RespondToAllianceJoinRequestMessage',
14322: 'SendAllianceInvitationMessage',
14323: 'JoinAllianceUsingInvitationMessage',
14324: 'SearchAlliancesMessage',
14326: 'SendAllianceInvitationToFriendMessage',
14330: 'SendAllianceMailMessage',
14350: 'TeamCreateMessage',
14351: 'TeamJoinMessage',
14352: 'TeamKickMessage',
14353: 'TeamLeaveMessage',
14354: 'TeamChangeMemberSettingsMessage',
14355: 'TeamSetMemberReadyMessage',
14356: 'TeamTogglePractiseMessage',
14357: 'TeamToggleMemberSideMessage',
14358: 'TeamSpectateMessage',
14359: 'TeamChatMessage',
14360: 'TeamPostAdMessage',
14361: 'TeamMemberStatusMessage',
14362: 'TeamSetEventMessage',
14363: 'TeamSetLocationMessage',
14364: 'TeamReportChatMessage',
14365: 'TeamInviteMessage',
14366: 'PlayerStatusMessage',
14367: 'TeamClearInviteMessage',
14368: 'TeamInviteResponseMessage',
14369: 'TeamPremadeChatMessage',
14370: 'TeamAllianceMemberInviteMessage',
14371: 'TeamJoinOrCreateGameRoomMessage',
14372: 'TeamToggleSettingsMessage',
14373: 'TeamBotSlotDisableMessage',
14403: 'GetLeaderboardMessage',
14405: 'AskForAvatarStreamMessage',
14406: 'AskForBattleReplayStreamMessage',
14418: 'RemoveAvatarStreamEntryMessage',
14469: 'AlliancePremadeChatMessage',
14479: 'TeamInvitationResponseMessage',
14600: 'AvatarNameCheckRequestMessage',
14700: 'ListBrawlTvChannelsMessage',
14701: 'TuneBrawlTvChannelMessage',
14715: 'SendGlobalChatLineMessage',
14777: 'SetInvitesBlockedMessage',
14778: 'SetTeamChatMutedMessage',
14867: 'SetRegionMessage',
14880: 'TeamRequestJoinCancelMessage',
14881: 'TeamRequestJoinMessage',
14882: 'TeamRequestJoinApproveMessage',
15081: GetPlayerProfileMessage, #v50
15793: 'GetTokenFriendMessage',
16000: 'LogicDeviceLinkCodeRequestMessage',
16001: 'LogicDeviceLinkMenuClosedMessage',
16002: 'LogicDeviceLinkEnterCodeMessage',
16003: 'LogicDeviceLinkConfirmYesMessage',
16939: 'AskApiTokenMessage',
17000: 'LogicAccountTransferCodeRequestMessage',
17190: 'JoinAllianceUsingTokenMessage',
17337: 'UnbotifyReportMessage',
17338: 'AdjustPackageMessage',
17750: GoHomeFromOfflinePractiseMessage, #v50
18686: 'SetSupportedCreatorMessage',
19001: 'LatencyTestResultMessage',
19002: 'UdpLatencyTestRequestMessage',
19003: 'TriggerStartLatencyTestMessage',
19004: 'RequestLatencyTestStatusMessage',
20000: 'SetEncryptionMessage',
20100: ServerHelloMessage,
20101: 'CreateAccountOkMessage',
20103: LoginFailedMessage,
|
class LogicLaserMessageFactory:
messagesList = {
10055: 'AskPlayerJWTokenMessage',
10099: 'ClientCryptoErrorMessage',
10100: ClientHelloMessage,
10101: LoginMessage,
10102: 'LoginUsingSessionMessage',
10103: 'CreateAccountMessage',
10107: 'ClientCapabilitiesMessage',
10108: KeepAliveMessage,
10109: 'UdpCheckConnectionMessage',
10110: 'AnalyticEventMessage',
10111: 'AccountIdentifiersMessage',
10112: 'AuthenticationCheckMessage',
10113: 'SetDeviceTokenMessage',
10116: 'ResetAccountMessage',
10117: 'ReportUserMessage',
10118: 'AccountSwitchedMessage',
10119: 'ReportAllianceStreamMessage',
10121: 'UnlockAccountMessage',
10150: 'AppleBillingRequestMessage',
10151: 'GoogleBillingRequestMessage',
10152: 'TencentBillingRequestMessage',
10153: 'CafeBazaarBillingRequestMessage',
10159: 'KunlunBillingRequestMessage',
10160: 'BillingCancelledByClientMessage',
10177: 'ClientInfoMessage',
10212: ChangeAvatarNameMessage,
10309: 'GetAllianceInviteTokenMessage',
10321: 'AttributionEventMessage',
10401: 'CreateGameMessage',
10501: 'AcceptFriendMessage',
10502: 'AddFriendMessage',
10503: 'AskForAddableFriendsMessage',
10504: 'AskForFriendListMessage',
10506: 'RemoveFriendMessage',
10507: 'AddFriendByEmailMessage',
10509: 'AddFriendByAvatarNameAndCodeMessage',
10512: 'AskForPlayingGamecenterFriendsMessage',
10513: 'AskForPlayingFacebookFriendsMessage',
10514: 'AskForPlayingKakaoFriendsMessage',
10515: 'AskForPlayingTencentFriendsMessage',
10516: 'AskForPlayingLineFriendsMessage',
10517: 'AskForPlayingSupercellFriendsMessage',
10523: 'YoozooBillingRequestMessage',
10555: 'ClientInputMessage',
10576: 'SetBlockFriendRequestsMessage',
10599: 'AskForFriendSuggestionsMessage',
10636: 'SCIDBindAccountMessage',
11736: 'SCIDLogoutAllDevicesMessage',
12100: 'CreatePlayerMapMessage',
12101: 'DeletePlayerMapMessage',
12102: 'GetPlayerMapsMessage',
12103: 'UpdatePlayerMapMessage',
12104: 'SubmitPlayerMapMessage',
12105: 'PublishPlayerMapMessage',
12106: 'ChangePlayerMapNameMessage',
12107: 'EnterMapEditorMessage',
12108: 'GoHomeFromMapEditorMessage',
12110: 'TeamSetPlayerMapMessage',
12111: 'SignoffPlayerMapMessage',
12125: 'ReportPlayerMapMessage',
12152: 'RankedMatchBanHeroMessage',
12155: 'RankedMatchPickHeroMessage',
12157: 'RankedMatchUpdateHeroDataMessage',
12905: 'GetCurrentBattleReplayDataMessage',
12998: 'SetCountryMessage',
13922: 'AcceptTokenFriendMessage',
14101: GoHomeMessage,
14102: EndClientTurnMessage,
14103: 'StartGameMessage',
14104: 'StartSpectateMessage',
14105: 'HomeLogicStoppedMessage',
14106: 'CancelMatchmakingMessage',
14107: 'StopSpectateMessage',
14108: 'GoHomeFromSpectateMessage',
#14109: GoHomeFromOfflinePractiseMessage, //before v50
14110: AskForBattleEndMessage,
#14113: GetPlayerProfileMessage, //before v50
14114: 'GetBattleLogMessage',
14115: 'BattleLogViewReplayMessage',
14116: 'ViewReplayByStringMessage',
14117: 'RequestMatchCancelMessage',
14118: 'SinglePlayerMatchRequestMessage',
14166: 'ChronosEventSeenMessage',
14167: 'ChronosEventSeenMessage',
14177: 'PlayAgainMessage',
14178: 'DebugCommandMessage',
14199: 'LookForGameRoomRequestMessage',
14211: 'UnbindFacebookAccountMessage',
14201: 'BindFacebookAccountMessage',
14202: 'BindKakaoAccountMessage',
14203: 'BingLineAccountMessage',
14212: 'BindGamecenterAccountMessage',
14213: 'UnbindKakaoAccountMessage',
14214: 'UnbindLineAccountMessage',
14262: 'BindGoogleServiceAccountMessage',
14266: 'BindTencentAccountMessage',
14268: 'TencentCheckCanPayMessage',
14276: 'TencentAntiAddictionInstructionExecutedMessage',
14277: 'GetSeasonRewardsMessage',
14299: 'SetAllianceCountryMessage',
14301: 'CreateAllianceMessage',
14302: AskForAllianceDataMessage,
14303: 'AskForJoinableAlliancesListMessage',
14304: 'AskForAllianceStreamMessage',
14305: 'JoinAllianceMessage',
14306: 'ChangeAllianceMemberRoleMessage',
14307: 'KickAllianceMemberMessage',
14308: 'LeaveAllianceMessage',
14315: 'ChatToAllianceStreamMessage',
14316: 'ChangeAllianceSettingsMessage',
14317: 'RequestJoinAllianceMessage',
14321: 'RespondToAllianceJoinRequestMessage',
14322: 'SendAllianceInvitationMessage',
14323: 'JoinAllianceUsingInvitationMessage',
14324: 'SearchAlliancesMessage',
14326: 'SendAllianceInvitationToFriendMessage',
14330: 'SendAllianceMailMessage',
14350: 'TeamCreateMessage',
14351: 'TeamJoinMessage',
14352: 'TeamKickMessage',
14353: 'TeamLeaveMessage',
14354: 'TeamChangeMemberSettingsMessage',
14355: 'TeamSetMemberReadyMessage',
14356: 'TeamTogglePractiseMessage',
14357: 'TeamToggleMemberSideMessage',
14358: 'TeamSpectateMessage',
14359: 'TeamChatMessage',
14360: 'TeamPostAdMessage',
14361: 'TeamMemberStatusMessage',
14362: 'TeamSetEventMessage',
14363: 'TeamSetLocationMessage',
14364: 'TeamReportChatMessage',
14365: 'TeamInviteMessage',
14366: 'PlayerStatusMessage',
14367: 'TeamClearInviteMessage',
14368: 'TeamInviteResponseMessage',
14369: 'TeamPremadeChatMessage',
14370: 'TeamAllianceMemberInviteMessage',
14371: 'TeamJoinOrCreateGameRoomMessage',
14372: 'TeamToggleSettingsMessage',
14373: 'TeamBotSlotDisableMessage',
14403: 'GetLeaderboardMessage',
14405: 'AskForAvatarStreamMessage',
14406: 'AskForBattleReplayStreamMessage',
14418: 'RemoveAvatarStreamEntryMessage',
14469: 'AlliancePremadeChatMessage',
14479: 'TeamInvitationResponseMessage',
14600: 'AvatarNameCheckRequestMessage',
14700: 'ListBrawlTvChannelsMessage',
14701: 'TuneBrawlTvChannelMessage',
14715: 'SendGlobalChatLineMessage',
14777: 'SetInvitesBlockedMessage',
14778: 'SetTeamChatMutedMessage',
14867: 'SetRegionMessage',
14880: 'TeamRequestJoinCancelMessage',
14881: 'TeamRequestJoinMessage',
14882: 'TeamRequestJoinApproveMessage',
15081: GetPlayerProfileMessage, #v50
15793: 'GetTokenFriendMessage',
16000: 'LogicDeviceLinkCodeRequestMessage',
16001: 'LogicDeviceLinkMenuClosedMessage',
16002: 'LogicDeviceLinkEnterCodeMessage',
16003: 'LogicDeviceLinkConfirmYesMessage',
16939: 'AskApiTokenMessage',
17000: 'LogicAccountTransferCodeRequestMessage',
17190: 'JoinAllianceUsingTokenMessage',
17337: 'UnbotifyReportMessage',
17338: 'AdjustPackageMessage',
17750: GoHomeFromOfflinePractiseMessage, #v50
18686: 'SetSupportedCreatorMessage',
19001: 'LatencyTestResultMessage',
19002: 'UdpLatencyTestRequestMessage',
19003: 'TriggerStartLatencyTestMessage',
19004: 'RequestLatencyTestStatusMessage',
20000: 'SetEncryptionMessage',
20100: ServerHelloMessage,
20101: 'CreateAccountOkMessage',
20103: LoginFailedMessage, | 20104: LoginOkMessage, | 11 | 2023-12-14 18:57:56+00:00 | 24k |
GXNU-ZhongLab/ODTrack | lib/train/base_functions.py | [
{
"identifier": "Lasot",
"path": "lib/train/dataset/lasot.py",
"snippet": "class Lasot(BaseVideoDataset):\n \"\"\" LaSOT dataset.\n\n Publication:\n LaSOT: A High-quality Benchmark for Large-scale Single Object Tracking\n Heng Fan, Liting Lin, Fan Yang, Peng Chu, Ge Deng, Sijia Yu, H... | import os
import torch
import lib.train.data.transforms as tfm
from torch.utils.data.distributed import DistributedSampler
from lib.train.dataset import Lasot, Got10k, MSCOCOSeq, ImagenetVID, TrackingNet
from lib.train.dataset import Lasot_lmdb, Got10k_lmdb, MSCOCOSeq_lmdb, ImagenetVID_lmdb, TrackingNet_lmdb
from lib.train.data import sampler, opencv_loader, processing, LTRLoader
from lib.utils.misc import is_main_process | 18,241 | # datasets related
def update_settings(settings, cfg):
settings.print_interval = cfg.TRAIN.PRINT_INTERVAL
settings.search_area_factor = {'template': cfg.DATA.TEMPLATE.FACTOR,
'search': cfg.DATA.SEARCH.FACTOR}
settings.output_sz = {'template': cfg.DATA.TEMPLATE.SIZE,
'search': cfg.DATA.SEARCH.SIZE}
settings.center_jitter_factor = {'template': cfg.DATA.TEMPLATE.CENTER_JITTER,
'search': cfg.DATA.SEARCH.CENTER_JITTER}
settings.scale_jitter_factor = {'template': cfg.DATA.TEMPLATE.SCALE_JITTER,
'search': cfg.DATA.SEARCH.SCALE_JITTER}
settings.grad_clip_norm = cfg.TRAIN.GRAD_CLIP_NORM
settings.print_stats = None
settings.batchsize = cfg.TRAIN.BATCH_SIZE
settings.scheduler_type = cfg.TRAIN.SCHEDULER.TYPE
def names2datasets(name_list: list, settings, image_loader):
assert isinstance(name_list, list)
datasets = []
for name in name_list:
assert name in ["LASOT", "GOT10K_vottrain", "GOT10K_votval", "GOT10K_train_full", "GOT10K_official_val",
"COCO17", "VID", "TRACKINGNET",
]
# Tracking Task
if name == "LASOT":
if settings.use_lmdb:
print("Building lasot dataset from lmdb")
datasets.append(Lasot_lmdb(settings.env.lasot_lmdb_dir, split='train', image_loader=image_loader))
else:
datasets.append(Lasot(settings.env.lasot_dir, split='train', image_loader=image_loader))
if name == "GOT10K_vottrain":
if settings.use_lmdb:
print("Building got10k from lmdb")
datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='vottrain', image_loader=image_loader))
else:
datasets.append(Got10k(settings.env.got10k_dir, split='vottrain', image_loader=image_loader))
if name == "GOT10K_train_full":
if settings.use_lmdb:
print("Building got10k_train_full from lmdb")
datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='train_full', image_loader=image_loader))
else:
datasets.append(Got10k(settings.env.got10k_dir, split='train_full', image_loader=image_loader))
if name == "GOT10K_votval":
if settings.use_lmdb:
print("Building got10k from lmdb")
datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='votval', image_loader=image_loader))
else:
datasets.append(Got10k(settings.env.got10k_dir, split='votval', image_loader=image_loader))
if name == "GOT10K_official_val":
if settings.use_lmdb:
raise ValueError("Not implement")
else:
datasets.append(Got10k(settings.env.got10k_val_dir, split=None, image_loader=image_loader))
if name == "COCO17":
if settings.use_lmdb:
print("Building COCO2017 from lmdb")
datasets.append(MSCOCOSeq_lmdb(settings.env.coco_lmdb_dir, version="2017", image_loader=image_loader))
else:
datasets.append(MSCOCOSeq(settings.env.coco_dir, version="2017", image_loader=image_loader))
if name == "VID":
if settings.use_lmdb:
print("Building VID from lmdb")
datasets.append(ImagenetVID_lmdb(settings.env.imagenet_lmdb_dir, image_loader=image_loader))
else:
datasets.append(ImagenetVID(settings.env.imagenet_dir, image_loader=image_loader))
if name == "TRACKINGNET":
if settings.use_lmdb:
print("Building TrackingNet from lmdb")
datasets.append(TrackingNet_lmdb(settings.env.trackingnet_lmdb_dir, image_loader=image_loader))
else:
# raise ValueError("NOW WE CAN ONLY USE TRACKINGNET FROM LMDB")
| # datasets related
def update_settings(settings, cfg):
settings.print_interval = cfg.TRAIN.PRINT_INTERVAL
settings.search_area_factor = {'template': cfg.DATA.TEMPLATE.FACTOR,
'search': cfg.DATA.SEARCH.FACTOR}
settings.output_sz = {'template': cfg.DATA.TEMPLATE.SIZE,
'search': cfg.DATA.SEARCH.SIZE}
settings.center_jitter_factor = {'template': cfg.DATA.TEMPLATE.CENTER_JITTER,
'search': cfg.DATA.SEARCH.CENTER_JITTER}
settings.scale_jitter_factor = {'template': cfg.DATA.TEMPLATE.SCALE_JITTER,
'search': cfg.DATA.SEARCH.SCALE_JITTER}
settings.grad_clip_norm = cfg.TRAIN.GRAD_CLIP_NORM
settings.print_stats = None
settings.batchsize = cfg.TRAIN.BATCH_SIZE
settings.scheduler_type = cfg.TRAIN.SCHEDULER.TYPE
def names2datasets(name_list: list, settings, image_loader):
assert isinstance(name_list, list)
datasets = []
for name in name_list:
assert name in ["LASOT", "GOT10K_vottrain", "GOT10K_votval", "GOT10K_train_full", "GOT10K_official_val",
"COCO17", "VID", "TRACKINGNET",
]
# Tracking Task
if name == "LASOT":
if settings.use_lmdb:
print("Building lasot dataset from lmdb")
datasets.append(Lasot_lmdb(settings.env.lasot_lmdb_dir, split='train', image_loader=image_loader))
else:
datasets.append(Lasot(settings.env.lasot_dir, split='train', image_loader=image_loader))
if name == "GOT10K_vottrain":
if settings.use_lmdb:
print("Building got10k from lmdb")
datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='vottrain', image_loader=image_loader))
else:
datasets.append(Got10k(settings.env.got10k_dir, split='vottrain', image_loader=image_loader))
if name == "GOT10K_train_full":
if settings.use_lmdb:
print("Building got10k_train_full from lmdb")
datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='train_full', image_loader=image_loader))
else:
datasets.append(Got10k(settings.env.got10k_dir, split='train_full', image_loader=image_loader))
if name == "GOT10K_votval":
if settings.use_lmdb:
print("Building got10k from lmdb")
datasets.append(Got10k_lmdb(settings.env.got10k_lmdb_dir, split='votval', image_loader=image_loader))
else:
datasets.append(Got10k(settings.env.got10k_dir, split='votval', image_loader=image_loader))
if name == "GOT10K_official_val":
if settings.use_lmdb:
raise ValueError("Not implement")
else:
datasets.append(Got10k(settings.env.got10k_val_dir, split=None, image_loader=image_loader))
if name == "COCO17":
if settings.use_lmdb:
print("Building COCO2017 from lmdb")
datasets.append(MSCOCOSeq_lmdb(settings.env.coco_lmdb_dir, version="2017", image_loader=image_loader))
else:
datasets.append(MSCOCOSeq(settings.env.coco_dir, version="2017", image_loader=image_loader))
if name == "VID":
if settings.use_lmdb:
print("Building VID from lmdb")
datasets.append(ImagenetVID_lmdb(settings.env.imagenet_lmdb_dir, image_loader=image_loader))
else:
datasets.append(ImagenetVID(settings.env.imagenet_dir, image_loader=image_loader))
if name == "TRACKINGNET":
if settings.use_lmdb:
print("Building TrackingNet from lmdb")
datasets.append(TrackingNet_lmdb(settings.env.trackingnet_lmdb_dir, image_loader=image_loader))
else:
# raise ValueError("NOW WE CAN ONLY USE TRACKINGNET FROM LMDB") | datasets.append(TrackingNet(settings.env.trackingnet_dir, image_loader=image_loader)) | 2 | 2023-12-10 03:57:19+00:00 | 24k |
lumina-test/lumina | lumina/e2e_test/test_gbn.py | [
{
"identifier": "get_qp_info_list",
"path": "lumina/analyzer/main.py",
"snippet": "def get_qp_info_list(switch_msg_snapshot):\n \"\"\" Get the list of QP info from the switch message snapshot\n\n Args:\n switch_msg_snapshot (str): The path to the switch message snapshot\n\n Returns:\n ... | import argparse, os, math, glob, logging, time
import lumina.analyzer.checker.integrity_check as integrity_check
import lumina.analyzer.checker.host_check as host_check
import lumina.analyzer.checker.gbn_check as gbn_check
import lumina.analyzer.checker.read_gbn_check as read_gbn_check
import lumina.orchestrator.host as host
import lumina.orchestrator.switch as switch
from lumina.analyzer.main import get_qp_info_list
from lumina.orchestrator.main import Orchestrator
from lumina.analyzer.counter.switch_counter import SwitchCounter
from lumina.analyzer.counter.host_counter import MLNXHostCounter, IntelHostCounter
from lumina.analyzer.pcap_processor.pcap_process import get_packet_list
from lumina.analyzer.measurer.latency_measure import LatencyMeasure
from lumina.utils.config_loggers import config_stream_handler, config_file_handler
from lumina.analyzer.packet_parser.roce_packet import TRIGGER_OOS, TRIGGER_TIMEOUT | 15,816 | elif orchestrator.requester.is_intel_nic():
requester_counter = IntelHostCounter(requester_counter_start, requester_counter_finish)
else:
logging.error("Unkown NIC Vendor for rdma requester.")
requester_counter = None
if orchestrator.responder.is_mlnx_nic():
responder_counter = MLNXHostCounter(responder_counter_start, responder_counter_finish)
elif orchestrator.responder.is_intel_nic():
responder_counter = IntelHostCounter(responder_counter_start, responder_counter_finish)
else:
logging.error("Unkown NIC Vendor for rdma responder.")
responder_counter = None
qp_info_list = get_qp_info_list(switch_msg_snapshot)
packet_list = get_packet_list(pcap_filename)
packet_list.sort(key=lambda x:x.get_switch_seqnum())
result_logger.info("Packet trace sorted by switch sequence number.")
## Do integrity check to make sure there is nothing wrong with traces and counters
integrity_checker = integrity_check.IntegrityCheck(packet_list=packet_list,
switch_counter=switch_counter,
requester_ip_list=requester_ip_list,
responder_ip_list=responder_ip_list)
if integrity_checker.check():
result_logger.info("Integrity check passed")
else:
result_logger.error("Integrity check failed")
continue
## Check host counters
host_counter_checker = host_check.HostCounterCheck()
if host_counter_checker.check_no_packet_loss(requester_counter, responder_counter):
result_logger.info("Host packet discard counter check passed")
else:
result_logger.error("Host packet discard counter check failed")
continue
rdma_verb = orchestrator.traffic_conf['rdma-verb'].lower().strip()
if rdma_verb not in host.VALID_IB_VERB_LIST_LOWER:
logging.error("Invalid RDMA verb: %s" % rdma_verb)
continue
## RDMA READ
if rdma_verb == 'read':
read_gbn_checker = read_gbn_check.ReadGBNCheck(packet_list=packet_list,
qp_info_list=qp_info_list,
num_msgs_per_qp=num_msgs_per_qp,
msg_size=msg_size,
mtu=mtu)
if read_gbn_checker.check_all_qps() == True:
result_logger.info("READ Go-Back-N state machine check passed for all qps.")
else:
result_logger.error("READ Go-Back-N state machine check failed")
continue
gbn_counter_check = read_gbn_checker.check_counters(sender_counter=responder_counter,
receiver_counter=requester_counter)
if gbn_counter_check == True:
result_logger.info("READ Go-Back-N counter check passed.")
else:
result_logger.error("READ Go-Back-N counter check failed")
continue
## A mix of RDMA SEND and READ
elif rdma_verb == 'send_read':
num_qps_send, num_qps_read = [int(x) for x in orchestrator.traffic_conf['num-qps'].split(',')]
send_qp_info_list = qp_info_list[0:num_qps_send]
read_qp_info_list = qp_info_list[num_qps_send:]
send_gbn_checker = gbn_check.GBNCheck(packet_list=packet_list,
qp_info_list=send_qp_info_list,
num_data_pkts=math.ceil(msg_size/mtu) * num_msgs_per_qp)
read_gbn_checker = read_gbn_check.ReadGBNCheck(packet_list=packet_list,
qp_info_list=read_qp_info_list,
num_msgs_per_qp=num_msgs_per_qp,
msg_size=msg_size,
mtu=mtu)
if send_gbn_checker.check_all_qps() == True and read_gbn_checker.check_all_qps() == True:
result_logger.info("Go-Back-N state machine check passed for all qps.")
else:
result_logger.error("Go-Back-N state machine check failed")
continue
send_gbn_counter_check = send_gbn_checker.check_counters(sender_counter=requester_counter,
receiver_counter=responder_counter)
read_gbn_counter_check = read_gbn_checker.check_counters(sender_counter=responder_counter,
receiver_counter=requester_counter)
if send_gbn_counter_check == True and read_gbn_counter_check == True:
result_logger.info("Go-Back-N counter check passed for all qps.")
else:
result_logger.error("Go-Back-N counter check failed")
continue
else:
## Check the traces and counters against the GBN state machine
gbn_checker = gbn_check.GBNCheck(packet_list=packet_list,
qp_info_list=qp_info_list,
num_data_pkts=math.ceil(msg_size/mtu) * num_msgs_per_qp)
if gbn_checker.check_all_qps() == True:
result_logger.info("Go-Back-N state machine check passed for all qps.")
else:
result_logger.error("Go-Back-N state machine check failed")
continue
gbn_counter_check = gbn_checker.check_counters(sender_counter=requester_counter,
receiver_counter=responder_counter)
if gbn_counter_check == True:
result_logger.info("Go-Back-N counter check passed.")
else:
result_logger.error("Go-Back-N counter check failed")
continue
## Output the latency for undelivered packets
num_qps = len(qp_info_list)
for qp_index in range(num_qps):
is_read = (rdma_verb == 'read') or (rdma_verb == 'send_read' and qp_index >= num_qps_send)
|
## All logs will be logged into file LOG_FILENAME
LOG_FILENAME = "test_gbn.log"
## Results (checkers and measurements) will also be dumped into file RESULT_FILENAME
RESULT_FILENAME = "result.log"
## Max # of retries for each experiment iteration
MAX_NB_EXP_RETRIES = 3
def setup_root_logger(orchestrator):
""" Setup the root logger for the test
Args:
orchestrator (Orchestrator object): Orchestrator object that contains all the configurations
Returns:
N/A
"""
root_logger = logging.getLogger()
root_logger.handlers.clear()
config_stream_handler(root_logger)
config_file_handler(logger=root_logger,
log_file=os.path.join(orchestrator.result_path, LOG_FILENAME),
no_format=False)
def run_traffic(orchestrator):
""" Run the traffic and collect the results
Args:
orchestrator (Orchestrator object): Orchestrator object that contains all the configurations
Returns:
bool: True if the experiment is successful, False otherwise
"""
orchestrator.rm_old_files()
if orchestrator.sync_and_compile() == False:
logging.error("Failed to sync and compile the code")
sys.exit(-1)
logging.info("Sync and compile completed")
if orchestrator.generate_switch_config_file() == False:
logging.error("Failed to generate switch configuration file")
sys.exit(-1)
num_repeats = orchestrator.get_num_repeats()
for i in range(num_repeats):
logging.info("=" * 100)
nb_retry = 0
iter_result = False
while nb_retry < MAX_NB_EXP_RETRIES:
if orchestrator.run_experiment() == False:
logging.error("Iteration %d: Failed to complete experiment" % i)
logging.error("Iteration %d: Rerun experiment (retry: %d)" % i, nb_retry)
nb_retry += 1
orchestrator.clean_up()
time.sleep(5)
continue
logging.info("Iteration %d: Completed experiment" % i)
try:
orchestrator.clean_up()
orchestrator.fetch_results(i)
logging.info("Iteration %d: Fetch experiment results" % i)
orchestrator.merge_traces(i)
logging.info("Iteration %d: Merge the pcap files" % i)
except:
logging.error("Iteration %d: Result collection failed" % (i))
logging.error("Iteration %d: Rerun experiment (retry: %d)" % (i, nb_retry))
nb_retry += 1
time.sleep(5)
continue
if orchestrator.check_integrity(i) == False:
logging.error("Iteration %d: Integrity check failed" % (i))
logging.error("Iteration %d: Rerun experiment (retry: %d)" % (i, nb_retry))
nb_retry += 1
time.sleep(5)
continue
iter_result = True
break
if iter_result is False:
logging.error("Iteration %d: Still failed after %d retries" % (i, nb_retry))
return False
return True
def analyze_retrans_latency(pkt, latency_measurement, is_read, logger):
""" Analyze the retransmission latency breakdown for an undelivered packet
Args:
pkt (Packet object): The undelivered packet
latency_measurement (LatencyMeasure object): A LatencyMeasure object that can compute latency breakdown
is_read (bool): If we use RDMA READ in this experiment
logger (logging.Logger): A logger object
Returns:
N/A
"""
# All the undelivered packets should be retransmitted in our test cases
if latency_measurement.get_retransmit_pkt(pkt) == None:
logger.error("\t\t No retransmit packet found for this packet")
logger.error("\t\t It is possible that this undelivered packet is a redundant transmission")
return
retrans_latency = latency_measurement.get_retransmit_latency(pkt)
if is_read == True:
# For RDMA READ, we should always find a NACK READ request that triggers retransmission
nack = latency_measurement.get_nack(pkt)
if nack is not None:
trigger = nack.get_trigger()
if trigger == TRIGGER_OOS:
next_delivered_pkt_delay = latency_measurement.get_qp_next_delivered_pkt_latency(pkt)
nack_gen_latency = latency_measurement.get_nack_gen_latency(pkt)
nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)
logger.info("\t\t Out of sequence (OOS) triggered retransmission")
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
logger.info('\t\t Next delivered packet delay: %fus' % (next_delivered_pkt_delay * 1e6))
logger.info("\t\t NACK READ request generation latency: %fus" % (nack_gen_latency * 1e6))
logger.info('\t\t NACK READ request response latency: %fus' % (nack_resp_latency * 1e6))
elif trigger == TRIGGER_TIMEOUT:
nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)
logger.info("\t\t Timeout triggered retransmission")
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
logger.info('\t\t NACK READ request response latency: %fus' % (nack_resp_latency * 1e6))
else:
logger.error("\t\t NACK READ request should be triggered by either OOS or timeout")
else:
nack = latency_measurement.get_qp_first_nack_before_retrans(pkt)
if nack is None:
logger.error("\t\t Cannot find the NACK READ request to recover this lost packet")
return
trigger = nack.get_trigger()
if trigger == TRIGGER_OOS:
logger.info("\t\t Out of sequence (OOS) triggered retransmission")
logger.info("\t\t But the NACK READ request indicates a loss (%d) before this packet (%d)" %\
(nack.get_roce_pkt_seq(), pkt.get_roce_pkt_seq()))
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
elif trigger == TRIGGER_TIMEOUT:
logger.info("\t\t Timeout triggered retransmission")
logger.info("\t\t But the NACK READ request indicates a loss (%d) before this packet (%d)" %\
(nack.get_roce_pkt_seq(), pkt.get_roce_pkt_seq()))
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
else:
logger.error("\t\t NACK READ request should be triggered by either OOS or timeout")
else:
# For other verbs, we can only find a NACK in case of out of sequence arriving packets
if latency_measurement.get_nack(pkt) != None:
# Out of sequence/NACK triggered retransmission
next_delivered_pkt_delay = latency_measurement.get_qp_next_delivered_pkt_latency(pkt)
nack_gen_latency = latency_measurement.get_nack_gen_latency(pkt)
nack_resp_latency = latency_measurement.get_nack_resp_latency(pkt)
logger.info("\t\t Out of sequence (OOS) triggered retransmission")
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
logger.info('\t\t Next delivered packet delay: %fus' % (next_delivered_pkt_delay * 1e6))
logger.info("\t\t NACK generation latency: %fus" % (nack_gen_latency * 1e6))
logger.info('\t\t NACK response latency: %fus' % (nack_resp_latency * 1e6))
elif latency_measurement.get_qp_first_nack_before_retrans(pkt) != None:
logger.info("\t\t Out of sequence (OOS) triggered retransmission")
logger.info("\t\t But the NACK indicates a loss (%d) before this packet (%d)")
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
else:
logger.info("\t\t Timeout triggered retransmission")
logger.info("\t\t Retransmission latency: %fus" % (retrans_latency * 1e6))
def verify_results(orchestrator):
""" Verify the experiment results
Args:
orchestrator (Orchestrator object): Orchestrator object that contains all the configurations
Returns:
N/A
"""
result_dir = orchestrator.result_path
num_repeats = orchestrator.num_repeats
mtu = orchestrator.traffic_conf['mtu']
msg_size = orchestrator.traffic_conf['message-size']
num_msgs_per_qp = orchestrator.traffic_conf['num-msgs-per-qp']
aggregate_pcap_filename = orchestrator.aggregate_pcap_filename
port_map = {'requester': orchestrator.requester.conf['nic']['switch-port'],
'responder': orchestrator.responder.conf['nic']['switch-port'],
'requester-mirror': orchestrator.requester_mirror.conf['nic']['switch-port'],
'responder-mirror': orchestrator.responder_mirror.conf['nic']['switch-port']}
requester_ip_list = orchestrator.get_requester_ip_list()
responder_ip_list = orchestrator.get_responder_ip_list()
for iter in range(num_repeats):
iter = str(iter)
result_logger = logging.getLogger('Analysis iter %s' % (iter))
result_logger.handlers.clear()
config_file_handler(logger=result_logger,
log_file=os.path.join(result_dir, iter, RESULT_FILENAME),
no_format=True)
result_logger.info("=" * 100)
result_logger.info("Iteration %s" % iter)
switch_msg_snapshot = os.path.join(result_dir,
iter,
switch.SWITCH_RESULT_DIR,
switch.SWITCH_MESSAGE_SNAPSHOT)
switch_state_snapshot = os.path.join(result_dir,
iter,
switch.SWITCH_RESULT_DIR,
switch.SWITCH_STATE_SNAPSHOT)
pcap_filename = os.path.join(result_dir,
iter,
host.PCAP_RESULT_DIR,
aggregate_pcap_filename)
requester_counter_start = os.path.join(result_dir,
iter,
host.RDMA_RESULT_DIR,
host.REQ_START_COUNTER_FILE_NAME)
requester_counter_finish = os.path.join(result_dir,
iter,
host.RDMA_RESULT_DIR,
host.REQ_FINISH_COUNTER_FILE_NAME)
responder_counter_start = os.path.join(result_dir,
iter,
host.RDMA_RESULT_DIR,
host.RSP_START_COUNTER_FILE_NAME)
responder_counter_finish = os.path.join(result_dir,
iter,
host.RDMA_RESULT_DIR,
host.RSP_FINISH_COUNTER_FILE_NAME)
switch_counter = SwitchCounter(switch_state_snapshot, port_map)
if orchestrator.requester.is_mlnx_nic():
requester_counter = MLNXHostCounter(requester_counter_start, requester_counter_finish)
elif orchestrator.requester.is_intel_nic():
requester_counter = IntelHostCounter(requester_counter_start, requester_counter_finish)
else:
logging.error("Unkown NIC Vendor for rdma requester.")
requester_counter = None
if orchestrator.responder.is_mlnx_nic():
responder_counter = MLNXHostCounter(responder_counter_start, responder_counter_finish)
elif orchestrator.responder.is_intel_nic():
responder_counter = IntelHostCounter(responder_counter_start, responder_counter_finish)
else:
logging.error("Unkown NIC Vendor for rdma responder.")
responder_counter = None
qp_info_list = get_qp_info_list(switch_msg_snapshot)
packet_list = get_packet_list(pcap_filename)
packet_list.sort(key=lambda x:x.get_switch_seqnum())
result_logger.info("Packet trace sorted by switch sequence number.")
## Do integrity check to make sure there is nothing wrong with traces and counters
integrity_checker = integrity_check.IntegrityCheck(packet_list=packet_list,
switch_counter=switch_counter,
requester_ip_list=requester_ip_list,
responder_ip_list=responder_ip_list)
if integrity_checker.check():
result_logger.info("Integrity check passed")
else:
result_logger.error("Integrity check failed")
continue
## Check host counters
host_counter_checker = host_check.HostCounterCheck()
if host_counter_checker.check_no_packet_loss(requester_counter, responder_counter):
result_logger.info("Host packet discard counter check passed")
else:
result_logger.error("Host packet discard counter check failed")
continue
rdma_verb = orchestrator.traffic_conf['rdma-verb'].lower().strip()
if rdma_verb not in host.VALID_IB_VERB_LIST_LOWER:
logging.error("Invalid RDMA verb: %s" % rdma_verb)
continue
## RDMA READ
if rdma_verb == 'read':
read_gbn_checker = read_gbn_check.ReadGBNCheck(packet_list=packet_list,
qp_info_list=qp_info_list,
num_msgs_per_qp=num_msgs_per_qp,
msg_size=msg_size,
mtu=mtu)
if read_gbn_checker.check_all_qps() == True:
result_logger.info("READ Go-Back-N state machine check passed for all qps.")
else:
result_logger.error("READ Go-Back-N state machine check failed")
continue
gbn_counter_check = read_gbn_checker.check_counters(sender_counter=responder_counter,
receiver_counter=requester_counter)
if gbn_counter_check == True:
result_logger.info("READ Go-Back-N counter check passed.")
else:
result_logger.error("READ Go-Back-N counter check failed")
continue
## A mix of RDMA SEND and READ
elif rdma_verb == 'send_read':
num_qps_send, num_qps_read = [int(x) for x in orchestrator.traffic_conf['num-qps'].split(',')]
send_qp_info_list = qp_info_list[0:num_qps_send]
read_qp_info_list = qp_info_list[num_qps_send:]
send_gbn_checker = gbn_check.GBNCheck(packet_list=packet_list,
qp_info_list=send_qp_info_list,
num_data_pkts=math.ceil(msg_size/mtu) * num_msgs_per_qp)
read_gbn_checker = read_gbn_check.ReadGBNCheck(packet_list=packet_list,
qp_info_list=read_qp_info_list,
num_msgs_per_qp=num_msgs_per_qp,
msg_size=msg_size,
mtu=mtu)
if send_gbn_checker.check_all_qps() == True and read_gbn_checker.check_all_qps() == True:
result_logger.info("Go-Back-N state machine check passed for all qps.")
else:
result_logger.error("Go-Back-N state machine check failed")
continue
send_gbn_counter_check = send_gbn_checker.check_counters(sender_counter=requester_counter,
receiver_counter=responder_counter)
read_gbn_counter_check = read_gbn_checker.check_counters(sender_counter=responder_counter,
receiver_counter=requester_counter)
if send_gbn_counter_check == True and read_gbn_counter_check == True:
result_logger.info("Go-Back-N counter check passed for all qps.")
else:
result_logger.error("Go-Back-N counter check failed")
continue
else:
## Check the traces and counters against the GBN state machine
gbn_checker = gbn_check.GBNCheck(packet_list=packet_list,
qp_info_list=qp_info_list,
num_data_pkts=math.ceil(msg_size/mtu) * num_msgs_per_qp)
if gbn_checker.check_all_qps() == True:
result_logger.info("Go-Back-N state machine check passed for all qps.")
else:
result_logger.error("Go-Back-N state machine check failed")
continue
gbn_counter_check = gbn_checker.check_counters(sender_counter=requester_counter,
receiver_counter=responder_counter)
if gbn_counter_check == True:
result_logger.info("Go-Back-N counter check passed.")
else:
result_logger.error("Go-Back-N counter check failed")
continue
## Output the latency for undelivered packets
num_qps = len(qp_info_list)
for qp_index in range(num_qps):
is_read = (rdma_verb == 'read') or (rdma_verb == 'send_read' and qp_index >= num_qps_send) | latency_measurement = LatencyMeasure(packet_list=packet_list, | 6 | 2023-12-09 08:21:14+00:00 | 24k |
ebb-earl-co/tidal-wave | tidal_wave/main.py | [
{
"identifier": "login",
"path": "tidal_wave/login.py",
"snippet": "def login(\n audio_format: AudioFormat,\n) -> Tuple[Optional[requests.Session], Optional[AudioFormat]]:\n \"\"\"Given a selected audio_format, either log in \"automatically\"\n via the Fire TV OAuth 2.0 flow, or ask for an Andr... | from contextlib import closing
from pathlib import Path
from typing import Optional, Union
from .login import login, AudioFormat, LogLevel
from .album import Album
from .artist import Artist
from .mix import Mix
from .playlist import Playlist
from .track import Track
from .video import Video
from .models import (
match_tidal_url,
TidalAlbum,
TidalArtist,
TidalMix,
TidalPlaylist,
TidalTrack,
TidalVideo,
)
from platformdirs import user_music_path
from typing_extensions import Annotated
import logging
import typer | 17,350 |
app = typer.Typer()
@app.command()
def main(
tidal_url: Annotated[
str,
typer.Argument(
help="The Tidal album or artist or mix or playlist or track or video to download"
),
],
audio_format: Annotated[
AudioFormat, typer.Option(case_sensitive=False)
] = AudioFormat.lossless.value,
output_directory: Annotated[
Path,
typer.Argument(
help="The parent directory under which directory(ies) of files will be written"
),
] = user_music_path(),
loglevel: Annotated[
LogLevel, typer.Option(case_sensitive=False)
] = LogLevel.info.value,
include_eps_singles: Annotated[
bool,
typer.Option(
"--include-eps-singles",
help="No-op unless passing TIDAL artist. Whether to include artist's EPs and singles with albums",
),
] = False,
):
logging.basicConfig(
format="%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s",
datefmt="%Y-%m-%d:%H:%M:%S",
level=logging.getLevelName(loglevel.value),
)
logger = logging.getLogger(__name__)
tidal_resource: Optional[
Union[TidalAlbum, TidalMix, TidalPlaylist, TidalTrack, TidalVideo]
] = match_tidal_url(tidal_url)
if tidal_resource is None:
logger.critical(
f"Cannot parse '{tidal_url}' as a TIDAL album, artist, mix, playlist, track, or video URL"
)
raise typer.Exit(code=1)
s, audio_format = login(audio_format=audio_format)
if s is None:
raise typer.Exit(code=1)
with closing(s) as session:
if isinstance(tidal_resource, TidalTrack):
track = Track(track_id=tidal_resource.tidal_id)
track.get(
session=session, audio_format=audio_format, out_dir=output_directory
)
if loglevel == LogLevel.debug:
track.dump()
raise typer.Exit(code=0)
elif isinstance(tidal_resource, TidalAlbum):
album = Album(album_id=tidal_resource.tidal_id)
album.get(
session=session, audio_format=audio_format, out_dir=output_directory
)
if loglevel == LogLevel.debug:
album.dump()
raise typer.Exit(code=0)
elif isinstance(tidal_resource, TidalArtist):
|
app = typer.Typer()
@app.command()
def main(
tidal_url: Annotated[
str,
typer.Argument(
help="The Tidal album or artist or mix or playlist or track or video to download"
),
],
audio_format: Annotated[
AudioFormat, typer.Option(case_sensitive=False)
] = AudioFormat.lossless.value,
output_directory: Annotated[
Path,
typer.Argument(
help="The parent directory under which directory(ies) of files will be written"
),
] = user_music_path(),
loglevel: Annotated[
LogLevel, typer.Option(case_sensitive=False)
] = LogLevel.info.value,
include_eps_singles: Annotated[
bool,
typer.Option(
"--include-eps-singles",
help="No-op unless passing TIDAL artist. Whether to include artist's EPs and singles with albums",
),
] = False,
):
logging.basicConfig(
format="%(asctime)s,%(msecs)03d %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s",
datefmt="%Y-%m-%d:%H:%M:%S",
level=logging.getLevelName(loglevel.value),
)
logger = logging.getLogger(__name__)
tidal_resource: Optional[
Union[TidalAlbum, TidalMix, TidalPlaylist, TidalTrack, TidalVideo]
] = match_tidal_url(tidal_url)
if tidal_resource is None:
logger.critical(
f"Cannot parse '{tidal_url}' as a TIDAL album, artist, mix, playlist, track, or video URL"
)
raise typer.Exit(code=1)
s, audio_format = login(audio_format=audio_format)
if s is None:
raise typer.Exit(code=1)
with closing(s) as session:
if isinstance(tidal_resource, TidalTrack):
track = Track(track_id=tidal_resource.tidal_id)
track.get(
session=session, audio_format=audio_format, out_dir=output_directory
)
if loglevel == LogLevel.debug:
track.dump()
raise typer.Exit(code=0)
elif isinstance(tidal_resource, TidalAlbum):
album = Album(album_id=tidal_resource.tidal_id)
album.get(
session=session, audio_format=audio_format, out_dir=output_directory
)
if loglevel == LogLevel.debug:
album.dump()
raise typer.Exit(code=0)
elif isinstance(tidal_resource, TidalArtist): | artist = Artist(artist_id=tidal_resource.tidal_id) | 4 | 2023-12-12 21:50:25+00:00 | 24k |
ZS-YANG/FemtoDet-v3 | mmdet/models/utils/misc.py | [
{
"identifier": "SampleList",
"path": "mmdet/structures/det_data_sample.py",
"snippet": "class DetDataSample(BaseDataElement):\n def proposals(self) -> InstanceData:\n def proposals(self, value: InstanceData):\n def proposals(self):\n def gt_instances(self) -> InstanceData:\n def gt_insta... | from functools import partial
from typing import List, Optional, Sequence, Tuple, Union
from mmengine.structures import InstanceData
from mmengine.utils import digit_version
from six.moves import map, zip
from torch import Tensor
from torch.autograd import Function
from torch.nn import functional as F
from mmdet.structures import SampleList
from mmdet.structures.bbox import BaseBoxes, get_box_type, stack_boxes
from mmdet.structures.mask import BitmapMasks, PolygonMasks
from mmdet.utils import OptInstanceList
import numpy as np
import torch | 17,513 | def empty_instances(batch_img_metas: List[dict],
device: torch.device,
task_type: str,
instance_results: OptInstanceList = None,
mask_thr_binary: Union[int, float] = 0,
box_type: Union[str, type] = 'hbox',
use_box_type: bool = False,
num_classes: int = 80,
score_per_cls: bool = False) -> List[InstanceData]:
"""Handle predicted instances when RoI is empty.
Note: If ``instance_results`` is not None, it will be modified
in place internally, and then return ``instance_results``
Args:
batch_img_metas (list[dict]): List of image information.
device (torch.device): Device of tensor.
task_type (str): Expected returned task type. it currently
supports bbox and mask.
instance_results (list[:obj:`InstanceData`]): List of instance
results.
mask_thr_binary (int, float): mask binarization threshold.
Defaults to 0.
box_type (str or type): The empty box type. Defaults to `hbox`.
use_box_type (bool): Whether to warp boxes with the box type.
Defaults to False.
num_classes (int): num_classes of bbox_head. Defaults to 80.
score_per_cls (bool): Whether to generate classwise score for
the empty instance. ``score_per_cls`` will be True when the model
needs to produce raw results without nms. Defaults to False.
Returns:
list[:obj:`InstanceData`]: Detection results of each image
"""
assert task_type in ('bbox', 'mask'), 'Only support bbox and mask,' \
f' but got {task_type}'
if instance_results is not None:
assert len(instance_results) == len(batch_img_metas)
results_list = []
for img_id in range(len(batch_img_metas)):
if instance_results is not None:
results = instance_results[img_id]
assert isinstance(results, InstanceData)
else:
results = InstanceData()
if task_type == 'bbox':
_, box_type = get_box_type(box_type)
bboxes = torch.zeros(0, box_type.box_dim, device=device)
if use_box_type:
bboxes = box_type(bboxes, clone=False)
results.bboxes = bboxes
score_shape = (0, num_classes + 1) if score_per_cls else (0, )
results.scores = torch.zeros(score_shape, device=device)
results.labels = torch.zeros((0, ),
device=device,
dtype=torch.long)
else:
# TODO: Handle the case where rescale is false
img_h, img_w = batch_img_metas[img_id]['ori_shape'][:2]
# the type of `im_mask` will be torch.bool or torch.uint8,
# where uint8 if for visualization and debugging.
im_mask = torch.zeros(
0,
img_h,
img_w,
device=device,
dtype=torch.bool if mask_thr_binary >= 0 else torch.uint8)
results.masks = im_mask
results_list.append(results)
return results_list
def multi_apply(func, *args, **kwargs):
"""Apply function to a list of arguments.
Note:
This function applies the ``func`` to multiple inputs and
map the multiple outputs of the ``func`` into different
list. Each list contains the same type of outputs corresponding
to different inputs.
Args:
func (Function): A function that will be applied to a list of
arguments
Returns:
tuple(list): A tuple containing multiple list, each list contains \
a kind of returned results by the function
"""
pfunc = partial(func, **kwargs) if kwargs else func
map_results = map(pfunc, *args)
return tuple(map(list, zip(*map_results)))
def unmap(data, count, inds, fill=0):
"""Unmap a subset of item (data) back to the original set of items (of size
count)"""
if data.dim() == 1:
ret = data.new_full((count, ), fill)
ret[inds.type(torch.bool)] = data
else:
new_size = (count, ) + data.size()[1:]
ret = data.new_full(new_size, fill)
ret[inds.type(torch.bool), :] = data
return ret
def mask2ndarray(mask):
"""Convert Mask to ndarray..
Args:
mask (:obj:`BitmapMasks` or :obj:`PolygonMasks` or
torch.Tensor or np.ndarray): The mask to be converted.
Returns:
np.ndarray: Ndarray mask of shape (n, h, w) that has been converted
"""
| # Copyright (c) OpenMMLab. All rights reserved.
class SigmoidGeometricMean(Function):
"""Forward and backward function of geometric mean of two sigmoid
functions.
This implementation with analytical gradient function substitutes
the autograd function of (x.sigmoid() * y.sigmoid()).sqrt(). The
original implementation incurs none during gradient backprapagation
if both x and y are very small values.
"""
@staticmethod
def forward(ctx, x, y):
x_sigmoid = x.sigmoid()
y_sigmoid = y.sigmoid()
z = (x_sigmoid * y_sigmoid).sqrt()
ctx.save_for_backward(x_sigmoid, y_sigmoid, z)
return z
@staticmethod
def backward(ctx, grad_output):
x_sigmoid, y_sigmoid, z = ctx.saved_tensors
grad_x = grad_output * z * (1 - x_sigmoid) / 2
grad_y = grad_output * z * (1 - y_sigmoid) / 2
return grad_x, grad_y
sigmoid_geometric_mean = SigmoidGeometricMean.apply
def interpolate_as(source, target, mode='bilinear', align_corners=False):
"""Interpolate the `source` to the shape of the `target`.
The `source` must be a Tensor, but the `target` can be a Tensor or a
np.ndarray with the shape (..., target_h, target_w).
Args:
source (Tensor): A 3D/4D Tensor with the shape (N, H, W) or
(N, C, H, W).
target (Tensor | np.ndarray): The interpolation target with the shape
(..., target_h, target_w).
mode (str): Algorithm used for interpolation. The options are the
same as those in F.interpolate(). Default: ``'bilinear'``.
align_corners (bool): The same as the argument in F.interpolate().
Returns:
Tensor: The interpolated source Tensor.
"""
assert len(target.shape) >= 2
def _interpolate_as(source, target, mode='bilinear', align_corners=False):
"""Interpolate the `source` (4D) to the shape of the `target`."""
target_h, target_w = target.shape[-2:]
source_h, source_w = source.shape[-2:]
if target_h != source_h or target_w != source_w:
source = F.interpolate(
source,
size=(target_h, target_w),
mode=mode,
align_corners=align_corners)
return source
if len(source.shape) == 3:
source = source[:, None, :, :]
source = _interpolate_as(source, target, mode, align_corners)
return source[:, 0, :, :]
else:
return _interpolate_as(source, target, mode, align_corners)
def unpack_gt_instances(batch_data_samples: SampleList) -> tuple:
"""Unpack ``gt_instances``, ``gt_instances_ignore`` and ``img_metas`` based
on ``batch_data_samples``
Args:
batch_data_samples (List[:obj:`DetDataSample`]): The Data
Samples. It usually includes information such as
`gt_instance`, `gt_panoptic_seg` and `gt_sem_seg`.
Returns:
tuple:
- batch_gt_instances (list[:obj:`InstanceData`]): Batch of
gt_instance. It usually includes ``bboxes`` and ``labels``
attributes.
- batch_gt_instances_ignore (list[:obj:`InstanceData`]):
Batch of gt_instances_ignore. It includes ``bboxes`` attribute
data that is ignored during training and testing.
Defaults to None.
- batch_img_metas (list[dict]): Meta information of each image,
e.g., image size, scaling factor, etc.
"""
batch_gt_instances = []
batch_gt_instances_ignore = []
batch_img_metas = []
for data_sample in batch_data_samples:
batch_img_metas.append(data_sample.metainfo)
batch_gt_instances.append(data_sample.gt_instances)
if 'ignored_instances' in data_sample:
batch_gt_instances_ignore.append(data_sample.ignored_instances)
else:
batch_gt_instances_ignore.append(None)
return batch_gt_instances, batch_gt_instances_ignore, batch_img_metas
def empty_instances(batch_img_metas: List[dict],
device: torch.device,
task_type: str,
instance_results: OptInstanceList = None,
mask_thr_binary: Union[int, float] = 0,
box_type: Union[str, type] = 'hbox',
use_box_type: bool = False,
num_classes: int = 80,
score_per_cls: bool = False) -> List[InstanceData]:
"""Handle predicted instances when RoI is empty.
Note: If ``instance_results`` is not None, it will be modified
in place internally, and then return ``instance_results``
Args:
batch_img_metas (list[dict]): List of image information.
device (torch.device): Device of tensor.
task_type (str): Expected returned task type. it currently
supports bbox and mask.
instance_results (list[:obj:`InstanceData`]): List of instance
results.
mask_thr_binary (int, float): mask binarization threshold.
Defaults to 0.
box_type (str or type): The empty box type. Defaults to `hbox`.
use_box_type (bool): Whether to warp boxes with the box type.
Defaults to False.
num_classes (int): num_classes of bbox_head. Defaults to 80.
score_per_cls (bool): Whether to generate classwise score for
the empty instance. ``score_per_cls`` will be True when the model
needs to produce raw results without nms. Defaults to False.
Returns:
list[:obj:`InstanceData`]: Detection results of each image
"""
assert task_type in ('bbox', 'mask'), 'Only support bbox and mask,' \
f' but got {task_type}'
if instance_results is not None:
assert len(instance_results) == len(batch_img_metas)
results_list = []
for img_id in range(len(batch_img_metas)):
if instance_results is not None:
results = instance_results[img_id]
assert isinstance(results, InstanceData)
else:
results = InstanceData()
if task_type == 'bbox':
_, box_type = get_box_type(box_type)
bboxes = torch.zeros(0, box_type.box_dim, device=device)
if use_box_type:
bboxes = box_type(bboxes, clone=False)
results.bboxes = bboxes
score_shape = (0, num_classes + 1) if score_per_cls else (0, )
results.scores = torch.zeros(score_shape, device=device)
results.labels = torch.zeros((0, ),
device=device,
dtype=torch.long)
else:
# TODO: Handle the case where rescale is false
img_h, img_w = batch_img_metas[img_id]['ori_shape'][:2]
# the type of `im_mask` will be torch.bool or torch.uint8,
# where uint8 if for visualization and debugging.
im_mask = torch.zeros(
0,
img_h,
img_w,
device=device,
dtype=torch.bool if mask_thr_binary >= 0 else torch.uint8)
results.masks = im_mask
results_list.append(results)
return results_list
def multi_apply(func, *args, **kwargs):
"""Apply function to a list of arguments.
Note:
This function applies the ``func`` to multiple inputs and
map the multiple outputs of the ``func`` into different
list. Each list contains the same type of outputs corresponding
to different inputs.
Args:
func (Function): A function that will be applied to a list of
arguments
Returns:
tuple(list): A tuple containing multiple list, each list contains \
a kind of returned results by the function
"""
pfunc = partial(func, **kwargs) if kwargs else func
map_results = map(pfunc, *args)
return tuple(map(list, zip(*map_results)))
def unmap(data, count, inds, fill=0):
"""Unmap a subset of item (data) back to the original set of items (of size
count)"""
if data.dim() == 1:
ret = data.new_full((count, ), fill)
ret[inds.type(torch.bool)] = data
else:
new_size = (count, ) + data.size()[1:]
ret = data.new_full(new_size, fill)
ret[inds.type(torch.bool), :] = data
return ret
def mask2ndarray(mask):
"""Convert Mask to ndarray..
Args:
mask (:obj:`BitmapMasks` or :obj:`PolygonMasks` or
torch.Tensor or np.ndarray): The mask to be converted.
Returns:
np.ndarray: Ndarray mask of shape (n, h, w) that has been converted
""" | if isinstance(mask, (BitmapMasks, PolygonMasks)): | 5 | 2023-12-11 15:23:03+00:00 | 24k |
chinhsuanwu/ifusion | model/zero123.py | [
{
"identifier": "inject_trainable_lora_extended",
"path": "ldm/lora.py",
"snippet": "def inject_trainable_lora_extended(\n model: nn.Module,\n target_replace_module: Set[str] = UNET_EXTENDED_TARGET_REPLACE,\n r: int = 4,\n loras=None, # path to lora .pt\n eval=True,\n):\n \"\"\"\n ... | import itertools
import torch
import torch.nn as nn
from dataclasses import dataclass
from diffusers import DDIMScheduler
from einops import rearrange
from omegaconf import OmegaConf
from ldm.lora import (
inject_trainable_lora_extended,
monkeypatch_remove_lora,
save_lora_weight,
)
from ldm.models.diffusion.ddpm import LatentDiffusion
from ldm.util import load_model_from_config
from util.pose import make_T
from util.typing import *
from util.util import default | 15,836 | self.configure()
def configure(self) -> None:
print("[INFO] Loading Zero123...")
self.pretrained_config = OmegaConf.load(self.config.pretrained_config)
self.weights_dtype = torch.float32
self.model: LatentDiffusion = load_model_from_config(
self.pretrained_config,
self.config.pretrained_model_name_or_path,
device=self.device,
vram_O=self.config.vram_O,
)
for p in self.model.parameters():
p.requires_grad_(False)
self.num_train_timesteps = self.pretrained_config.model.params.timesteps
self.scheduler = DDIMScheduler(
self.num_train_timesteps,
self.pretrained_config.model.params.linear_start,
self.pretrained_config.model.params.linear_end,
beta_schedule="scaled_linear",
clip_sample=False,
set_alpha_to_one=False,
steps_offset=1,
)
self.num_train_timesteps = self.scheduler.config.num_train_timesteps
self.set_min_max_steps(
min_step_percent=self.config.min_step_percent,
max_step_percent=self.config.max_step_percent,
)
print("[INFO] Loaded Zero123")
@torch.cuda.amp.autocast(enabled=False)
def set_min_max_steps(
self, min_step_percent: float = 0.02, max_step_percent: float = 0.98
):
self.min_step = int(self.num_train_timesteps * min_step_percent)
self.max_step = int(self.num_train_timesteps * max_step_percent)
@torch.cuda.amp.autocast(enabled=False)
@torch.no_grad()
def get_image_embeds(
self, image: Float[Tensor, "B 3 256 256"]
) -> Tuple[Float[Tensor, "B 1 768"], Float[Tensor, "B 4 32 32"]]:
c_crossattn = self.model.get_learned_conditioning(image.to(self.weights_dtype))
c_concat = self.model.encode_first_stage(image.to(self.weights_dtype)).mode()
return c_crossattn, c_concat
@torch.cuda.amp.autocast(enabled=False)
def encode_image(
self, image: Float[Tensor, "B 3 256 256"]
) -> Float[Tensor, "B 4 32 32"]:
input_dtype = image.dtype
latent = self.model.get_first_stage_encoding(
self.model.encode_first_stage(image.to(self.weights_dtype))
)
return latent.to(input_dtype) # [B, 4, 32, 32] Latent space image
@torch.cuda.amp.autocast(enabled=False)
def decode_latent(
self,
latent: Float[Tensor, "B 4 H W"],
) -> Float[Tensor, "B 3 512 512"]:
input_dtype = latent.dtype
image = self.model.decode_first_stage(latent)
image = (image * 0.5 + 0.5).clamp(0, 1)
return image.to(input_dtype)
@staticmethod
@torch.no_grad()
def make_cond(cond):
"""Add zeros to the beginning of cond"""
return {k: [torch.cat([torch.zeros_like(v), v])] for k, v in cond.items()}
@torch.cuda.amp.autocast(enabled=False)
@torch.no_grad()
def clip_camera_projection(
self,
theta: Float[Tensor, "B"],
azimuth: Float[Tensor, "B"],
distance: Float[Tensor, "B"],
c_crossattn: Float[Tensor, "B 1 768"],
in_deg: bool = False,
):
T = make_T(theta, azimuth, distance, in_deg=in_deg).T[:, None, :]
clip_emb = self.model.cc_projection(torch.cat([c_crossattn, T], dim=-1))
return clip_emb
def inject_lora(
self,
ckpt_fp: str = None,
rank: int = 12,
target_replace_module: List[str] = ["CrossAttention", "GEGLU"],
eval: bool = False,
):
print(
f"[INFO] Injecting LoRA from "
+ (str(ckpt_fp) if ckpt_fp is not None else "scratch"),
)
lora_params, _ = inject_trainable_lora_extended(
self.model.model,
target_replace_module=set(target_replace_module),
r=rank,
loras=ckpt_fp,
eval=eval,
)
if not eval:
self.require_grad_params += itertools.chain(*lora_params)
return self
def save_lora(
self,
ckpt_fp: str,
target_replace_module: List[str] = ["CrossAttention", "GEGLU"],
):
|
class Zero123(nn.Module):
@dataclass
class Config:
pretrained_model_name_or_path: str = "ldm/ckpt/zero123-xl.ckpt"
pretrained_config: str = "ldm/ckpt/sd-objaverse-finetune-c_concat-256.yaml"
vram_O: bool = False
min_step_percent: float = 0.02
max_step_percent: float = 0.98
config: Config
def __init__(self, **kwargs) -> None:
super().__init__()
self.config = OmegaConf.structured(self.Config(**kwargs))
self.device = "cuda"
self.require_grad_params = []
self.configure()
def configure(self) -> None:
print("[INFO] Loading Zero123...")
self.pretrained_config = OmegaConf.load(self.config.pretrained_config)
self.weights_dtype = torch.float32
self.model: LatentDiffusion = load_model_from_config(
self.pretrained_config,
self.config.pretrained_model_name_or_path,
device=self.device,
vram_O=self.config.vram_O,
)
for p in self.model.parameters():
p.requires_grad_(False)
self.num_train_timesteps = self.pretrained_config.model.params.timesteps
self.scheduler = DDIMScheduler(
self.num_train_timesteps,
self.pretrained_config.model.params.linear_start,
self.pretrained_config.model.params.linear_end,
beta_schedule="scaled_linear",
clip_sample=False,
set_alpha_to_one=False,
steps_offset=1,
)
self.num_train_timesteps = self.scheduler.config.num_train_timesteps
self.set_min_max_steps(
min_step_percent=self.config.min_step_percent,
max_step_percent=self.config.max_step_percent,
)
print("[INFO] Loaded Zero123")
@torch.cuda.amp.autocast(enabled=False)
def set_min_max_steps(
self, min_step_percent: float = 0.02, max_step_percent: float = 0.98
):
self.min_step = int(self.num_train_timesteps * min_step_percent)
self.max_step = int(self.num_train_timesteps * max_step_percent)
@torch.cuda.amp.autocast(enabled=False)
@torch.no_grad()
def get_image_embeds(
self, image: Float[Tensor, "B 3 256 256"]
) -> Tuple[Float[Tensor, "B 1 768"], Float[Tensor, "B 4 32 32"]]:
c_crossattn = self.model.get_learned_conditioning(image.to(self.weights_dtype))
c_concat = self.model.encode_first_stage(image.to(self.weights_dtype)).mode()
return c_crossattn, c_concat
@torch.cuda.amp.autocast(enabled=False)
def encode_image(
self, image: Float[Tensor, "B 3 256 256"]
) -> Float[Tensor, "B 4 32 32"]:
input_dtype = image.dtype
latent = self.model.get_first_stage_encoding(
self.model.encode_first_stage(image.to(self.weights_dtype))
)
return latent.to(input_dtype) # [B, 4, 32, 32] Latent space image
@torch.cuda.amp.autocast(enabled=False)
def decode_latent(
self,
latent: Float[Tensor, "B 4 H W"],
) -> Float[Tensor, "B 3 512 512"]:
input_dtype = latent.dtype
image = self.model.decode_first_stage(latent)
image = (image * 0.5 + 0.5).clamp(0, 1)
return image.to(input_dtype)
@staticmethod
@torch.no_grad()
def make_cond(cond):
"""Add zeros to the beginning of cond"""
return {k: [torch.cat([torch.zeros_like(v), v])] for k, v in cond.items()}
@torch.cuda.amp.autocast(enabled=False)
@torch.no_grad()
def clip_camera_projection(
self,
theta: Float[Tensor, "B"],
azimuth: Float[Tensor, "B"],
distance: Float[Tensor, "B"],
c_crossattn: Float[Tensor, "B 1 768"],
in_deg: bool = False,
):
T = make_T(theta, azimuth, distance, in_deg=in_deg).T[:, None, :]
clip_emb = self.model.cc_projection(torch.cat([c_crossattn, T], dim=-1))
return clip_emb
def inject_lora(
self,
ckpt_fp: str = None,
rank: int = 12,
target_replace_module: List[str] = ["CrossAttention", "GEGLU"],
eval: bool = False,
):
print(
f"[INFO] Injecting LoRA from "
+ (str(ckpt_fp) if ckpt_fp is not None else "scratch"),
)
lora_params, _ = inject_trainable_lora_extended(
self.model.model,
target_replace_module=set(target_replace_module),
r=rank,
loras=ckpt_fp,
eval=eval,
)
if not eval:
self.require_grad_params += itertools.chain(*lora_params)
return self
def save_lora(
self,
ckpt_fp: str,
target_replace_module: List[str] = ["CrossAttention", "GEGLU"],
): | save_lora_weight( | 2 | 2023-12-17 12:45:38+00:00 | 24k |
penghao-wu/vstar | VisualSearch/utils/dataset.py | [
{
"identifier": "conversation",
"path": "VisualSearch/model/llava/conversation.py",
"snippet": "class SeparatorStyle(Enum):\nclass Conversation:\n SINGLE = auto()\n TWO = auto()\n MPT = auto()\n PLAIN = auto()\n LLAMA_2 = auto()\n W, H = image.size\n ... | import glob
import os
import random
import cv2
import numpy as np
import torch
import torch.nn.functional as F
from PIL import Image
from pycocotools import mask
from transformers import CLIPImageProcessor
from transformers import OwlViTProcessor
from VisualSearch.model.llava import conversation as conversation_lib
from VisualSearch.model.llava.constants import (DEFAULT_IMAGE_TOKEN, IGNORE_INDEX,
IMAGE_TOKEN_INDEX)
from VisualSearch.model.llava.mm_utils import tokenizer_image_token
from VisualSearch.utils.data_processing import get_mask_from_json
from VisualSearch.utils.refer import REFER
from VisualSearch.utils.refer_seg_dataset import ReferSegDataset
from VisualSearch.utils.general_segdet_dataset import SegDetDataset
from VisualSearch.utils.mixed_grounding_dataset import MixedGroundingDataset
from VisualSearch.utils.vqa_dataset import VQADataset
from VisualSearch.utils.utils import (DEFAULT_IM_END_TOKEN, DEFAULT_IM_START_TOKEN,
DEFAULT_IMAGE_TOKEN)
from VisualSearch.utils.utils import box_xyxy_to_cxcywh, expand2square | 16,059 | self,
base_dir,
tokenizer,
vision_tower,
samples_per_epoch=500 * 8 * 2 * 10,
precision: str = "fp32",
num_classes_per_sample: int = 3,
exclude_val=False,
dataset="general_segdet||refer_seg||vqa||reason_seg",
sample_rate=[9, 3, 3, 1],
general_segdet_data="objects365||cocostuff||paco_lvis",
general_segdet_sample_rate=[2,1,1],
refer_seg_data="refclef||refcoco||refcoco+||refcocog",
vqa_data="possible_locations_conv_86k||llava_instruct_80k",
vqa_sample_rate=[2,1],
):
self.exclude_val = exclude_val
self.dataset = dataset
self.samples_per_epoch = samples_per_epoch
self.num_classes_per_sample = num_classes_per_sample
sample_rate = np.array(sample_rate)
self.sample_rate = sample_rate / sample_rate.sum()
self.base_dir = base_dir
self.tokenizer = tokenizer
self.precision = precision
self.datasets = dataset.split("||")
self.all_datasets = []
for dataset in self.datasets:
if dataset == "general_segdet":
self.all_datasets.append(
SegDetDataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
general_segdet_data,
general_segdet_sample_rate,
)
)
elif dataset == "refer_seg":
self.all_datasets.append(
ReferSegDataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
refer_seg_data,
)
)
elif dataset == "vqa":
self.all_datasets.append(
VQADataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
vqa_data,
vqa_sample_rate,
)
)
elif dataset == "mixed_grounding":
self.all_datasets.append(
MixedGroundingDataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
)
)
def __len__(self):
return self.samples_per_epoch
def __getitem__(self, idx):
ind = np.random.choice(list(range(len(self.datasets))), p=self.sample_rate)
data = self.all_datasets[ind]
inference = False
return *data[0], inference
class ValDataset(torch.utils.data.Dataset):
pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)
pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)
img_size = 1024
ignore_label = 255
def __init__(
self,
base_dir,
tokenizer,
vision_tower,
val_dataset,
):
self.base_dir = base_dir
splits = val_dataset.split("|")
if len(splits) == 2:
ds, split = splits
images = glob.glob(
os.path.join(self.base_dir, "reason_seg", ds, split, "*.jpg")
)
self.images = images
self.data_type = "reason_seg"
elif len(splits) == 3:
self.base_dir = os.path.join(self.base_dir, 'refer_seg')
ds, splitBy, split = splits
| cv2.setNumThreads(1)
def collate_fn(
batch, tokenizer=None, conv_type="llava_v1", use_mm_start_end=True, local_rank=-1
):
image_path_list = []
images_list = []
images_clip_list = []
conversation_list = []
masks_list = []
label_list = []
bboxes_labels_list = []
bboxes_valid_list = []
masks_valid_list = []
resize_list = []
questions_list = []
sampled_classes_list = []
offset_list = [0]
cnt = 0
inferences = []
for (
image_path,
images,
images_clip,
conversations,
masks,
label,
bboxes_labels,
bboxes_valid,
masks_valid,
resize,
questions,
sampled_classes,
inference,
) in batch:
image_path_list.append(image_path)
images_list.append(images)
images_clip_list.append(images_clip)
conversation_list.extend(conversations)
label_list.append(label)
masks_list.append(masks.float())
bboxes_labels_list.extend(bboxes_labels)
bboxes_valid_list.extend(bboxes_valid)
masks_valid_list.append(torch.tensor(masks_valid))
resize_list.append(resize)
questions_list.append(questions)
sampled_classes_list.append(sampled_classes)
cnt += len(conversations)
offset_list.append(cnt)
inferences.append(inference)
if use_mm_start_end:
# replace <image> token
for i in range(len(conversation_list)):
replace_token = DEFAULT_IMAGE_TOKEN
replace_token = (
DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN
)
conversation_list[i] = conversation_list[i].replace(
DEFAULT_IMAGE_TOKEN, replace_token
)
input_ids = [
tokenizer_image_token(prompt, tokenizer, return_tensors="pt")
for prompt in conversation_list
]
input_ids = torch.nn.utils.rnn.pad_sequence(
input_ids, batch_first=True, padding_value=tokenizer.pad_token_id
)
attention_masks = input_ids.ne(tokenizer.pad_token_id)
for i in range(len(bboxes_valid_list)):
bboxes_valid = bboxes_valid_list[i]
attention_mask = attention_masks[i]
if not bboxes_valid:
attention_mask = attention_mask & input_ids[i].ne(tokenizer("[LOC]", add_special_tokens=False).input_ids[0])
attention_masks[i] = attention_mask
conv = conversation_lib.default_conversation.copy()
targets = input_ids.clone()
if conv_type == "llava_v1":
sep = conv.sep + conv.roles[1] + ": "
else:
sep = "[/INST] "
for conversation, target in zip(conversation_list, targets):
total_len = int(target.ne(tokenizer.pad_token_id).sum())
rounds = conversation.split(conv.sep2)
cur_len = 1
target[:cur_len] = IGNORE_INDEX
for i, rou in enumerate(rounds):
if rou == "":
break
parts = rou.split(sep)
# if len(parts) != 2:
# break
assert len(parts) == 2, (len(parts), rou)
parts[0] += sep
if DEFAULT_IMAGE_TOKEN in conversation:
round_len = len(tokenizer_image_token(rou, tokenizer))
instruction_len = len(tokenizer_image_token(parts[0], tokenizer)) - 2
else:
round_len = len(tokenizer(rou).input_ids)
instruction_len = len(tokenizer(parts[0]).input_ids) - 2
target[cur_len : cur_len + instruction_len] = IGNORE_INDEX
cur_len += round_len
target[cur_len:] = IGNORE_INDEX
if False:
z = target.clone()
z = torch.where(z == IGNORE_INDEX, tokenizer.unk_token_id, z)
if local_rank == 0:
print(
"conversation: ",
conversation,
"tokenizer.decode(z): ",
tokenizer.decode(z),
)
if cur_len < tokenizer.model_max_length:
assert cur_len == total_len
if inferences[0] == False:
truncate_len = tokenizer.model_max_length - 255
if input_ids.shape[1] > truncate_len:
input_ids = input_ids[:, :truncate_len]
targets = targets[:, :truncate_len]
attention_masks = attention_masks[:, :truncate_len]
return {
"image_paths": image_path_list,
"images": torch.stack(images_list, dim=0),
"images_clip": torch.stack(images_clip_list, dim=0),
"input_ids": input_ids,
"labels": targets,
"bboxes_labels_list": bboxes_labels_list,
"bboxes_valid_list": torch.tensor(bboxes_valid_list),
"masks_valid_list": masks_valid_list,
"attention_masks": attention_masks,
"masks_list": masks_list,
"label_list": label_list,
"resize_list": resize_list,
"offset": torch.LongTensor(offset_list),
"questions_list": questions_list,
"sampled_classes_list": sampled_classes_list,
"inference": inferences[0],
"conversation_list": conversation_list,
}
class HybridDataset(torch.utils.data.Dataset):
pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)
pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)
img_size = 1024
ignore_label = 255
def __init__(
self,
base_dir,
tokenizer,
vision_tower,
samples_per_epoch=500 * 8 * 2 * 10,
precision: str = "fp32",
num_classes_per_sample: int = 3,
exclude_val=False,
dataset="general_segdet||refer_seg||vqa||reason_seg",
sample_rate=[9, 3, 3, 1],
general_segdet_data="objects365||cocostuff||paco_lvis",
general_segdet_sample_rate=[2,1,1],
refer_seg_data="refclef||refcoco||refcoco+||refcocog",
vqa_data="possible_locations_conv_86k||llava_instruct_80k",
vqa_sample_rate=[2,1],
):
self.exclude_val = exclude_val
self.dataset = dataset
self.samples_per_epoch = samples_per_epoch
self.num_classes_per_sample = num_classes_per_sample
sample_rate = np.array(sample_rate)
self.sample_rate = sample_rate / sample_rate.sum()
self.base_dir = base_dir
self.tokenizer = tokenizer
self.precision = precision
self.datasets = dataset.split("||")
self.all_datasets = []
for dataset in self.datasets:
if dataset == "general_segdet":
self.all_datasets.append(
SegDetDataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
general_segdet_data,
general_segdet_sample_rate,
)
)
elif dataset == "refer_seg":
self.all_datasets.append(
ReferSegDataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
refer_seg_data,
)
)
elif dataset == "vqa":
self.all_datasets.append(
VQADataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
vqa_data,
vqa_sample_rate,
)
)
elif dataset == "mixed_grounding":
self.all_datasets.append(
MixedGroundingDataset(
base_dir,
tokenizer,
vision_tower,
samples_per_epoch,
precision,
num_classes_per_sample,
exclude_val,
)
)
def __len__(self):
return self.samples_per_epoch
def __getitem__(self, idx):
ind = np.random.choice(list(range(len(self.datasets))), p=self.sample_rate)
data = self.all_datasets[ind]
inference = False
return *data[0], inference
class ValDataset(torch.utils.data.Dataset):
pixel_mean = torch.Tensor([123.675, 116.28, 103.53]).view(-1, 1, 1)
pixel_std = torch.Tensor([58.395, 57.12, 57.375]).view(-1, 1, 1)
img_size = 1024
ignore_label = 255
def __init__(
self,
base_dir,
tokenizer,
vision_tower,
val_dataset,
):
self.base_dir = base_dir
splits = val_dataset.split("|")
if len(splits) == 2:
ds, split = splits
images = glob.glob(
os.path.join(self.base_dir, "reason_seg", ds, split, "*.jpg")
)
self.images = images
self.data_type = "reason_seg"
elif len(splits) == 3:
self.base_dir = os.path.join(self.base_dir, 'refer_seg')
ds, splitBy, split = splits | refer_api = REFER(self.base_dir, ds, splitBy) | 6 | 2023-12-15 14:58:24+00:00 | 24k |
sinoyou/nelf-pro | nerfstudio/viewer/server/viewer_utils.py | [
{
"identifier": "Cameras",
"path": "nerfstudio/cameras/cameras.py",
"snippet": "class Cameras(TensorDataclass):\n \"\"\"Dataparser outputs for the image dataset and the ray generator.\n\n Note: currently only supports cameras with the same principal points and types. The reason we type\n the fo... | import base64
import enum
import os
import sys
import threading
import time
import warnings
import cv2
import numpy as np
import torch
from pathlib import Path
from typing import Any, Dict, Optional, Tuple
from cryptography.utils import CryptographyDeprecationWarning
from rich.console import Console
from nerfstudio.cameras.cameras import Cameras
from nerfstudio.cameras.rays import RayBundle
from nerfstudio.configs import base_config as cfg
from nerfstudio.data.datasets.base_dataset import InputDataset
from nerfstudio.models.base_model import Model
from nerfstudio.utils import colormaps, profiler, writer
from nerfstudio.utils.decorators import check_main_thread, decorate_all
from nerfstudio.utils.images import BasicImages
from nerfstudio.utils.io import load_from_json, write_to_json
from nerfstudio.utils.writer import GLOBAL_BUFFER, EventName, TimeWriter
from nerfstudio.viewer.server.subprocess import run_viewer_bridge_server_as_subprocess
from nerfstudio.viewer.server.utils import get_intrinsics_matrix_and_camera_to_world_h
from nerfstudio.viewer.server.visualizer import Viewer | 21,585 |
if self.prev_camera_matrix is not None and np.allclose(camera_object["matrix"], self.prev_camera_matrix):
self.camera_moving = False
else:
self.prev_camera_matrix = camera_object["matrix"]
self.camera_moving = True
output_type = self.vis["renderingState/output_choice"].read()
if output_type is None:
output_type = OutputTypes.INIT
if self.prev_output_type != output_type:
self.camera_moving = True
colormap_type = self.vis["renderingState/colormap_choice"].read()
if colormap_type is None:
colormap_type = ColormapTypes.INIT
if self.prev_colormap_type != colormap_type:
self.camera_moving = True
return camera_object
def _apply_colormap(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):
"""Determines which colormap to use based on set colormap type
Args:
outputs: the output tensors for which to apply colormaps on
colors: is only set if colormap is for semantics. Defaults to None.
eps: epsilon to handle floating point comparisons
"""
if self.output_list:
reformatted_output = self._process_invalid_output(self.prev_output_type)
# default for rgb images
if self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].shape[-1] == 3:
return outputs[reformatted_output]
# rendering depth outputs
if self.prev_colormap_type == ColormapTypes.DEPTH or (
self.prev_colormap_type == ColormapTypes.DEFAULT
and outputs[reformatted_output].dtype == torch.float
and (torch.max(outputs[reformatted_output]) - 1.0) > eps # handle floating point arithmetic
):
accumulation_str = (
OutputTypes.ACCUMULATION
if OutputTypes.ACCUMULATION in self.output_list
else OutputTypes.ACCUMULATION_FINE
)
return colormaps.apply_depth_colormap(outputs[reformatted_output], accumulation=outputs[accumulation_str])
# rendering accumulation outputs
if self.prev_colormap_type == ColormapTypes.TURBO or (
self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.float
):
return colormaps.apply_colormap(outputs[reformatted_output])
# rendering semantic outputs
if self.prev_colormap_type == ColormapTypes.SEMANTIC or (
self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.int
):
logits = outputs[reformatted_output]
labels = torch.argmax(torch.nn.functional.softmax(logits, dim=-1), dim=-1) # type: ignore
assert colors is not None
return colors[labels]
# rendering boolean outputs
if self.prev_colormap_type == ColormapTypes.BOOLEAN or (
self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.bool
):
return colormaps.apply_boolean_colormap(outputs[reformatted_output])
raise NotImplementedError
def _send_output_to_viewer(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):
"""Chooses the correct output and sends it to the viewer
Args:
outputs: the dictionary of outputs to choose from, from the graph
colors: is only set if colormap is for semantics. Defaults to None.
eps: epsilon to handle floating point comparisons
"""
if self.output_list is None:
self.output_list = list(outputs.keys())
viewer_output_list = list(np.copy(self.output_list))
# remapping rgb_fine -> rgb for all cases just so that we dont have 2 of them in the options
if OutputTypes.RGB_FINE in self.output_list:
viewer_output_list.remove(OutputTypes.RGB_FINE)
viewer_output_list.insert(0, OutputTypes.RGB)
self.vis["renderingState/output_options"].write(viewer_output_list)
reformatted_output = self._process_invalid_output(self.prev_output_type)
# re-register colormaps and send to viewer
if self.output_type_changed or self.prev_colormap_type == ColormapTypes.INIT:
self.prev_colormap_type = ColormapTypes.DEFAULT
colormap_options = [ColormapTypes.DEFAULT]
if (
outputs[reformatted_output].shape[-1] != 3
and outputs[reformatted_output].dtype == torch.float
and (torch.max(outputs[reformatted_output]) - 1.0) <= eps # handle floating point arithmetic
):
# accumulation can also include depth
colormap_options.extend(["depth"])
self.output_type_changed = False
self.vis["renderingState/colormap_choice"].write(self.prev_colormap_type)
self.vis["renderingState/colormap_options"].write(colormap_options)
selected_output = (self._apply_colormap(outputs, colors) * 255).type(torch.uint8)
image = selected_output[..., [2, 1, 0]].cpu().numpy()
data = cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, 75])[1].tobytes()
data = str("data:image/jpeg;base64," + base64.b64encode(data).decode("ascii"))
self.vis["render_img"].write(data)
def _update_viewer_stats(self, render_time: float, num_rays: int, image_height: int, image_width: int) -> None:
"""Function that calculates and populates all the rendering statistics accordingly
Args:
render_time: total time spent rendering current view
num_rays: number of rays rendered
image_height: resolution of the current view
image_width: resolution of the current view
"""
| # Copyright 2022 The Nerfstudio Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Code to interface with the `vis/` (the JS viewer).
"""
from __future__ import annotations
warnings.filterwarnings("ignore", category=CryptographyDeprecationWarning)
CONSOLE = Console(width=120)
def get_viewer_version() -> str:
"""Get the version of the viewer."""
json_filename = os.path.join(os.path.dirname(__file__), "../app/package.json")
version = load_from_json(Path(json_filename))["version"]
return version
@check_main_thread
def setup_viewer(config: cfg.ViewerConfig, log_filename: Path):
"""Sets up the viewer if enabled
Args:
config: the configuration to instantiate viewer
"""
viewer_state = ViewerState(config, log_filename=log_filename)
banner_messages = [f"Viewer at: {viewer_state.viewer_url}"]
return viewer_state, banner_messages
class OutputTypes(str, enum.Enum):
"""Noncomprehsnive list of output render types"""
INIT = "init"
RGB = "rgb"
RGB_FINE = "rgb_fine"
ACCUMULATION = "accumulation"
ACCUMULATION_FINE = "accumulation_fine"
class ColormapTypes(str, enum.Enum):
"""Noncomprehsnive list of colormap render types"""
INIT = "init"
DEFAULT = "default"
TURBO = "turbo"
DEPTH = "depth"
SEMANTIC = "semantic"
BOOLEAN = "boolean"
class IOChangeException(Exception):
"""Basic camera exception to interrupt viewer"""
class SetTrace:
"""Basic trace function"""
def __init__(self, func):
self.func = func
def __enter__(self):
sys.settrace(self.func)
return self
def __exit__(self, ext_type, exc_value, traceback):
sys.settrace(None)
class RenderThread(threading.Thread):
"""Thread that does all the rendering calls while listening for interrupts
Args:
state: current viewer state object
graph: current checkpoint of model
camera_ray_bundle: input rays to pass through the graph to render out
"""
def __init__(self, state: "ViewerState", graph: Model, camera_ray_bundle: RayBundle):
threading.Thread.__init__(self)
self.state = state
self.graph = graph
self.camera_ray_bundle = camera_ray_bundle
self.exc = None
self.vis_outputs = None
def run(self):
"""run function that renders out images given the current graph and ray bundles.
Interlaced with a trace function that checks to see if any I/O changes were registered.
Exits and continues program if IOChangeException thrown.
"""
outputs = None
try:
with SetTrace(self.state.check_interrupt):
with torch.no_grad():
outputs = self.graph.get_outputs_for_camera_ray_bundle(self.camera_ray_bundle)
except Exception as e: # pylint: disable=broad-except
self.exc = e
if outputs:
self.vis_outputs = outputs
self.state.check_done_render = True
self.state.check_interrupt_vis = False
def join(self, timeout=None):
threading.Thread.join(self)
if self.exc:
raise self.exc
class CheckThread(threading.Thread):
"""Thread the constantly checks for io changes and sets a flag indicating interrupt
Args:
state: current viewer state object
"""
def __init__(self, state):
threading.Thread.__init__(self)
self.state = state
def run(self):
"""Run function that checks to see if any of the existing state has changed
(e.g. camera pose/output type/resolutions).
Sets the viewer state flag to true to signal
to render thread that an interrupt was registered.
"""
self.state.check_done_render = False
while not self.state.check_done_render:
# check camera
data = self.state.vis["renderingState/camera"].read()
if data is not None:
camera_object = data["object"]
if self.state.prev_camera_matrix is None or (
not np.allclose(camera_object["matrix"], self.state.prev_camera_matrix)
and not self.state.prev_moving
):
self.state.check_interrupt_vis = True
self.state.prev_moving = True
return
self.state.prev_moving = False
# check output type
output_type = self.state.vis["renderingState/output_choice"].read()
if output_type is None:
output_type = OutputTypes.INIT
if self.state.prev_output_type != output_type:
self.state.check_interrupt_vis = True
return
# check colormap type
colormap_type = self.state.vis["renderingState/colormap_choice"].read()
if colormap_type is None:
colormap_type = ColormapTypes.INIT
if self.state.prev_colormap_type != colormap_type:
self.state.check_interrupt_vis = True
return
# check max render
max_resolution = self.state.vis["renderingState/maxResolution"].read()
if max_resolution is not None:
if self.state.max_resolution != max_resolution:
self.state.check_interrupt_vis = True
return
@decorate_all([check_main_thread])
class ViewerState:
"""Class to hold state for viewer variables
Args:
config: viewer setup configuration
"""
def __init__(self, config: cfg.ViewerConfig, log_filename: Path):
self.config = config
self.vis = None
self.viewer_url = None
self.log_filename = log_filename
if self.config.launch_bridge_server:
# start the viewer bridge server
assert self.config.websocket_port is not None
self.log_filename.parent.mkdir(exist_ok=True)
zmq_port = run_viewer_bridge_server_as_subprocess(
self.config.websocket_port,
zmq_port=self.config.zmq_port,
ip_address=self.config.ip_address,
log_filename=str(self.log_filename),
)
# TODO(ethan): log the output of the viewer bridge server in a file where the training logs go
CONSOLE.line()
version = get_viewer_version()
websocket_url = f"ws://localhost:{self.config.websocket_port}"
self.viewer_url = f"https://viewer.nerf.studio/versions/{version}/?websocket_url={websocket_url}"
CONSOLE.rule(characters="=")
CONSOLE.print(f"[Public] Open the viewer at {self.viewer_url}")
CONSOLE.rule(characters="=")
CONSOLE.line()
self.vis = Viewer(zmq_port=zmq_port, ip_address=self.config.ip_address)
else:
assert self.config.zmq_port is not None
self.vis = Viewer(zmq_port=self.config.zmq_port, ip_address=self.config.ip_address)
# viewer specific variables
self.prev_camera_matrix = None
self.prev_output_type = OutputTypes.INIT
self.prev_colormap_type = ColormapTypes.INIT
self.prev_moving = False
self.output_type_changed = True
self.max_resolution = 1000
self.check_interrupt_vis = False
self.check_done_render = True
self.step = 0
self.static_fps = 1
self.moving_fps = 24
self.camera_moving = False
self.prev_camera_timestamp = 0
self.probe_config = None
self.output_list = None
def _pick_drawn_image_idxs(self, total_num: int) -> list[int]:
"""Determine indicies of images to display in viewer.
Args:
total_num: total number of training images.
Returns:
List of indices from [0, total_num-1].
"""
if self.config.max_num_display_images < 0:
num_display_images = total_num
else:
num_display_images = min(self.config.max_num_display_images, total_num)
# draw indices, roughly evenly spaced
return np.linspace(0, total_num - 1, num_display_images, dtype=np.int32).tolist()
def init_scene(self, dataset: InputDataset, start_train=True) -> None:
"""Draw some images and the scene aabb in the viewer.
Args:
dataset: dataset to render in the scene
start_train: whether to start train when viewer init;
if False, only displays dataset until resume train is toggled
"""
# set the config base dir
self.vis["renderingState/config_base_dir"].write(str(self.log_filename.parents[0]))
# clear the current scene
self.vis["sceneState/sceneBox"].delete()
self.vis["sceneState/cameras"].delete()
# draw the training cameras and images
image_indices = self._pick_drawn_image_idxs(len(dataset))
for idx in image_indices:
image = dataset[idx]["image"]
if isinstance(image, BasicImages):
bgr = image.images[0][..., [2, 1, 0]]
else:
bgr = image[..., [2, 1, 0]]
camera_json = dataset.cameras.to_json(camera_idx=idx, image=bgr, max_size=100)
self.vis[f"sceneState/cameras/{idx:06d}"].write(camera_json)
# draw the scene box (i.e., the bounding box)
json_ = dataset.scene_box.to_json()
self.vis["sceneState/sceneBox"].write(json_)
# set the initial state whether to train or not
self.vis["renderingState/isTraining"].write(start_train)
# self.vis["renderingState/render_time"].write(str(0))
self.probe_config = dataset.cameras.probe_config
# set the properties of the camera
# self.vis["renderingState/camera"].write(json_)
# set the main camera intrinsics to one from the dataset
# K = camera.get_intrinsics_matrix()
# set_persp_intrinsics_matrix(self.vis, K.double().numpy())
def _check_camera_path_payload(self, trainer, step: int):
"""Check to see if the camera path export button was pressed."""
# check if we should interrupt from a button press?
camera_path_payload = self.vis["camera_path_payload"].read()
if camera_path_payload:
# save a model checkpoint
trainer.save_checkpoint(step)
# write to json file
camera_path_filename = camera_path_payload["camera_path_filename"] + '.json'
camera_path = camera_path_payload["camera_path"]
write_to_json(Path(camera_path_filename), camera_path)
self.vis["camera_path_payload"].delete()
def update_scene(self, trainer, step: int, graph: Model, num_rays_per_batch: int) -> None:
"""updates the scene based on the graph weights
Args:
step: iteration step of training
graph: the current checkpoint of the model
"""
has_temporal_distortion = getattr(graph, "temporal_distortion", None) is not None
self.vis["model/has_temporal_distortion"].write(str(has_temporal_distortion).lower())
is_training = self.vis["renderingState/isTraining"].read()
self.step = step
self._check_camera_path_payload(trainer, step)
camera_object = self._get_camera_object()
if camera_object is None:
return
if is_training is None or is_training:
# in training mode
if self.camera_moving:
# if the camera is moving, then we pause training and update camera continuously
while self.camera_moving:
self._render_image_in_viewer(camera_object, graph, is_training)
camera_object = self._get_camera_object()
else:
# if the camera is not moving, then we approximate how many training steps need to be taken
# to render at a FPS defined by self.static_fps.
if EventName.TRAIN_RAYS_PER_SEC.value in GLOBAL_BUFFER["events"]:
train_rays_per_sec = GLOBAL_BUFFER["events"][EventName.TRAIN_RAYS_PER_SEC.value]["avg"]
target_train_util = self.vis["renderingState/targetTrainUtil"].read()
if target_train_util is None:
target_train_util = 0.9
batches_per_sec = train_rays_per_sec / num_rays_per_batch
num_steps = max(int(1 / self.static_fps * batches_per_sec), 1)
else:
num_steps = 1
if step % num_steps == 0:
self._render_image_in_viewer(camera_object, graph, is_training)
else:
# in pause training mode, enter render loop with set graph
local_step = step
run_loop = not is_training
while run_loop:
# if self._is_render_step(local_step) and step > 0:
if step > 0:
self._render_image_in_viewer(camera_object, graph, is_training)
camera_object = self._get_camera_object()
is_training = self.vis["renderingState/isTraining"].read()
self._check_camera_path_payload(trainer, step)
run_loop = not is_training
local_step += 1
def check_interrupt(self, frame, event, arg): # pylint: disable=unused-argument
"""Raises interrupt when flag has been set and not already on lowest resolution.
Used in conjunction with SetTrace.
"""
if event == "line":
if self.check_interrupt_vis and not self.camera_moving:
raise IOChangeException
return self.check_interrupt
def _get_camera_object(self):
"""Gets the camera object from the viewer and updates the movement state if it has changed."""
data = self.vis["renderingState/camera"].read()
if data is None:
return None
camera_object = data["object"]
if self.prev_camera_matrix is not None and np.allclose(camera_object["matrix"], self.prev_camera_matrix):
self.camera_moving = False
else:
self.prev_camera_matrix = camera_object["matrix"]
self.camera_moving = True
output_type = self.vis["renderingState/output_choice"].read()
if output_type is None:
output_type = OutputTypes.INIT
if self.prev_output_type != output_type:
self.camera_moving = True
colormap_type = self.vis["renderingState/colormap_choice"].read()
if colormap_type is None:
colormap_type = ColormapTypes.INIT
if self.prev_colormap_type != colormap_type:
self.camera_moving = True
return camera_object
def _apply_colormap(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):
"""Determines which colormap to use based on set colormap type
Args:
outputs: the output tensors for which to apply colormaps on
colors: is only set if colormap is for semantics. Defaults to None.
eps: epsilon to handle floating point comparisons
"""
if self.output_list:
reformatted_output = self._process_invalid_output(self.prev_output_type)
# default for rgb images
if self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].shape[-1] == 3:
return outputs[reformatted_output]
# rendering depth outputs
if self.prev_colormap_type == ColormapTypes.DEPTH or (
self.prev_colormap_type == ColormapTypes.DEFAULT
and outputs[reformatted_output].dtype == torch.float
and (torch.max(outputs[reformatted_output]) - 1.0) > eps # handle floating point arithmetic
):
accumulation_str = (
OutputTypes.ACCUMULATION
if OutputTypes.ACCUMULATION in self.output_list
else OutputTypes.ACCUMULATION_FINE
)
return colormaps.apply_depth_colormap(outputs[reformatted_output], accumulation=outputs[accumulation_str])
# rendering accumulation outputs
if self.prev_colormap_type == ColormapTypes.TURBO or (
self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.float
):
return colormaps.apply_colormap(outputs[reformatted_output])
# rendering semantic outputs
if self.prev_colormap_type == ColormapTypes.SEMANTIC or (
self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.int
):
logits = outputs[reformatted_output]
labels = torch.argmax(torch.nn.functional.softmax(logits, dim=-1), dim=-1) # type: ignore
assert colors is not None
return colors[labels]
# rendering boolean outputs
if self.prev_colormap_type == ColormapTypes.BOOLEAN or (
self.prev_colormap_type == ColormapTypes.DEFAULT and outputs[reformatted_output].dtype == torch.bool
):
return colormaps.apply_boolean_colormap(outputs[reformatted_output])
raise NotImplementedError
def _send_output_to_viewer(self, outputs: Dict[str, Any], colors: torch.Tensor = None, eps=1e-6):
"""Chooses the correct output and sends it to the viewer
Args:
outputs: the dictionary of outputs to choose from, from the graph
colors: is only set if colormap is for semantics. Defaults to None.
eps: epsilon to handle floating point comparisons
"""
if self.output_list is None:
self.output_list = list(outputs.keys())
viewer_output_list = list(np.copy(self.output_list))
# remapping rgb_fine -> rgb for all cases just so that we dont have 2 of them in the options
if OutputTypes.RGB_FINE in self.output_list:
viewer_output_list.remove(OutputTypes.RGB_FINE)
viewer_output_list.insert(0, OutputTypes.RGB)
self.vis["renderingState/output_options"].write(viewer_output_list)
reformatted_output = self._process_invalid_output(self.prev_output_type)
# re-register colormaps and send to viewer
if self.output_type_changed or self.prev_colormap_type == ColormapTypes.INIT:
self.prev_colormap_type = ColormapTypes.DEFAULT
colormap_options = [ColormapTypes.DEFAULT]
if (
outputs[reformatted_output].shape[-1] != 3
and outputs[reformatted_output].dtype == torch.float
and (torch.max(outputs[reformatted_output]) - 1.0) <= eps # handle floating point arithmetic
):
# accumulation can also include depth
colormap_options.extend(["depth"])
self.output_type_changed = False
self.vis["renderingState/colormap_choice"].write(self.prev_colormap_type)
self.vis["renderingState/colormap_options"].write(colormap_options)
selected_output = (self._apply_colormap(outputs, colors) * 255).type(torch.uint8)
image = selected_output[..., [2, 1, 0]].cpu().numpy()
data = cv2.imencode(".jpg", image, [cv2.IMWRITE_JPEG_QUALITY, 75])[1].tobytes()
data = str("data:image/jpeg;base64," + base64.b64encode(data).decode("ascii"))
self.vis["render_img"].write(data)
def _update_viewer_stats(self, render_time: float, num_rays: int, image_height: int, image_width: int) -> None:
"""Function that calculates and populates all the rendering statistics accordingly
Args:
render_time: total time spent rendering current view
num_rays: number of rays rendered
image_height: resolution of the current view
image_width: resolution of the current view
""" | writer.put_time( | 7 | 2023-12-15 20:07:22+00:00 | 24k |
amazon-science/c2f-seg | data/dataloader_transformer.py | [
{
"identifier": "FishBowl",
"path": "data/dataloader_Fishbowl.py",
"snippet": "class FishBowl(object):\n def __init__(self, config, mode, subtest=None):\n self.datatype = mode\n data_dir = config.root_path\n\n self.img_path = os.path.join(data_dir, self.datatype+\"_data\", self.d... | from data.dataloader_Fishbowl import FishBowl
from data.dataloader_MOViD_A import MOViD_A
from data.dataloader_KINS import Kins_Fusion_dataset, KINS_Aisformer_VRSP_Intersection
from data.dataloader_COCOA import COCOA_Fusion_dataset, COCOA_VRSP | 21,265 |
def load_dataset(config, args, mode):
if mode=="train":
if args.dataset=="KINS":
train_dataset = Kins_Fusion_dataset(config, mode='train')
test_dataset = Kins_Fusion_dataset(config, mode='test')
elif args.dataset=="COCOA":
train_dataset = COCOA_Fusion_dataset(config, mode='train')
test_dataset = COCOA_Fusion_dataset(config, mode='test')
elif args.dataset=="Fishbowl":
train_dataset = FishBowl(config, mode='train')
test_dataset = FishBowl(config, mode='test')
elif args.dataset=="MOViD_A":
|
def load_dataset(config, args, mode):
if mode=="train":
if args.dataset=="KINS":
train_dataset = Kins_Fusion_dataset(config, mode='train')
test_dataset = Kins_Fusion_dataset(config, mode='test')
elif args.dataset=="COCOA":
train_dataset = COCOA_Fusion_dataset(config, mode='train')
test_dataset = COCOA_Fusion_dataset(config, mode='test')
elif args.dataset=="Fishbowl":
train_dataset = FishBowl(config, mode='train')
test_dataset = FishBowl(config, mode='test')
elif args.dataset=="MOViD_A": | train_dataset = MOViD_A(config, mode='train') | 1 | 2023-12-21 04:25:47+00:00 | 24k |
alipay/PainlessInferenceAcceleration | pia/lookahead/models/qwen/modeling_qwen.py | [
{
"identifier": "LookaheadPreTrainedModel",
"path": "pia/lookahead/common/pretrained_model.py",
"snippet": "class LookaheadPreTrainedModel(PreTrainedModel):\n _batch_generation = False\n _stream_generation = False\n\n def __init__(self, config):\n super().__init__(config=config)\n\n d... | import importlib
import math
import torch
import torch.nn.functional as F
import torch.utils.checkpoint
import flash_attn
from typing import TYPE_CHECKING, Optional, Tuple, Union, List, Any, Generator
from torch.cuda.amp import autocast
from torch.nn import CrossEntropyLoss
from transformers import PreTrainedTokenizer, GenerationConfig
from transformers.generation.logits_process import LogitsProcessorList
from transformers.modeling_outputs import (
BaseModelOutputWithPast,
CausalLMOutputWithPast,
)
from pia.lookahead.common.pretrained_model import LookaheadPreTrainedModel
from transformers.utils import logging
from einops import rearrange
from torch import nn
from .configuration_qwen import QWenConfig
from .qwen_generation_utils import (
HistoryType,
make_context,
decode_tokens,
get_stop_words_ids,
StopWordsLogitsProcessor,
)
from flash_attn.layers.rotary import apply_rotary_emb_func as __apply_rotary_emb_func
from flash_attn.ops.rms_norm import rms_norm as __rms_norm
from flash_attn.flash_attn_interface import flash_attn_unpadded_func as __flash_attn_unpadded_func
from flash_attn.flash_attn_interface import flash_attn_varlen_func as __flash_attn_unpadded_func
from flash_attn.flash_attn_interface import flash_attn_unpadded_func as __flash_attn_unpadded_func
from transformers_stream_generator.main import NewGenerationMixin, StreamGenerationConfig
from einops import rearrange
from einops import rearrange | 17,805 | position_ids = position_ids[:, -1].unsqueeze(-1)
else:
position_ids = None
if inputs_embeds is not None and past_key_values is None:
model_inputs = {"inputs_embeds": inputs_embeds}
else:
model_inputs = {"input_ids": input_ids}
model_inputs.update(
{
"past_key_values": past_key_values,
"use_cache": kwargs.get("use_cache"),
"position_ids": position_ids,
"attention_mask": attention_mask,
"token_type_ids": token_type_ids,
}
)
return model_inputs
def forward(
self,
input_ids: Optional[torch.LongTensor] = None,
past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
attention_mask: Optional[torch.FloatTensor] = None,
token_type_ids: Optional[torch.LongTensor] = None,
position_ids: Optional[torch.LongTensor] = None,
head_mask: Optional[torch.FloatTensor] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.Tensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
labels: Optional[torch.LongTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[Tuple, CausalLMOutputWithPast]:
return_dict = (
return_dict if return_dict is not None else self.config.use_return_dict
)
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
lm_logits = self.lm_head(hidden_states)
loss = None
if labels is not None:
labels = labels.to(lm_logits.device)
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
loss_fct = CrossEntropyLoss()
loss = loss_fct(
shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)
)
if not return_dict:
output = (lm_logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return CausalLMOutputWithPast(
loss=loss,
logits=lm_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
@staticmethod
def _reorder_cache(
past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor
) -> Tuple[Tuple[torch.Tensor]]:
return tuple(
tuple(
past_state.index_select(0, beam_idx.to(past_state.device))
for past_state in layer_past
)
for layer_past in past_key_values
)
def chat(
self,
tokenizer: PreTrainedTokenizer,
query: str,
history: Optional[HistoryType],
system: str = "You are a helpful assistant.",
append_history: bool = True,
stream: Optional[bool] = _SENTINEL,
stop_words_ids: Optional[List[List[int]]] = None,
generation_config: Optional[GenerationConfig] = None,
**kwargs,
) -> Tuple[str, HistoryType]:
generation_config = generation_config if generation_config is not None else self.generation_config
assert stream is _SENTINEL, _ERROR_STREAM_IN_CHAT
assert generation_config.chat_format == 'chatml', _ERROR_BAD_CHAT_FORMAT
if history is None:
history = []
if stop_words_ids is None:
stop_words_ids = []
max_window_size = kwargs.get('max_window_size', None)
if max_window_size is None:
max_window_size = generation_config.max_window_size
| # Copyright (c) Alibaba Cloud.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
if TYPE_CHECKING:
pass
# from transformers.modeling_utils import PreTrainedModel
try:
except ImportError:
rearrange = None
SUPPORT_CUDA = torch.cuda.is_available()
SUPPORT_BF16 = SUPPORT_CUDA and torch.cuda.is_bf16_supported()
SUPPORT_FP16 = SUPPORT_CUDA and torch.cuda.get_device_capability(0)[0] >= 7
logger = logging.get_logger(__name__)
_CHECKPOINT_FOR_DOC = "qwen"
_CONFIG_FOR_DOC = "QWenConfig"
QWen_PRETRAINED_MODEL_ARCHIVE_LIST = ["qwen-7b"]
_ERROR_BAD_CHAT_FORMAT = """\
We detect you are probably using the pretrained model (rather than chat model) for chatting, since the chat_format in generation_config is not "chatml".
If you are directly using the model downloaded from Huggingface, please make sure you are using our "Qwen/Qwen-7B-Chat" Huggingface model (rather than "Qwen/Qwen-7B") when you call model.chat().
我们检测到您可能在使用预训练模型（而非chat模型）进行多轮chat，因为您当前在generation_config指定的chat_format，并未设置为我们在对话中所支持的"chatml"格式。
如果您在直接使用我们从Huggingface提供的模型，请确保您在调用model.chat()时，使用的是"Qwen/Qwen-7B-Chat"模型（而非"Qwen/Qwen-7B"预训练模型）。
"""
_SENTINEL = object()
_ERROR_STREAM_IN_CHAT = """\
Pass argument `stream` to model.chat() is buggy, deprecated, and marked for removal. Please use model.chat_stream(...) instead of model.chat(..., stream=True).
向model.chat()传入参数stream的用法可能存在Bug，该用法已被废弃，将在未来被移除。请使用model.chat_stream(...)代替model.chat(..., stream=True)。
"""
_ERROR_INPUT_CPU_QUERY_WITH_FLASH_ATTN_ACTIVATED = """\
We detect you have activated flash attention support, but running model computation on CPU. Please make sure that your input data has been placed on GPU. If you actually want to run CPU computation, please following the readme and set device_map="cpu" to disable flash attention when loading the model (calling AutoModelForCausalLM.from_pretrained).
检测到您的模型已激活了flash attention支持，但正在执行CPU运算任务。如使用flash attention，请您确认模型输入已经传到GPU上。如果您确认要执行CPU运算，请您在载入模型（调用AutoModelForCausalLM.from_pretrained）时，按照readme说法，指定device_map="cpu"以禁用flash attention。
"""
apply_rotary_emb_func = None
rms_norm = None
flash_attn_unpadded_func = None
def _import_flash_attn():
global apply_rotary_emb_func, rms_norm, flash_attn_unpadded_func
try:
apply_rotary_emb_func = __apply_rotary_emb_func
except ImportError:
logger.warn(
"Warning: import flash_attn rotary fail, please install FlashAttention rotary to get higher efficiency "
"https://github.com/Dao-AILab/flash-attention/tree/main/csrc/rotary"
)
try:
rms_norm = __rms_norm
except ImportError:
logger.warn(
"Warning: import flash_attn rms_norm fail, please install FlashAttention layer_norm to get higher efficiency "
"https://github.com/Dao-AILab/flash-attention/tree/main/csrc/layer_norm"
)
try:
if not hasattr(flash_attn, '__version__'):
else:
if int(flash_attn.__version__.split(".")[0]) >= 2:
else:
flash_attn_unpadded_func = __flash_attn_unpadded_func
except ImportError:
logger.warn(
"Warning: import flash_attn fail, please install FlashAttention to get higher efficiency "
"https://github.com/Dao-AILab/flash-attention"
)
class FlashSelfAttention(torch.nn.Module):
def __init__(
self,
causal=False,
softmax_scale=None,
attention_dropout=0.0,
):
super().__init__()
assert flash_attn_unpadded_func is not None, (
"Please install FlashAttention first, " "e.g., with pip install flash-attn"
)
assert (
rearrange is not None
), "Please install einops first, e.g., with pip install einops"
self.causal = causal
self.softmax_scale = softmax_scale
self.dropout_p = attention_dropout
def forward(self, q, k, v):
assert all((i.dtype in [torch.float16, torch.bfloat16] for i in (q, k, v)))
assert all((i.is_cuda for i in (q, k, v)))
batch_size, seqlen_q = q.shape[0], q.shape[1]
seqlen_k = k.shape[1]
q, k, v = [rearrange(x, "b s ... -> (b s) ...") for x in [q, k, v]]
cu_seqlens_q = torch.arange(
0,
(batch_size + 1) * seqlen_q,
step=seqlen_q,
dtype=torch.int32,
device=q.device,
)
if self.training:
assert seqlen_k == seqlen_q
is_causal = self.causal
cu_seqlens_k = cu_seqlens_q
else:
is_causal = seqlen_q == seqlen_k
cu_seqlens_k = torch.arange(
0,
(batch_size + 1) * seqlen_k,
step=seqlen_k,
dtype=torch.int32,
device=q.device,
)
self.dropout_p = 0
output = flash_attn_unpadded_func(
q,
k,
v,
cu_seqlens_q,
cu_seqlens_k,
seqlen_q,
seqlen_k,
self.dropout_p,
softmax_scale=self.softmax_scale,
causal=is_causal,
)
new_shape = (batch_size, output.shape[0] // batch_size) + output.shape[1:]
output = output.view(new_shape)
return output
class QWenAttention(nn.Module):
def __init__(self, config):
super().__init__()
self.register_buffer("masked_bias", torch.tensor(-1e4), persistent=False)
self.seq_length = config.seq_length
self.hidden_size = config.hidden_size
self.split_size = config.hidden_size
self.num_heads = config.num_attention_heads
self.head_dim = self.hidden_size // self.num_heads
# self.use_flash_attn = config.use_flash_attn
self.use_flash_attn = False
self.scale_attn_weights = True
self.projection_size = config.kv_channels * config.num_attention_heads
assert self.projection_size % config.num_attention_heads == 0
self.hidden_size_per_attention_head = (
self.projection_size // config.num_attention_heads
)
self.c_attn = nn.Linear(config.hidden_size, 3 * self.projection_size)
self.c_proj = nn.Linear(
config.hidden_size, self.projection_size, bias=not config.no_bias
)
self.is_fp32 = not (config.bf16 or config.fp16)
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
):
self.core_attention_flash = FlashSelfAttention(
causal=True, attention_dropout=config.attn_dropout_prob
)
self.bf16 = config.bf16
self.use_dynamic_ntk = config.use_dynamic_ntk
self.use_logn_attn = config.use_logn_attn
logn_list = [
math.log(i, self.seq_length) if i > self.seq_length else 1
for i in range(1, 32768)
]
self.logn_tensor = torch.tensor(logn_list)[None, :, None, None]
self.attn_dropout = nn.Dropout(config.attn_dropout_prob)
def _attn(self, query, key, value, registered_causal_mask, attention_mask=None, head_mask=None):
attn_weights = torch.matmul(query, key.transpose(-1, -2))
if self.scale_attn_weights:
attn_weights = attn_weights / torch.full(
[],
value.size(-1) ** 0.5,
dtype=attn_weights.dtype,
device=attn_weights.device,
)
query_length, key_length = query.size(-2), key.size(-2)
causal_mask = registered_causal_mask[
:, :, key_length - query_length: key_length, :key_length
]
mask_value = torch.finfo(attn_weights.dtype).min
mask_value = torch.full([], mask_value, dtype=attn_weights.dtype).to(
attn_weights.device
)
attn_weights = torch.where(
causal_mask, attn_weights.to(attn_weights.dtype), mask_value
)
attn_weights = nn.functional.softmax(attn_weights, dim=-1)
attn_weights = attn_weights.type(value.dtype)
attn_weights = self.attn_dropout(attn_weights)
if head_mask is not None:
attn_weights = attn_weights * head_mask
attn_output = torch.matmul(attn_weights, value)
attn_output = attn_output.transpose(1, 2)
return attn_output, attn_weights
def _upcast_and_reordered_attn(
self, query, key, value, registered_causal_mask, attention_mask=None, head_mask=None
):
bsz, num_heads, q_seq_len, dk = query.size()
_, _, k_seq_len, _ = key.size()
attn_weights = torch.empty(
bsz * num_heads,
q_seq_len,
k_seq_len,
dtype=torch.float32,
device=query.device,
)
scale_factor = 1.0
if self.scale_attn_weights:
scale_factor /= float(value.size(-1)) ** 0.5
with autocast(enabled=False):
q, k = query.reshape(-1, q_seq_len, dk), key.transpose(-1, -2).reshape(
-1, dk, k_seq_len
)
attn_weights = torch.baddbmm(
attn_weights, q.float(), k.float(), beta=0, alpha=scale_factor
)
attn_weights = attn_weights.reshape(bsz, num_heads, q_seq_len, k_seq_len)
query_length, key_length = query.size(-2), key.size(-2)
causal_mask = registered_causal_mask[
:, :, key_length - query_length: key_length, :key_length
]
mask_value = torch.finfo(attn_weights.dtype).min
mask_value = torch.tensor(mask_value, dtype=attn_weights.dtype).to(
attn_weights.device
)
attn_weights = torch.where(causal_mask, attn_weights, mask_value)
if attention_mask is not None:
attn_weights = attn_weights + attention_mask
attn_weights = nn.functional.softmax(attn_weights, dim=-1)
if attn_weights.dtype != torch.float32:
raise RuntimeError(
"Error with upcasting, attn_weights does not have dtype torch.float32"
)
attn_weights = attn_weights.type(value.dtype)
attn_weights = self.attn_dropout(attn_weights)
if head_mask is not None:
attn_weights = attn_weights * head_mask
attn_output = torch.matmul(attn_weights, value)
return attn_output, attn_weights
def _split_heads(self, tensor, num_heads, attn_head_size):
new_shape = tensor.size()[:-1] + (num_heads, attn_head_size)
tensor = tensor.view(new_shape)
return tensor
def _merge_heads(self, tensor, num_heads, attn_head_size):
tensor = tensor.contiguous()
new_shape = tensor.size()[:-2] + (num_heads * attn_head_size,)
return tensor.view(new_shape)
def forward(
self,
hidden_states: Optional[Tuple[torch.FloatTensor]],
rotary_pos_emb: Optional[List[torch.Tensor]] = None,
registered_causal_mask: Optional[torch.Tensor] = None,
layer_past: Optional[Tuple[torch.Tensor]] = None,
attention_mask: Optional[torch.FloatTensor] = None,
head_mask: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.Tensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
output_attentions: Optional[bool] = False,
use_cache: Optional[bool] = False,
):
mixed_x_layer = self.c_attn(hidden_states)
query, key, value = mixed_x_layer.split(self.split_size, dim=2)
query = self._split_heads(query, self.num_heads, self.head_dim)
key = self._split_heads(key, self.num_heads, self.head_dim)
value = self._split_heads(value, self.num_heads, self.head_dim)
if rotary_pos_emb is not None:
cur_len = query.shape[1]
rotary_pos_emb = [i[:, -cur_len:, :, :] for i in rotary_pos_emb]
rotary_pos_emb = (rotary_pos_emb,) * 2
q_pos_emb, k_pos_emb = rotary_pos_emb
# Slice the pos emb for current inference
query = apply_rotary_pos_emb(query, q_pos_emb)
key = apply_rotary_pos_emb(key, k_pos_emb)
if layer_past is not None:
past_key, past_value = layer_past[0], layer_past[1]
key = torch.cat((past_key, key), dim=1)
value = torch.cat((past_value, value), dim=1)
if use_cache:
present = (key, value)
else:
present = None
if self.use_logn_attn and not self.training:
if self.logn_tensor.device != query.device or self.logn_tensor.dtype != query.dtype:
self.logn_tensor = self.logn_tensor.to(query.device).type_as(query)
seq_start = key.size(1) - query.size(1)
seq_end = key.size(1)
logn_tensor = self.logn_tensor[:, seq_start:seq_end, :, :]
query = query * logn_tensor.expand_as(query)
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
and query.is_cuda
):
q, k, v = query, key, value
context_layer = self.core_attention_flash(q, k, v)
# b s h d -> b s (h d)
context_layer = context_layer.flatten(2, 3).contiguous()
else:
query = query.permute(0, 2, 1, 3)
key = key.permute(0, 2, 1, 3)
value = value.permute(0, 2, 1, 3)
if (
registered_causal_mask is None
and self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
and not query.is_cuda
):
raise Exception(_ERROR_INPUT_CPU_QUERY_WITH_FLASH_ATTN_ACTIVATED)
attn_output, attn_weight = self._attn(
query, key, value, registered_causal_mask, attention_mask, head_mask
)
context_layer = self._merge_heads(
attn_output, self.num_heads, self.head_dim
)
attn_output = self.c_proj(context_layer)
outputs = (attn_output, present)
if output_attentions:
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
):
raise ValueError("Cannot output attentions while using flash-attn")
else:
outputs += (attn_weight,)
return outputs
class QWenMLP(nn.Module):
def __init__(self, config):
super().__init__()
self.w1 = nn.Linear(
config.hidden_size, config.intermediate_size // 2, bias=not config.no_bias
)
self.w2 = nn.Linear(
config.hidden_size, config.intermediate_size // 2, bias=not config.no_bias
)
ff_dim_in = config.intermediate_size // 2
self.c_proj = nn.Linear(ff_dim_in, config.hidden_size, bias=not config.no_bias)
def forward(self, hidden_states):
a1 = self.w1(hidden_states)
a2 = self.w2(hidden_states)
intermediate_parallel = a1 * F.silu(a2)
output = self.c_proj(intermediate_parallel)
return output
class QWenBlock(nn.Module):
def __init__(self, config):
super().__init__()
hidden_size = config.hidden_size
self.bf16 = config.bf16
self.ln_1 = RMSNorm(
hidden_size,
eps=config.layer_norm_epsilon,
)
self.attn = QWenAttention(config)
self.ln_2 = RMSNorm(
hidden_size,
eps=config.layer_norm_epsilon,
)
self.mlp = QWenMLP(config)
def forward(
self,
hidden_states: Optional[Tuple[torch.FloatTensor]],
rotary_pos_emb: Optional[List[torch.Tensor]] = None,
registered_causal_mask: Optional[torch.Tensor] = None,
layer_past: Optional[Tuple[torch.Tensor]] = None,
attention_mask: Optional[torch.FloatTensor] = None,
head_mask: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.Tensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
use_cache: Optional[bool] = False,
output_attentions: Optional[bool] = False,
):
layernorm_output = self.ln_1(hidden_states)
attn_outputs = self.attn(
layernorm_output,
rotary_pos_emb,
registered_causal_mask=registered_causal_mask,
layer_past=layer_past,
attention_mask=attention_mask,
head_mask=head_mask,
use_cache=use_cache,
output_attentions=output_attentions,
)
attn_output = attn_outputs[0]
outputs = attn_outputs[1:]
residual = hidden_states
layernorm_input = attn_output + residual
layernorm_output = self.ln_2(layernorm_input)
residual = layernorm_input
mlp_output = self.mlp(layernorm_output)
hidden_states = residual + mlp_output
if use_cache:
outputs = (hidden_states,) + outputs
else:
outputs = (hidden_states,) + outputs[1:]
return outputs
class QWenPreTrainedModel(LookaheadPreTrainedModel):
config_class = QWenConfig
base_model_prefix = "transformer"
is_parallelizable = False
supports_gradient_checkpointing = True
_no_split_modules = ["QWenBlock"]
def __init__(self, *inputs, **kwargs):
super().__init__(*inputs, **kwargs)
def _init_weights(self, module):
"""Initialize the weights."""
if isinstance(module, nn.Linear):
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.Embedding):
module.weight.data.normal_(mean=0.0, std=self.config.initializer_range)
if module.padding_idx is not None:
module.weight.data[module.padding_idx].zero_()
elif isinstance(module, RMSNorm):
module.weight.data.fill_(1.0)
for name, p in module.named_parameters():
if name == "c_proj.weight":
p.data.normal_(
mean=0.0,
std=(
self.config.initializer_range
/ math.sqrt(2 * self.config.num_hidden_layers)
),
)
def _set_gradient_checkpointing(self, module, value=False):
if isinstance(module, QWenModel):
module.gradient_checkpointing = value
class QWenModel(QWenPreTrainedModel):
_keys_to_ignore_on_load_missing = ["attn.masked_bias"]
def __init__(self, config):
super().__init__(config)
self.vocab_size = config.vocab_size
self.num_hidden_layers = config.num_hidden_layers
self.embed_dim = config.hidden_size
self.gradient_checkpointing = False
self.use_dynamic_ntk = config.use_dynamic_ntk
self.seq_length = config.seq_length
self.wte = nn.Embedding(self.vocab_size, self.embed_dim)
self.drop = nn.Dropout(config.emb_dropout_prob)
if config.rotary_pct == 1.0:
self.rotary_ndims = None
else:
assert config.rotary_pct < 1
self.rotary_ndims = int(
config.kv_channels * config.rotary_pct
)
dim = (
self.rotary_ndims
if self.rotary_ndims is not None
else config.kv_channels
)
self.rotary_emb = RotaryEmbedding(dim, base=config.rotary_emb_base)
# self.use_flash_attn = config.use_flash_attn
self.use_flash_attn = False
self.is_fp32 = not (config.bf16 or config.fp16)
if (
self.use_flash_attn
and flash_attn_unpadded_func is not None
and not self.is_fp32
):
self.registered_causal_mask = None
else:
max_positions = config.max_position_embeddings
self.register_buffer(
"registered_causal_mask",
torch.tril(
torch.ones((max_positions, max_positions), dtype=torch.bool)
).view(1, 1, max_positions, max_positions),
persistent=False,
)
self.h = nn.ModuleList(
[
QWenBlock(
config
)
for i in range(config.num_hidden_layers)
]
)
self.ln_f = RMSNorm(
self.embed_dim,
eps=config.layer_norm_epsilon,
)
self.post_init()
def get_input_embeddings(self):
return self.wte
def set_input_embeddings(self, new_embeddings):
self.wte = new_embeddings
def forward(
self,
input_ids: Optional[torch.LongTensor] = None,
past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
attention_mask: Optional[torch.FloatTensor] = None,
token_type_ids: Optional[torch.LongTensor] = None,
position_ids: Optional[torch.LongTensor] = None,
head_mask: Optional[torch.FloatTensor] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.Tensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
):
output_attentions = (
output_attentions
if output_attentions is not None
else self.config.output_attentions
)
output_hidden_states = (
output_hidden_states
if output_hidden_states is not None
else self.config.output_hidden_states
)
use_cache = use_cache if use_cache is not None else self.config.use_cache
return_dict = (
return_dict if return_dict is not None else self.config.use_return_dict
)
if input_ids is not None and inputs_embeds is not None:
raise ValueError(
"You cannot specify both input_ids and inputs_embeds at the same time"
)
elif input_ids is not None:
input_shape = input_ids.size()
# input_ids = input_ids.view(-1, input_shape[-1])
batch_size, seq_length = input_ids.shape
# batch_size = input_ids.shape[0]
elif inputs_embeds is not None:
input_shape = inputs_embeds.size()[:-1]
batch_size = inputs_embeds.shape[0]
else:
raise ValueError("You have to specify either input_ids or inputs_embeds")
device = input_ids.device if input_ids is not None else inputs_embeds.device
if token_type_ids is not None:
token_type_ids = token_type_ids.view(-1, input_shape[-1])
if position_ids is not None:
position_ids = position_ids.view(-1, input_shape[-1])
if past_key_values is None:
past_length = 0
past_key_values = tuple([None] * len(self.h))
else:
past_length = past_key_values[0][0].size(-2)
if inputs_embeds is None:
inputs_embeds = self.wte(input_ids)
# NOTE: adapt for lookahead
if attention_mask is not None and len(attention_mask.shape) == 4:
# with lookahead
position_ids = torch.sum(attention_mask, dim=-1).squeeze(1) - 1
attention_mask = (1.0 - attention_mask.to(inputs_embeds.dtype)) * torch.finfo(inputs_embeds.dtype).min
else:
# without lookahead
if position_ids is None:
position_ids = torch.arange(
past_length,
input_shape[-1] + past_length,
dtype=torch.long,
device=device,
)
position_ids = position_ids.unsqueeze(0).view(-1, input_shape[-1])
if attention_mask is not None:
if batch_size <= 0:
raise ValueError("batch_size has to be defined and > 0")
attention_mask = attention_mask.view(batch_size, -1)
attention_mask = attention_mask[:, None, None, :]
attention_mask = attention_mask.to(dtype=self.dtype)
attention_mask = (1.0 - attention_mask) * torch.finfo(self.dtype).min
encoder_attention_mask = None
head_mask = self.get_head_mask(head_mask, self.config.num_hidden_layers)
# if inputs_embeds is None:
# inputs_embeds = self.wte(input_ids)
hidden_states = inputs_embeds
kv_seq_len = hidden_states.size()[1]
if past_key_values[0] is not None:
# past key values[0][0] shape: bs * seq_len * head_num * dim
kv_seq_len += past_key_values[0][0].shape[1]
if (
self.use_dynamic_ntk
and kv_seq_len == hidden_states.size()[1]
and not self.training
):
context_value = math.log(kv_seq_len / self.seq_length, 2) + 1
ntk_alpha = 2 ** math.ceil(context_value) - 1
ntk_alpha = max(ntk_alpha, 1)
else:
ntk_alpha = self.rotary_emb._ntk_alpha_cached
rotary_pos_emb = self.rotary_emb(kv_seq_len, ntk_alpha=ntk_alpha)
for idx in range(len(rotary_pos_emb)):
rotary_pos_emb[idx] = rotary_pos_emb[idx].to(hidden_states.device)
hidden_states = self.drop(hidden_states)
output_shape = input_shape + (hidden_states.size(-1),)
if self.gradient_checkpointing and self.training:
if use_cache:
logger.warning_once(
"`use_cache=True` is incompatible with gradient checkpointing. Setting `use_cache=False`..."
)
use_cache = False
presents = () if use_cache else None
all_self_attentions = () if output_attentions else None
all_hidden_states = () if output_hidden_states else None
for i, (block, layer_past) in enumerate(zip(self.h, past_key_values)):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
if self.gradient_checkpointing and self.training:
def create_custom_forward(module):
def custom_forward(*inputs):
# None for past_key_value
return module(*inputs, use_cache, output_attentions)
return custom_forward
outputs = torch.utils.checkpoint.checkpoint(
create_custom_forward(block),
hidden_states,
rotary_pos_emb,
self.registered_causal_mask,
None,
attention_mask,
head_mask[i],
encoder_hidden_states,
encoder_attention_mask,
)
else:
outputs = block(
hidden_states,
layer_past=layer_past,
rotary_pos_emb=rotary_pos_emb,
registered_causal_mask=self.registered_causal_mask,
attention_mask=attention_mask,
head_mask=head_mask[i],
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
use_cache=use_cache,
output_attentions=output_attentions,
)
hidden_states = outputs[0]
if use_cache is True:
presents = presents + (outputs[1],)
if output_attentions:
all_self_attentions = all_self_attentions + (outputs[2 if use_cache else 1],)
hidden_states = self.ln_f(hidden_states)
hidden_states = hidden_states.view(output_shape)
# Add last hidden state
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
if not return_dict:
return tuple(
v for v in [hidden_states, presents, all_hidden_states] if v is not None
)
return BaseModelOutputWithPast(
last_hidden_state=hidden_states,
past_key_values=presents,
hidden_states=all_hidden_states,
attentions=all_self_attentions,
)
class QWenLMHeadModel(QWenPreTrainedModel):
_keys_to_ignore_on_load_missing = [r"h\.\d+\.attn\.rotary_emb\.inv_freq"]
_keys_to_ignore_on_load_unexpected = [r"h\.\d+\.attn\.masked_bias"]
def __init__(self, config):
super().__init__(config)
assert (
config.bf16 + config.fp16 + config.fp32 <= 1
), "Only one of \"bf16\", \"fp16\", \"fp32\" can be true"
autoset_precision = config.bf16 + config.fp16 + config.fp32 == 0
if autoset_precision:
if SUPPORT_BF16:
logger.warn(
"The model is automatically converting to bf16 for faster inference. "
"If you want to disable the automatic precision, please manually add bf16/fp16/fp32=True to \"AutoModelForCausalLM.from_pretrained\"."
)
config.bf16 = True
elif SUPPORT_FP16:
logger.warn(
"The model is automatically converting to fp16 for faster inference. "
"If you want to disable the automatic precision, please manually add bf16/fp16/fp32=True to \"AutoModelForCausalLM.from_pretrained\"."
)
config.fp16 = True
else:
config.fp32 = True
if config.bf16 and SUPPORT_CUDA and not SUPPORT_BF16:
logger.warn(
"Your device does NOT seem to support bf16, you can switch to fp16 or fp32 by by passing fp16/fp32=True in \"AutoModelForCausalLM.from_pretrained\".")
if config.fp16 and SUPPORT_CUDA and not SUPPORT_FP16:
logger.warn(
"Your device does NOT support faster inference with fp16, please switch to fp32 which is likely to be faster")
if config.fp32:
if SUPPORT_BF16:
logger.warn(
"Your device support faster inference by passing bf16=True in \"AutoModelForCausalLM.from_pretrained\".")
elif SUPPORT_FP16:
logger.warn(
"Your device support faster inference by passing fp16=True in \"AutoModelForCausalLM.from_pretrained\".")
if config.use_flash_attn == "auto":
if config.bf16 or config.fp16:
logger.warn("Try importing flash-attention for faster inference...")
config.use_flash_attn = True
else:
config.use_flash_attn = False
if config.use_flash_attn and config.fp32:
logger.warn("Flash attention will be disabled because it does NOT support fp32.")
if config.use_flash_attn:
_import_flash_attn()
self.transformer = QWenModel(config)
self.lm_head = nn.Linear(config.hidden_size, config.vocab_size, bias=False)
if config.bf16:
self.transformer.bfloat16()
self.lm_head.bfloat16()
if config.fp16:
self.transformer.half()
self.lm_head.half()
self.post_init()
def get_output_embeddings(self):
return self.lm_head
def set_output_embeddings(self, new_embeddings):
self.lm_head = new_embeddings
def prepare_inputs_for_generation(
self, input_ids, past_key_values=None, inputs_embeds=None, **kwargs
):
token_type_ids = kwargs.get("token_type_ids", None)
if past_key_values:
input_ids = input_ids[:, -1].unsqueeze(-1)
if token_type_ids is not None:
token_type_ids = token_type_ids[:, -1].unsqueeze(-1)
attention_mask = kwargs.get("attention_mask", None)
position_ids = kwargs.get("position_ids", None)
if attention_mask is not None and position_ids is None:
position_ids = attention_mask.long().cumsum(-1) - 1
position_ids.masked_fill_(attention_mask == 0, 1)
if past_key_values:
position_ids = position_ids[:, -1].unsqueeze(-1)
else:
position_ids = None
if inputs_embeds is not None and past_key_values is None:
model_inputs = {"inputs_embeds": inputs_embeds}
else:
model_inputs = {"input_ids": input_ids}
model_inputs.update(
{
"past_key_values": past_key_values,
"use_cache": kwargs.get("use_cache"),
"position_ids": position_ids,
"attention_mask": attention_mask,
"token_type_ids": token_type_ids,
}
)
return model_inputs
def forward(
self,
input_ids: Optional[torch.LongTensor] = None,
past_key_values: Optional[Tuple[Tuple[torch.Tensor]]] = None,
attention_mask: Optional[torch.FloatTensor] = None,
token_type_ids: Optional[torch.LongTensor] = None,
position_ids: Optional[torch.LongTensor] = None,
head_mask: Optional[torch.FloatTensor] = None,
inputs_embeds: Optional[torch.FloatTensor] = None,
encoder_hidden_states: Optional[torch.Tensor] = None,
encoder_attention_mask: Optional[torch.FloatTensor] = None,
labels: Optional[torch.LongTensor] = None,
use_cache: Optional[bool] = None,
output_attentions: Optional[bool] = None,
output_hidden_states: Optional[bool] = None,
return_dict: Optional[bool] = None,
) -> Union[Tuple, CausalLMOutputWithPast]:
return_dict = (
return_dict if return_dict is not None else self.config.use_return_dict
)
transformer_outputs = self.transformer(
input_ids,
past_key_values=past_key_values,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
position_ids=position_ids,
head_mask=head_mask,
inputs_embeds=inputs_embeds,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_attention_mask,
use_cache=use_cache,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
hidden_states = transformer_outputs[0]
lm_logits = self.lm_head(hidden_states)
loss = None
if labels is not None:
labels = labels.to(lm_logits.device)
shift_logits = lm_logits[..., :-1, :].contiguous()
shift_labels = labels[..., 1:].contiguous()
loss_fct = CrossEntropyLoss()
loss = loss_fct(
shift_logits.view(-1, shift_logits.size(-1)), shift_labels.view(-1)
)
if not return_dict:
output = (lm_logits,) + transformer_outputs[1:]
return ((loss,) + output) if loss is not None else output
return CausalLMOutputWithPast(
loss=loss,
logits=lm_logits,
past_key_values=transformer_outputs.past_key_values,
hidden_states=transformer_outputs.hidden_states,
attentions=transformer_outputs.attentions,
)
@staticmethod
def _reorder_cache(
past_key_values: Tuple[Tuple[torch.Tensor]], beam_idx: torch.Tensor
) -> Tuple[Tuple[torch.Tensor]]:
return tuple(
tuple(
past_state.index_select(0, beam_idx.to(past_state.device))
for past_state in layer_past
)
for layer_past in past_key_values
)
def chat(
self,
tokenizer: PreTrainedTokenizer,
query: str,
history: Optional[HistoryType],
system: str = "You are a helpful assistant.",
append_history: bool = True,
stream: Optional[bool] = _SENTINEL,
stop_words_ids: Optional[List[List[int]]] = None,
generation_config: Optional[GenerationConfig] = None,
**kwargs,
) -> Tuple[str, HistoryType]:
generation_config = generation_config if generation_config is not None else self.generation_config
assert stream is _SENTINEL, _ERROR_STREAM_IN_CHAT
assert generation_config.chat_format == 'chatml', _ERROR_BAD_CHAT_FORMAT
if history is None:
history = []
if stop_words_ids is None:
stop_words_ids = []
max_window_size = kwargs.get('max_window_size', None)
if max_window_size is None:
max_window_size = generation_config.max_window_size | raw_text, context_tokens = make_context( | 2 | 2023-12-19 13:11:38+00:00 | 24k |
MingtaoGuo/AnimateAnyone_unofficial | aldm/aldm.py | [
{
"identifier": "conv_nd",
"path": "ldm/modules/diffusionmodules/util.py",
"snippet": "def conv_nd(dims, *args, **kwargs):\n \"\"\"\n Create a 1D, 2D, or 3D convolution module.\n \"\"\"\n if dims == 1:\n return nn.Conv1d(*args, **kwargs)\n elif dims == 2:\n return nn.Conv2d(... | import einops
import torch
import torch as th
import torch.nn as nn
from ldm.modules.diffusionmodules.util import (
conv_nd,
linear,
zero_module,
timestep_embedding,
)
from einops import rearrange, repeat
from torchvision.utils import make_grid
from ldm.modules.attention import SpatialTransformer, SpatialTransformerPlus
from ldm.modules.diffusionmodules.openaimodel import ResBlock, TimestepEmbedSequential, Downsample, AttentionBlock, Upsample, normalization, checkpoint, convert_module_to_f16, convert_module_to_f32
from ldm.models.diffusion.ddpm import LatentDiffusion
from ldm.util import log_txt_as_img, exists, instantiate_from_config
from ldm.models.diffusion.ddim import DDIMSampler
from omegaconf.listconfig import ListConfig
from omegaconf.listconfig import ListConfig | 18,001 | class ReferenceNet(nn.Module):
"""
The full UNet model with attention and timestep embedding.
:param in_channels: channels in the input Tensor.
:param model_channels: base channel count for the model.
:param out_channels: channels in the output Tensor.
:param num_res_blocks: number of residual blocks per downsample.
:param attention_resolutions: a collection of downsample rates at which
attention will take place. May be a set, list, or tuple.
For example, if this contains 4, then at 4x downsampling, attention
will be used.
:param dropout: the dropout probability.
:param channel_mult: channel multiplier for each level of the UNet.
:param conv_resample: if True, use learned convolutions for upsampling and
downsampling.
:param dims: determines if the signal is 1D, 2D, or 3D.
:param num_classes: if specified (as an int), then this model will be
class-conditional with `num_classes` classes.
:param use_checkpoint: use gradient checkpointing to reduce memory usage.
:param num_heads: the number of attention heads in each attention layer.
:param num_heads_channels: if specified, ignore num_heads and instead use
a fixed channel width per attention head.
:param num_heads_upsample: works with num_heads to set a different number
of heads for upsampling. Deprecated.
:param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
:param resblock_updown: use residual blocks for up/downsampling.
:param use_new_attention_order: use a different attention pattern for potentially
increased efficiency.
"""
def __init__(
self,
image_size,
in_channels,
model_channels,
num_res_blocks,
attention_resolutions,
dropout=0,
channel_mult=(1, 2, 4, 8),
conv_resample=True,
dims=2,
num_classes=None,
use_checkpoint=False,
use_fp16=False,
num_heads=-1,
num_head_channels=-1,
num_heads_upsample=-1,
use_scale_shift_norm=False,
resblock_updown=False,
use_new_attention_order=False,
use_spatial_transformer=False, # custom transformer support
transformer_depth=1, # custom transformer support
context_dim=None, # custom transformer support
n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model
legacy=True,
disable_self_attentions=None,
num_attention_blocks=None,
disable_middle_self_attn=False,
use_linear_in_transformer=False,
):
super().__init__()
if use_spatial_transformer:
assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
if context_dim is not None:
assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
if type(context_dim) == ListConfig:
context_dim = list(context_dim)
if num_heads_upsample == -1:
num_heads_upsample = num_heads
if num_heads == -1:
assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
if num_head_channels == -1:
assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
self.image_size = image_size
self.in_channels = in_channels
self.model_channels = model_channels
if isinstance(num_res_blocks, int):
self.num_res_blocks = len(channel_mult) * [num_res_blocks]
else:
if len(num_res_blocks) != len(channel_mult):
raise ValueError("provide num_res_blocks either as an int (globally constant) or "
"as a list/tuple (per-level) with the same length as channel_mult")
self.num_res_blocks = num_res_blocks
if disable_self_attentions is not None:
# should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not
assert len(disable_self_attentions) == len(channel_mult)
if num_attention_blocks is not None:
assert len(num_attention_blocks) == len(self.num_res_blocks)
assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks))))
print(f"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. "
f"This option has LESS priority than attention_resolutions {attention_resolutions}, "
f"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, "
f"attention will still not be set.")
self.attention_resolutions = attention_resolutions
self.dropout = dropout
self.channel_mult = channel_mult
self.conv_resample = conv_resample
self.num_classes = num_classes
self.use_checkpoint = use_checkpoint
self.dtype = th.float16 if use_fp16 else th.float32
self.num_heads = num_heads
self.num_head_channels = num_head_channels
self.num_heads_upsample = num_heads_upsample
self.predict_codebook_ids = n_embed is not None
time_embed_dim = model_channels * 4
self.time_embed = nn.Sequential(
linear(model_channels, time_embed_dim),
nn.SiLU(),
linear(time_embed_dim, time_embed_dim),
)
self.input_blocks = nn.ModuleList(
[
TimestepEmbedSequential(
|
class ReferenceNet(nn.Module):
"""
The full UNet model with attention and timestep embedding.
:param in_channels: channels in the input Tensor.
:param model_channels: base channel count for the model.
:param out_channels: channels in the output Tensor.
:param num_res_blocks: number of residual blocks per downsample.
:param attention_resolutions: a collection of downsample rates at which
attention will take place. May be a set, list, or tuple.
For example, if this contains 4, then at 4x downsampling, attention
will be used.
:param dropout: the dropout probability.
:param channel_mult: channel multiplier for each level of the UNet.
:param conv_resample: if True, use learned convolutions for upsampling and
downsampling.
:param dims: determines if the signal is 1D, 2D, or 3D.
:param num_classes: if specified (as an int), then this model will be
class-conditional with `num_classes` classes.
:param use_checkpoint: use gradient checkpointing to reduce memory usage.
:param num_heads: the number of attention heads in each attention layer.
:param num_heads_channels: if specified, ignore num_heads and instead use
a fixed channel width per attention head.
:param num_heads_upsample: works with num_heads to set a different number
of heads for upsampling. Deprecated.
:param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
:param resblock_updown: use residual blocks for up/downsampling.
:param use_new_attention_order: use a different attention pattern for potentially
increased efficiency.
"""
def __init__(
self,
image_size,
in_channels,
model_channels,
num_res_blocks,
attention_resolutions,
dropout=0,
channel_mult=(1, 2, 4, 8),
conv_resample=True,
dims=2,
num_classes=None,
use_checkpoint=False,
use_fp16=False,
num_heads=-1,
num_head_channels=-1,
num_heads_upsample=-1,
use_scale_shift_norm=False,
resblock_updown=False,
use_new_attention_order=False,
use_spatial_transformer=False, # custom transformer support
transformer_depth=1, # custom transformer support
context_dim=None, # custom transformer support
n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model
legacy=True,
disable_self_attentions=None,
num_attention_blocks=None,
disable_middle_self_attn=False,
use_linear_in_transformer=False,
):
super().__init__()
if use_spatial_transformer:
assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
if context_dim is not None:
assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
if type(context_dim) == ListConfig:
context_dim = list(context_dim)
if num_heads_upsample == -1:
num_heads_upsample = num_heads
if num_heads == -1:
assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
if num_head_channels == -1:
assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
self.image_size = image_size
self.in_channels = in_channels
self.model_channels = model_channels
if isinstance(num_res_blocks, int):
self.num_res_blocks = len(channel_mult) * [num_res_blocks]
else:
if len(num_res_blocks) != len(channel_mult):
raise ValueError("provide num_res_blocks either as an int (globally constant) or "
"as a list/tuple (per-level) with the same length as channel_mult")
self.num_res_blocks = num_res_blocks
if disable_self_attentions is not None:
# should be a list of booleans, indicating whether to disable self-attention in TransformerBlocks or not
assert len(disable_self_attentions) == len(channel_mult)
if num_attention_blocks is not None:
assert len(num_attention_blocks) == len(self.num_res_blocks)
assert all(map(lambda i: self.num_res_blocks[i] >= num_attention_blocks[i], range(len(num_attention_blocks))))
print(f"Constructor of UNetModel received num_attention_blocks={num_attention_blocks}. "
f"This option has LESS priority than attention_resolutions {attention_resolutions}, "
f"i.e., in cases where num_attention_blocks[i] > 0 but 2**i not in attention_resolutions, "
f"attention will still not be set.")
self.attention_resolutions = attention_resolutions
self.dropout = dropout
self.channel_mult = channel_mult
self.conv_resample = conv_resample
self.num_classes = num_classes
self.use_checkpoint = use_checkpoint
self.dtype = th.float16 if use_fp16 else th.float32
self.num_heads = num_heads
self.num_head_channels = num_head_channels
self.num_heads_upsample = num_heads_upsample
self.predict_codebook_ids = n_embed is not None
time_embed_dim = model_channels * 4
self.time_embed = nn.Sequential(
linear(model_channels, time_embed_dim),
nn.SiLU(),
linear(time_embed_dim, time_embed_dim),
)
self.input_blocks = nn.ModuleList(
[
TimestepEmbedSequential( | conv_nd(dims, in_channels, model_channels, 3, padding=1) | 0 | 2023-12-16 03:31:33+00:00 | 24k |
yasserben/CLOUDS | train_net.py | [
{
"identifier": "add_maskformer2_config",
"path": "clouds/config.py",
"snippet": "def add_maskformer2_config(cfg):\n \"\"\"\n Add config for MASK_FORMER.\n \"\"\"\n # NOTE: configs from original maskformer\n # data config\n # select the dataset mapper\n cfg.INPUT.DATASET_MAPPER_NAME... | from shapely.errors import ShapelyDeprecationWarning
from collections import OrderedDict
from typing import Any, Dict, List, Set
from detectron2.checkpoint import DetectionCheckpointer
from detectron2.config import get_cfg
from detectron2.data import (
MetadataCatalog,
build_detection_train_loader,
build_detection_test_loader,
)
from detectron2.engine import (
DefaultTrainer,
default_argument_parser,
default_setup,
launch,
)
from detectron2.modeling import build_model
from detectron2.evaluation import (
CityscapesInstanceEvaluator,
CityscapesSemSegEvaluator,
COCOEvaluator,
COCOPanopticEvaluator,
DatasetEvaluators,
LVISEvaluator,
SemSegEvaluator,
verify_results,
inference_on_dataset,
print_csv_format,
DatasetEvaluator,
)
from detectron2.projects.deeplab import add_deeplab_config, build_lr_scheduler
from detectron2.solver.build import maybe_add_gradient_clipping
from detectron2.utils.logger import setup_logger
from detectron2.engine import hooks
from fvcore.nn.precise_bn import get_bn_modules
from clouds import (
CityscapesSemSegEvaluator,
ClassicalSemSegEvaluator,
MapperTrain,
MapperTest,
add_maskformer2_config,
add_clouds_config,
add_wandb_config,
add_prerocessing_training_set_config,
PersoEvalHook,
add_repeat_factors,
)
from clouds.utils import setup_wandb, WandbWriter
import warnings
import copy
import itertools
import logging
import os
import ast
import torch
import detectron2.utils.comm as comm | 14,555 | evaluators (list[DatasetEvaluator] or None): if None, will call
:meth:`build_evaluator`. Otherwise, must have the same length as
``cfg.DATASETS.TEST``.
Returns:
dict: a dict of result metrics
"""
logger = logging.getLogger(__name__)
if isinstance(evaluators, DatasetEvaluator):
evaluators = [evaluators]
if evaluators is not None:
assert len(cfg.DATASETS.TEST) == len(evaluators), "{} != {}".format(
len(cfg.DATASETS.TEST), len(evaluators)
)
results = OrderedDict()
for idx, dataset_name in enumerate(cfg.DATASETS.TEST):
data_loader = cls.build_test_loader(cfg, dataset_name)
# When evaluators are passed in as arguments,
# implicitly assume that evaluators can be created before data_loader.
if evaluators is not None:
evaluator = evaluators[idx]
else:
try:
evaluator = cls.build_evaluator(
cfg, dataset_name, output_folder=output_folder
)
except NotImplementedError:
logger.warn(
"No evaluator found. Use `DefaultTrainer.test(evaluators=)`, "
"or implement its `build_evaluator` method."
)
results[dataset_name] = {}
continue
results_i = inference_on_dataset(model, data_loader, evaluator)
results[dataset_name] = results_i
if comm.is_main_process():
assert isinstance(
results_i, dict
), "Evaluator must return a dict on the main process. Got {} instead.".format(
results_i
)
logger.info(
"Evaluation results for {} in csv format:".format(dataset_name)
)
print_csv_format(results_i)
if len(results) == 1:
results = list(results.values())[0]
return results
def build_hooks(self):
"""
Build a list of default hooks, including timing, evaluation,
checkpointing, lr scheduling, precise BN, writing events.
Returns:
list[HookBase]:
"""
cfg = self.cfg.clone()
cfg.defrost()
cfg.DATALOADER.NUM_WORKERS = 0 # save some memory and time for PreciseBN
ret = [
hooks.IterationTimer(),
hooks.LRScheduler(),
hooks.PreciseBN(
# Run at the same freq as (but before) evaluation.
cfg.TEST.EVAL_PERIOD,
self.model,
# Build a new data loader to not affect training
self.build_train_loader(cfg),
cfg.TEST.PRECISE_BN.NUM_ITER,
)
if cfg.TEST.PRECISE_BN.ENABLED and get_bn_modules(self.model)
else None,
]
# Do PreciseBN before checkpointer, because it updates the model and need to
# be saved by checkpointer.
# This is not always the best: if checkpointing has a different frequency,
# some checkpoints may have more precise statistics than others.
if comm.is_main_process():
ret.append(
hooks.PeriodicCheckpointer(self.checkpointer, cfg.TEST.EVAL_PERIOD * 5)
)
def test_and_save_results():
self._last_eval_results = self.test(self.cfg, self.model)
return self._last_eval_results
# Do evaluation after checkpointer, because then if it fails,
# we can use the saved checkpoint to debug.
# ret.append(hooks.EvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))
ret.append(PersoEvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))
if comm.is_main_process():
# Here the default print/log frequency of each writer is used.
# run writers in the end, so that evaluation metrics are written
ret.append(hooks.PeriodicWriter(self.build_writers(), period=20))
return ret
def setup(args):
"""
Create configs and perform basic setups.
"""
cfg = get_cfg()
# for poly lr schedule
add_deeplab_config(cfg)
add_maskformer2_config(cfg)
add_clouds_config(cfg)
add_wandb_config(cfg)
add_prerocessing_training_set_config(cfg)
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
add_repeat_factors(cfg)
cfg.freeze()
default_setup(cfg, args)
if not args.eval_only:
| """
Copyright 2023 Telecom Paris, Yasser BENIGMIM. All rights reserved.
Licensed under the Apache License, Version 2.0
Reference: https://github.com/facebookresearch/Mask2Former/blob/main/train_net.py
CLOUDS Training Script.
This script is a simplified version of the training script in detectron2/tools.
"""
try:
# ignore ShapelyDeprecationWarning from fvcore
warnings.filterwarnings("ignore", category=ShapelyDeprecationWarning)
except:
pass
class Trainer(DefaultTrainer):
"""
Extension of the Trainer class adapted to CLOUDS.
"""
def build_writers(self):
writers = super().build_writers()
# use wandb writer instead.
writers[-1] = WandbWriter()
return writers
@classmethod
def build_model(cls, cfg):
"""
Returns:
torch.nn.Module:
It now calls :func:`detectron2.modeling.build_model`.
Overwrite it if you'd like a different model.
"""
model = build_model(cfg)
# logger = logging.getLogger(__name__)
# logger.info("Model:\n{}".format(model))
return model
# @classmethod
# def build_model(cls, cfg):
# """
# Returns:
# torch.nn.Module:
#
# It now calls :func:`detectron2.modeling.build_model`.
# Overwrite it if you'd like a different model.
# """
# model = build_model(cfg)
# # logger = logging.getLogger(__name__)
# # logger.info("Model:\n{}".format(model))
# return model
@classmethod
def build_evaluator(cls, cfg, dataset_name, output_folder=None):
"""
Create evaluator(s) for a given dataset.
This uses the special metadata "evaluator_type" associated with each
builtin dataset. For your own dataset, you can simply create an
evaluator manually in your script and do not have to worry about the
hacky if-else logic here.
"""
if output_folder is None:
output_folder = os.path.join(cfg.OUTPUT_DIR, "inference")
else:
output_folder = os.path.join(cfg.OUTPUT_DIR, output_folder, "inference")
evaluator_list = []
evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type
# semantic segmentation
if (
evaluator_type == "bdd_sem_seg"
or evaluator_type == "mapillary_sem_seg"
or evaluator_type == "acdc_sem_seg"
):
evaluator_list.append(
ClassicalSemSegEvaluator(
dataset_name,
distributed=True,
output_dir=output_folder,
save_pl=cfg.MODEL.SAVE_PSEUDO_LABELS,
)
)
# Cityscapes
if evaluator_type == "cityscapes_sem_seg":
assert (
torch.cuda.device_count() > comm.get_rank()
), "CityscapesEvaluator currently do not work with multiple machines."
# return CityscapesSemSegEvaluator(dataset_name)
if cfg.MODEL.SAVE_PSEUDO_LABELS:
return CityscapesSemSegEvaluator(
dataset_name, save_pl=True, output_dir=output_folder
)
else:
return CityscapesSemSegEvaluator(dataset_name)
if len(evaluator_list) == 0:
raise NotImplementedError(
"no Evaluator for the dataset {} with the type {}".format(
dataset_name, evaluator_type
)
)
elif len(evaluator_list) == 1:
return evaluator_list[0]
return DatasetEvaluators(evaluator_list)
@classmethod
def build_train_loader(cls, cfg):
# Semantic segmentation dataset mapper
mapper = MapperTrain(cfg, True)
return build_detection_train_loader(cfg, mapper=mapper)
@classmethod
def build_test_loader(cls, cfg, dataset_name):
mapper = MapperTest(cfg, False)
return build_detection_test_loader(
cfg, dataset_name, batch_size=1, mapper=mapper
)
@classmethod
def build_lr_scheduler(cls, cfg, optimizer):
"""
It now calls :func:`detectron2.solver.build_lr_scheduler`.
Overwrite it if you'd like a different scheduler.
"""
return build_lr_scheduler(cfg, optimizer)
@classmethod
def build_optimizer(cls, cfg, model):
weight_decay_norm = cfg.SOLVER.WEIGHT_DECAY_NORM
weight_decay_embed = cfg.SOLVER.WEIGHT_DECAY_EMBED
defaults = {}
defaults["lr"] = cfg.SOLVER.BASE_LR
defaults["weight_decay"] = cfg.SOLVER.WEIGHT_DECAY
norm_module_types = (
torch.nn.BatchNorm1d,
torch.nn.BatchNorm2d,
torch.nn.BatchNorm3d,
torch.nn.SyncBatchNorm,
# NaiveSyncBatchNorm inherits from BatchNorm2d
torch.nn.GroupNorm,
torch.nn.InstanceNorm1d,
torch.nn.InstanceNorm2d,
torch.nn.InstanceNorm3d,
torch.nn.LayerNorm,
torch.nn.LocalResponseNorm,
)
params: List[Dict[str, Any]] = []
memo: Set[torch.nn.parameter.Parameter] = set()
for module_name, module in model.named_modules():
for module_param_name, value in module.named_parameters(recurse=False):
if not value.requires_grad:
continue
if cfg.MODEL.CLOUDS.OVERWRITING:
if any(
ignored_module in module_name
for ignored_module in ["sem_seg_head_ema.", "sam.sam."]
):
continue
# Avoid duplicating parameters
if value in memo:
continue
memo.add(value)
hyperparams = copy.copy(defaults)
if "backbone" in module_name:
hyperparams["lr"] = (
hyperparams["lr"] * cfg.SOLVER.BACKBONE_MULTIPLIER
)
if (
"relative_position_bias_table" in module_param_name
or "absolute_pos_embed" in module_param_name
):
print(module_param_name)
hyperparams["weight_decay"] = 0.0
if isinstance(module, norm_module_types):
hyperparams["weight_decay"] = weight_decay_norm
if isinstance(module, torch.nn.Embedding):
hyperparams["weight_decay"] = weight_decay_embed
params.append({"params": [value], **hyperparams})
def maybe_add_full_model_gradient_clipping(optim):
# detectron2 doesn't have full model gradient clipping now
clip_norm_val = cfg.SOLVER.CLIP_GRADIENTS.CLIP_VALUE
enable = (
cfg.SOLVER.CLIP_GRADIENTS.ENABLED
and cfg.SOLVER.CLIP_GRADIENTS.CLIP_TYPE == "full_model"
and clip_norm_val > 0.0
)
class FullModelGradientClippingOptimizer(optim):
def step(self, closure=None):
all_params = itertools.chain(
*[x["params"] for x in self.param_groups]
)
torch.nn.utils.clip_grad_norm_(all_params, clip_norm_val)
super().step(closure=closure)
return FullModelGradientClippingOptimizer if enable else optim
optimizer_type = cfg.SOLVER.OPTIMIZER
if optimizer_type == "SGD":
optimizer = maybe_add_full_model_gradient_clipping(torch.optim.SGD)(
params, cfg.SOLVER.BASE_LR, momentum=cfg.SOLVER.MOMENTUM
)
elif optimizer_type == "ADAMW":
optimizer = maybe_add_full_model_gradient_clipping(torch.optim.AdamW)(
params, cfg.SOLVER.BASE_LR
)
else:
raise NotImplementedError(f"no optimizer type {optimizer_type}")
if not cfg.SOLVER.CLIP_GRADIENTS.CLIP_TYPE == "full_model":
optimizer = maybe_add_gradient_clipping(cfg, optimizer)
return optimizer
@classmethod
def test(cls, cfg, model, output_folder=None, evaluators=None):
"""
Evaluate the given model. The given model is expected to already contain
weights to evaluate.
Args:
cfg (CfgNode):
model (nn.Module):
evaluators (list[DatasetEvaluator] or None): if None, will call
:meth:`build_evaluator`. Otherwise, must have the same length as
``cfg.DATASETS.TEST``.
Returns:
dict: a dict of result metrics
"""
logger = logging.getLogger(__name__)
if isinstance(evaluators, DatasetEvaluator):
evaluators = [evaluators]
if evaluators is not None:
assert len(cfg.DATASETS.TEST) == len(evaluators), "{} != {}".format(
len(cfg.DATASETS.TEST), len(evaluators)
)
results = OrderedDict()
for idx, dataset_name in enumerate(cfg.DATASETS.TEST):
data_loader = cls.build_test_loader(cfg, dataset_name)
# When evaluators are passed in as arguments,
# implicitly assume that evaluators can be created before data_loader.
if evaluators is not None:
evaluator = evaluators[idx]
else:
try:
evaluator = cls.build_evaluator(
cfg, dataset_name, output_folder=output_folder
)
except NotImplementedError:
logger.warn(
"No evaluator found. Use `DefaultTrainer.test(evaluators=)`, "
"or implement its `build_evaluator` method."
)
results[dataset_name] = {}
continue
results_i = inference_on_dataset(model, data_loader, evaluator)
results[dataset_name] = results_i
if comm.is_main_process():
assert isinstance(
results_i, dict
), "Evaluator must return a dict on the main process. Got {} instead.".format(
results_i
)
logger.info(
"Evaluation results for {} in csv format:".format(dataset_name)
)
print_csv_format(results_i)
if len(results) == 1:
results = list(results.values())[0]
return results
def build_hooks(self):
"""
Build a list of default hooks, including timing, evaluation,
checkpointing, lr scheduling, precise BN, writing events.
Returns:
list[HookBase]:
"""
cfg = self.cfg.clone()
cfg.defrost()
cfg.DATALOADER.NUM_WORKERS = 0 # save some memory and time for PreciseBN
ret = [
hooks.IterationTimer(),
hooks.LRScheduler(),
hooks.PreciseBN(
# Run at the same freq as (but before) evaluation.
cfg.TEST.EVAL_PERIOD,
self.model,
# Build a new data loader to not affect training
self.build_train_loader(cfg),
cfg.TEST.PRECISE_BN.NUM_ITER,
)
if cfg.TEST.PRECISE_BN.ENABLED and get_bn_modules(self.model)
else None,
]
# Do PreciseBN before checkpointer, because it updates the model and need to
# be saved by checkpointer.
# This is not always the best: if checkpointing has a different frequency,
# some checkpoints may have more precise statistics than others.
if comm.is_main_process():
ret.append(
hooks.PeriodicCheckpointer(self.checkpointer, cfg.TEST.EVAL_PERIOD * 5)
)
def test_and_save_results():
self._last_eval_results = self.test(self.cfg, self.model)
return self._last_eval_results
# Do evaluation after checkpointer, because then if it fails,
# we can use the saved checkpoint to debug.
# ret.append(hooks.EvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))
ret.append(PersoEvalHook(cfg.TEST.EVAL_PERIOD, test_and_save_results))
if comm.is_main_process():
# Here the default print/log frequency of each writer is used.
# run writers in the end, so that evaluation metrics are written
ret.append(hooks.PeriodicWriter(self.build_writers(), period=20))
return ret
def setup(args):
"""
Create configs and perform basic setups.
"""
cfg = get_cfg()
# for poly lr schedule
add_deeplab_config(cfg)
add_maskformer2_config(cfg)
add_clouds_config(cfg)
add_wandb_config(cfg)
add_prerocessing_training_set_config(cfg)
cfg.merge_from_file(args.config_file)
cfg.merge_from_list(args.opts)
add_repeat_factors(cfg)
cfg.freeze()
default_setup(cfg, args)
if not args.eval_only: | setup_wandb(cfg, args) | 11 | 2023-12-15 15:40:58+00:00 | 24k |
Ruiyuan-Zhang/CCS | multi_part_assembly/utils/wx_transformer_utilities/transformer_layer.py | [
{
"identifier": "LayerNorm",
"path": "multi_part_assembly/utils/wx_transformer_utilities/layer_norm.py",
"snippet": "def LayerNorm(normalized_shape, eps=1e-5, elementwise_affine=True, export=False):\n if not export and torch.cuda.is_available() and has_fused_layernorm:\n return FusedLayerNorm(... | from typing import Dict, List, Optional
from .layer_norm import LayerNorm
from .multihead_attention import MultiheadAttention
from .relational_memory import RelationalMemory
from .group_linear_layer import GroupLinearLayer
from .basic_mha import MemoryAttention
from .quant_noise import quant_noise
from .fairseq_dropout import FairseqDropout
from torch import Tensor
import torch
import torch.nn as nn
import multi_part_assembly.utils.wx_transformer_utilities.fairseq_utils as utils
import random
import torch.nn.functional as F | 15,532 |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
#from fairseq.modules.shared_group_linear_layer import SharedGroupLinearLayer
class TransformerEncoderLayerVanilla(nn.Module):
"""Encoder layer block.
In the original paper each operation (multi-head attention or FFN) is
postprocessed with: `dropout -> add residual -> layernorm`. In the
tensor2tensor code they suggest that learning is more robust when
preprocessing each layer with layernorm and postprocessing with:
`dropout -> add residual`. We default to the approach in the paper, but the
tensor2tensor approach can be enabled by setting
*args.encoder_normalize_before* to ``True``.
Args:
args (argparse.Namespace): parsed command-line arguments
"""
def __init__(self, args, out_proj = None):
super().__init__()
self.embed_dim = args.encoder_embed_dim
self.self_attn = self.build_self_attention(self.embed_dim, args)
self.self_attn_layer_norm = LayerNorm(self.embed_dim, eps=1e-5)
self.dropout = args.dropout
self.activation_fn = utils.get_activation_fn(
activation=getattr(args, "activation_fn", "relu")
)
self.activation_dropout = getattr(args, "activation_dropout", 0)
if self.activation_dropout == 0:
# for backwards compatibility with models that use args.relu_dropout
self.activation_dropout = getattr(args, "relu_dropout", 0)
self.normalize_before = args.encoder_normalize_before
self.fc1 = self.build_fc1(self.embed_dim, args.encoder_ffn_embed_dim)
self.fc2 = self.build_fc2(args.encoder_ffn_embed_dim, self.embed_dim)
self.final_layer_norm = LayerNorm(self.embed_dim, eps=1e-5)
if out_proj is not None:
self.final_linear = nn.Linear(args.encoder_embed_dim, out_proj)
else:
self.final_linear = None
def build_fc1(self, input_dim, output_dim):
return nn.Linear(input_dim, output_dim)
def build_fc2(self, input_dim, output_dim):
return nn.Linear(input_dim, output_dim)
def build_self_attention(self, embed_dim, args):
|
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
#from fairseq.modules.shared_group_linear_layer import SharedGroupLinearLayer
class TransformerEncoderLayerVanilla(nn.Module):
"""Encoder layer block.
In the original paper each operation (multi-head attention or FFN) is
postprocessed with: `dropout -> add residual -> layernorm`. In the
tensor2tensor code they suggest that learning is more robust when
preprocessing each layer with layernorm and postprocessing with:
`dropout -> add residual`. We default to the approach in the paper, but the
tensor2tensor approach can be enabled by setting
*args.encoder_normalize_before* to ``True``.
Args:
args (argparse.Namespace): parsed command-line arguments
"""
def __init__(self, args, out_proj = None):
super().__init__()
self.embed_dim = args.encoder_embed_dim
self.self_attn = self.build_self_attention(self.embed_dim, args)
self.self_attn_layer_norm = LayerNorm(self.embed_dim, eps=1e-5)
self.dropout = args.dropout
self.activation_fn = utils.get_activation_fn(
activation=getattr(args, "activation_fn", "relu")
)
self.activation_dropout = getattr(args, "activation_dropout", 0)
if self.activation_dropout == 0:
# for backwards compatibility with models that use args.relu_dropout
self.activation_dropout = getattr(args, "relu_dropout", 0)
self.normalize_before = args.encoder_normalize_before
self.fc1 = self.build_fc1(self.embed_dim, args.encoder_ffn_embed_dim)
self.fc2 = self.build_fc2(args.encoder_ffn_embed_dim, self.embed_dim)
self.final_layer_norm = LayerNorm(self.embed_dim, eps=1e-5)
if out_proj is not None:
self.final_linear = nn.Linear(args.encoder_embed_dim, out_proj)
else:
self.final_linear = None
def build_fc1(self, input_dim, output_dim):
return nn.Linear(input_dim, output_dim)
def build_fc2(self, input_dim, output_dim):
return nn.Linear(input_dim, output_dim)
def build_self_attention(self, embed_dim, args): | return MultiheadAttention( | 1 | 2023-12-15 13:13:01+00:00 | 24k |
m-abr/FCPCodebase | world/World.py | [
{
"identifier": "Logger",
"path": "logs/Logger.py",
"snippet": "class Logger():\n _folder = None\n\n def __init__(self, is_enabled:bool, topic:str) -> None:\n self.no_of_entries = 0 \n self.enabled = is_enabled\n self.topic = topic\n\n def write(self, msg:str, timestamp:boo... | from collections import deque
from cpp.ball_predictor import ball_predictor
from cpp.localization import localization
from logs.Logger import Logger
from math import atan2, pi
from math_ops.Matrix_4x4 import Matrix_4x4
from world.commons.Draw import Draw
from world.commons.Other_Robot import Other_Robot
from world.Robot import Robot
import numpy as np | 19,012 |
class World():
STEPTIME = 0.02 # Fixed step time
STEPTIME_MS = 20 # Fixed step time in milliseconds
VISUALSTEP = 0.04 # Fixed visual step time
VISUALSTEP_MS = 40 # Fixed visual step time in milliseconds
# play modes in our favor
M_OUR_KICKOFF = 0
M_OUR_KICK_IN = 1
M_OUR_CORNER_KICK = 2
M_OUR_GOAL_KICK = 3
M_OUR_FREE_KICK = 4
M_OUR_PASS = 5
M_OUR_DIR_FREE_KICK = 6
M_OUR_GOAL = 7
M_OUR_OFFSIDE = 8
# play modes in their favor
M_THEIR_KICKOFF = 9
M_THEIR_KICK_IN = 10
M_THEIR_CORNER_KICK = 11
M_THEIR_GOAL_KICK = 12
M_THEIR_FREE_KICK = 13
M_THEIR_PASS = 14
M_THEIR_DIR_FREE_KICK = 15
M_THEIR_GOAL = 16
M_THEIR_OFFSIDE = 17
# neutral play modes
M_BEFORE_KICKOFF = 18
M_GAME_OVER = 19
M_PLAY_ON = 20
# play mode groups
MG_OUR_KICK = 0
MG_THEIR_KICK = 1
MG_ACTIVE_BEAM = 2
MG_PASSIVE_BEAM = 3
MG_OTHER = 4 # play on, game over
FLAGS_CORNERS_POS = ((-15,-10,0), (-15,+10,0), (+15,-10,0), (+15,+10,0))
FLAGS_POSTS_POS = ((-15,-1.05,0.8),(-15,+1.05,0.8),(+15,-1.05,0.8),(+15,+1.05,0.8))
def __init__(self,robot_type:int, team_name:str, unum:int, apply_play_mode_correction:bool,
enable_draw:bool, logger:Logger, host:str) -> None:
self.team_name = team_name # Name of our team
self.team_name_opponent : str = None # Name of opponent team
self.apply_play_mode_correction = apply_play_mode_correction # True to adjust ball position according to play mode
self.step = 0 # Total number of received simulation steps (always in sync with self.time_local_ms)
self.time_server = 0.0 # Time, in seconds, as indicated by the server (this time is NOT reliable, use only for synchronization between agents)
self.time_local_ms = 0 # Reliable simulation time in milliseconds, use this when possible (it is incremented 20ms for every TCP message)
self.time_game = 0.0 # Game time, in seconds, as indicated by the server
self.goals_scored = 0 # Goals score by our team
self.goals_conceded = 0 # Goals conceded by our team
self.team_side_is_left : bool = None # True if our team plays on the left side (this value is later changed by the world parser)
self.play_mode = None # Play mode of the soccer game, provided by the server
self.play_mode_group = None # Certain play modes share characteristics, so it makes sense to group them
self.flags_corners : dict = None # corner flags, key=(x,y,z), always assume we play on the left side
self.flags_posts : dict = None # goal posts, key=(x,y,z), always assume we play on the left side
self.ball_rel_head_sph_pos = np.zeros(3) # Ball position relative to head (spherical coordinates) (m, deg, deg)
self.ball_rel_head_cart_pos = np.zeros(3) # Ball position relative to head (cartesian coordinates) (m)
self.ball_rel_torso_cart_pos = np.zeros(3) # Ball position relative to torso (cartesian coordinates) (m)
self.ball_rel_torso_cart_pos_history = deque(maxlen=20) # Ball position relative to torso history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)
self.ball_abs_pos = np.zeros(3) # Ball absolute position (up to date if self.ball_is_visible and self.robot.loc_is_up_to_date) (m)
self.ball_abs_pos_history = deque(maxlen=20) # Ball absolute position history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)
self.ball_abs_pos_last_update = 0 # World.time_local_ms when self.ball_abs_pos was last updated by vision or radio
self.ball_abs_vel = np.zeros(3) # Ball velocity vector based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead get_ball_abs_vel)
self.ball_abs_speed = 0 # Ball scalar speed based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead ||get_ball_abs_vel||)
self.ball_is_visible = False # True if the last server message contained vision information related to the ball
self.is_ball_abs_pos_from_vision = False # True if ball_abs_pos originated from vision, False if it originated from radio
self.ball_last_seen = 0 # World.time_local_ms when ball was last seen (note: may be different from self.ball_abs_pos_last_update)
self.ball_cheat_abs_pos = np.zeros(3) # Absolute ball position provided by the server as cheat (m)
self.ball_cheat_abs_vel = np.zeros(3) # Absolute velocity vector based on the last 2 values of self.ball_cheat_abs_pos (m/s)
self.ball_2d_pred_pos = np.zeros((1,2)) # prediction of current and future 2D ball positions*
self.ball_2d_pred_vel = np.zeros((1,2)) # prediction of current and future 2D ball velocities*
self.ball_2d_pred_spd = np.zeros(1) # prediction of current and future 2D ball linear speeds*
# *at intervals of 0.02 s until ball comes to a stop or gets out of bounds (according to prediction)
self.lines = np.zeros((30,6)) # Position of visible lines, relative to head, start_pos+end_pos (spherical coordinates) (m, deg, deg, m, deg, deg)
self.line_count = 0 # Number of visible lines
self.vision_last_update = 0 # World.time_local_ms when last vision update was received
self.vision_is_up_to_date = False # True if the last server message contained vision information
self.teammates = [Other_Robot(i, True ) for i in range(1,12)] # List of teammates, ordered by unum
self.opponents = [Other_Robot(i, False) for i in range(1,12)] # List of opponents, ordered by unum
self.teammates[unum-1].is_self = True # This teammate is self
|
class World():
STEPTIME = 0.02 # Fixed step time
STEPTIME_MS = 20 # Fixed step time in milliseconds
VISUALSTEP = 0.04 # Fixed visual step time
VISUALSTEP_MS = 40 # Fixed visual step time in milliseconds
# play modes in our favor
M_OUR_KICKOFF = 0
M_OUR_KICK_IN = 1
M_OUR_CORNER_KICK = 2
M_OUR_GOAL_KICK = 3
M_OUR_FREE_KICK = 4
M_OUR_PASS = 5
M_OUR_DIR_FREE_KICK = 6
M_OUR_GOAL = 7
M_OUR_OFFSIDE = 8
# play modes in their favor
M_THEIR_KICKOFF = 9
M_THEIR_KICK_IN = 10
M_THEIR_CORNER_KICK = 11
M_THEIR_GOAL_KICK = 12
M_THEIR_FREE_KICK = 13
M_THEIR_PASS = 14
M_THEIR_DIR_FREE_KICK = 15
M_THEIR_GOAL = 16
M_THEIR_OFFSIDE = 17
# neutral play modes
M_BEFORE_KICKOFF = 18
M_GAME_OVER = 19
M_PLAY_ON = 20
# play mode groups
MG_OUR_KICK = 0
MG_THEIR_KICK = 1
MG_ACTIVE_BEAM = 2
MG_PASSIVE_BEAM = 3
MG_OTHER = 4 # play on, game over
FLAGS_CORNERS_POS = ((-15,-10,0), (-15,+10,0), (+15,-10,0), (+15,+10,0))
FLAGS_POSTS_POS = ((-15,-1.05,0.8),(-15,+1.05,0.8),(+15,-1.05,0.8),(+15,+1.05,0.8))
def __init__(self,robot_type:int, team_name:str, unum:int, apply_play_mode_correction:bool,
enable_draw:bool, logger:Logger, host:str) -> None:
self.team_name = team_name # Name of our team
self.team_name_opponent : str = None # Name of opponent team
self.apply_play_mode_correction = apply_play_mode_correction # True to adjust ball position according to play mode
self.step = 0 # Total number of received simulation steps (always in sync with self.time_local_ms)
self.time_server = 0.0 # Time, in seconds, as indicated by the server (this time is NOT reliable, use only for synchronization between agents)
self.time_local_ms = 0 # Reliable simulation time in milliseconds, use this when possible (it is incremented 20ms for every TCP message)
self.time_game = 0.0 # Game time, in seconds, as indicated by the server
self.goals_scored = 0 # Goals score by our team
self.goals_conceded = 0 # Goals conceded by our team
self.team_side_is_left : bool = None # True if our team plays on the left side (this value is later changed by the world parser)
self.play_mode = None # Play mode of the soccer game, provided by the server
self.play_mode_group = None # Certain play modes share characteristics, so it makes sense to group them
self.flags_corners : dict = None # corner flags, key=(x,y,z), always assume we play on the left side
self.flags_posts : dict = None # goal posts, key=(x,y,z), always assume we play on the left side
self.ball_rel_head_sph_pos = np.zeros(3) # Ball position relative to head (spherical coordinates) (m, deg, deg)
self.ball_rel_head_cart_pos = np.zeros(3) # Ball position relative to head (cartesian coordinates) (m)
self.ball_rel_torso_cart_pos = np.zeros(3) # Ball position relative to torso (cartesian coordinates) (m)
self.ball_rel_torso_cart_pos_history = deque(maxlen=20) # Ball position relative to torso history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)
self.ball_abs_pos = np.zeros(3) # Ball absolute position (up to date if self.ball_is_visible and self.robot.loc_is_up_to_date) (m)
self.ball_abs_pos_history = deque(maxlen=20) # Ball absolute position history (queue with up to 20 old positions at intervals of 0.04s, where index 0 is the previous position)
self.ball_abs_pos_last_update = 0 # World.time_local_ms when self.ball_abs_pos was last updated by vision or radio
self.ball_abs_vel = np.zeros(3) # Ball velocity vector based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead get_ball_abs_vel)
self.ball_abs_speed = 0 # Ball scalar speed based on the last 2 known values of self.ball_abs_pos (m/s) (Warning: noisy if ball is distant, use instead ||get_ball_abs_vel||)
self.ball_is_visible = False # True if the last server message contained vision information related to the ball
self.is_ball_abs_pos_from_vision = False # True if ball_abs_pos originated from vision, False if it originated from radio
self.ball_last_seen = 0 # World.time_local_ms when ball was last seen (note: may be different from self.ball_abs_pos_last_update)
self.ball_cheat_abs_pos = np.zeros(3) # Absolute ball position provided by the server as cheat (m)
self.ball_cheat_abs_vel = np.zeros(3) # Absolute velocity vector based on the last 2 values of self.ball_cheat_abs_pos (m/s)
self.ball_2d_pred_pos = np.zeros((1,2)) # prediction of current and future 2D ball positions*
self.ball_2d_pred_vel = np.zeros((1,2)) # prediction of current and future 2D ball velocities*
self.ball_2d_pred_spd = np.zeros(1) # prediction of current and future 2D ball linear speeds*
# *at intervals of 0.02 s until ball comes to a stop or gets out of bounds (according to prediction)
self.lines = np.zeros((30,6)) # Position of visible lines, relative to head, start_pos+end_pos (spherical coordinates) (m, deg, deg, m, deg, deg)
self.line_count = 0 # Number of visible lines
self.vision_last_update = 0 # World.time_local_ms when last vision update was received
self.vision_is_up_to_date = False # True if the last server message contained vision information
self.teammates = [Other_Robot(i, True ) for i in range(1,12)] # List of teammates, ordered by unum
self.opponents = [Other_Robot(i, False) for i in range(1,12)] # List of opponents, ordered by unum
self.teammates[unum-1].is_self = True # This teammate is self | self.draw = Draw(enable_draw, unum, host, 32769) # Draw object for current player | 2 | 2023-12-16 23:40:23+00:00 | 24k |
Sam-Izdat/tinycio | src/tinycio/lut.py | [
{
"identifier": "ColorSpace",
"path": "src/tinycio/colorspace.py",
"snippet": "class ColorSpace:\n \"\"\"\n Color space conversion. Applies OETFs and EOTFs as needed but omits tonemapping. Cylindrical transformations are \n treated as distinct color spaces. Example:\n\n .. highlight:: python... | import typing
import os
import torch
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
from typing import Union
from enum import IntEnum
from contextlib import nullcontext
from .colorspace import ColorSpace
from .fsio.lutfile import load_lut, save_lut, _infer_lut_file_format, _generate_linear_cube_lut
from .fsio.format import LUTFormat
from .util.colorutil import srgb_luminance
from .util.miscutil import trilinear_interpolation
from .loss import feature_moments_calculation | 17,698 | from __future__ import annotations
class LookupTable:
"""
Color lookup table. Example:
.. highlight:: python
.. code-block:: python
lut = LookupTable.get_negative()
im_negative = lut.apply(im)
:param size: Size of the LUT.
:param lattice: Lattice as tensor (defaults to linear).
:param lut_format: Format of the LUT.
"""
size = 32
lattice = None
| from __future__ import annotations
class LookupTable:
"""
Color lookup table. Example:
.. highlight:: python
.. code-block:: python
lut = LookupTable.get_negative()
im_negative = lut.apply(im)
:param size: Size of the LUT.
:param lattice: Lattice as tensor (defaults to linear).
:param lut_format: Format of the LUT.
"""
size = 32
lattice = None | lut_format= LUTFormat.UNKNOWN | 5 | 2023-12-15 15:39:08+00:00 | 24k |
quocanh34/magic-animate-modified | magicanimate/pipelines/pipeline_animation.py | [
{
"identifier": "UNet3DConditionModel",
"path": "magicanimate/models/unet_controlnet.py",
"snippet": "class UNet3DConditionModel(ModelMixin, ConfigMixin):\n _supports_gradient_checkpointing = True\n\n @register_to_config\n def __init__(\n self,\n sample_size: Optional[int] = None,... | import inspect, math
import numpy as np
import torch
import torch.distributed as dist
from typing import Callable, List, Optional, Union
from dataclasses import dataclass
from PIL import Image
from tqdm import tqdm
from diffusers.utils import is_accelerate_available
from packaging import version
from transformers import CLIPTextModel, CLIPTokenizer
from diffusers.configuration_utils import FrozenDict
from diffusers.models import AutoencoderKL
from diffusers.pipeline_utils import DiffusionPipeline
from diffusers.schedulers import (
DDIMScheduler,
DPMSolverMultistepScheduler,
EulerAncestralDiscreteScheduler,
EulerDiscreteScheduler,
LMSDiscreteScheduler,
PNDMScheduler,
)
from diffusers.utils import deprecate, logging, BaseOutput
from einops import rearrange
from magicanimate.models.unet_controlnet import UNet3DConditionModel
from magicanimate.models.multicontrolnet import ControlNetProcessor #fix
from magicanimate.models.mutual_self_attention import ReferenceAttentionControl
from magicanimate.pipelines.context import (
get_context_scheduler,
get_total_steps
)
from magicanimate.utils.util import get_tensor_interpolation_method
from accelerate import cpu_offload | 15,775 | verbose=False
):
"""
Inverse sampling for DDIM Inversion
"""
if verbose:
print("timestep: ", timestep)
next_step = timestep
timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999)
alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod
alpha_prod_t_next = self.scheduler.alphas_cumprod[next_step]
beta_prod_t = 1 - alpha_prod_t
pred_x0 = (x - beta_prod_t**0.5 * model_output) / alpha_prod_t**0.5
pred_dir = (1 - alpha_prod_t_next)**0.5 * model_output
x_next = alpha_prod_t_next**0.5 * pred_x0 + pred_dir
return x_next, pred_x0
@torch.no_grad()
def images2latents(self, images, dtype):
"""
Convert RGB image to VAE latents
"""
device = self._execution_device
images = torch.from_numpy(images).float().to(dtype) / 127.5 - 1
images = rearrange(images, "f h w c -> f c h w").to(device)
latents = []
for frame_idx in range(images.shape[0]):
latents.append(self.vae.encode(images[frame_idx:frame_idx+1])['latent_dist'].mean * 0.18215)
latents = torch.cat(latents)
return latents
@torch.no_grad()
def invert(
self,
image: torch.Tensor,
prompt,
num_inference_steps=20,
num_actual_inference_steps=10,
eta=0.0,
return_intermediates=False,
**kwargs):
"""
Adapted from: https://github.com/Yujun-Shi/DragDiffusion/blob/main/drag_pipeline.py#L440
invert a real image into noise map with determinisc DDIM inversion
"""
device = self._execution_device
batch_size = image.shape[0]
if isinstance(prompt, list):
if batch_size == 1:
image = image.expand(len(prompt), -1, -1, -1)
elif isinstance(prompt, str):
if batch_size > 1:
prompt = [prompt] * batch_size
# text embeddings
text_input = self.tokenizer(
prompt,
padding="max_length",
max_length=77,
return_tensors="pt"
)
text_embeddings = self.text_encoder(text_input.input_ids.to(device))[0]
print("input text embeddings :", text_embeddings.shape)
# define initial latents
latents = self.images2latents(image)
print("latents shape: ", latents.shape)
# interative sampling
self.scheduler.set_timesteps(num_inference_steps)
print("Valid timesteps: ", reversed(self.scheduler.timesteps))
latents_list = [latents]
pred_x0_list = [latents]
for i, t in enumerate(tqdm(reversed(self.scheduler.timesteps), desc="DDIM Inversion")):
if num_actual_inference_steps is not None and i >= num_actual_inference_steps:
continue
model_inputs = latents
# predict the noise
# NOTE: the u-net here is UNet3D, therefore the model_inputs need to be of shape (b c f h w)
model_inputs = rearrange(model_inputs, "f c h w -> 1 c f h w")
noise_pred = self.unet(model_inputs, t, encoder_hidden_states=text_embeddings).sample
noise_pred = rearrange(noise_pred, "b c f h w -> (b f) c h w")
# compute the previous noise sample x_t-1 -> x_t
latents, pred_x0 = self.next_step(noise_pred, t, latents)
latents_list.append(latents)
pred_x0_list.append(pred_x0)
if return_intermediates:
# return the intermediate laters during inversion
return latents, latents_list
return latents
def interpolate_latents(self, latents: torch.Tensor, interpolation_factor:int, device ):
if interpolation_factor < 2:
return latents
new_latents = torch.zeros(
(latents.shape[0],latents.shape[1],((latents.shape[2]-1) * interpolation_factor)+1, latents.shape[3],latents.shape[4]),
device=latents.device,
dtype=latents.dtype,
)
org_video_length = latents.shape[2]
rate = [i/interpolation_factor for i in range(interpolation_factor)][1:]
new_index = 0
v0 = None
v1 = None
for i0,i1 in zip( range( org_video_length ),range( org_video_length )[1:] ):
v0 = latents[:,:,i0,:,:]
v1 = latents[:,:,i1,:,:]
new_latents[:,:,new_index,:,:] = v0
new_index += 1
for f in rate:
| # *************************************************************************
# This file may have been modified by Bytedance Inc. (“Bytedance Inc.'s Mo-
# difications”). All Bytedance Inc.'s Modifications are Copyright (2023) B-
# ytedance Inc..
# *************************************************************************
# Adapted from https://github.com/showlab/Tune-A-Video/blob/main/tuneavideo/pipelines/pipeline_tuneavideo.py
# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
TODO:
1. support multi-controlnet
2. [DONE] support DDIM inversion
3. support Prompt-to-prompt
"""
# from magicanimate.models.controlnet import ControlNetModel
logger = logging.get_logger(__name__) # pylint: disable=invalid-name
@dataclass
class AnimationPipelineOutput(BaseOutput):
videos: Union[torch.Tensor, np.ndarray]
class AnimationPipeline(DiffusionPipeline):
_optional_components = []
def __init__(
self,
vae: AutoencoderKL,
text_encoder: CLIPTextModel,
tokenizer: CLIPTokenizer,
unet: UNet3DConditionModel,
# controlnet: ControlNetModel,
# processors: List[ControlNetProcessor],
scheduler: Union[
DDIMScheduler,
PNDMScheduler,
LMSDiscreteScheduler,
EulerDiscreteScheduler,
EulerAncestralDiscreteScheduler,
DPMSolverMultistepScheduler,
],
):
super().__init__()
if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
deprecation_message = (
f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
"to update the config accordingly as leaving `steps_offset` might led to incorrect results"
" in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
" it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
" file"
)
deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
new_config = dict(scheduler.config)
new_config["steps_offset"] = 1
scheduler._internal_dict = FrozenDict(new_config)
if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True:
deprecation_message = (
f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`."
" `clip_sample` should be set to False in the configuration file. Please make sure to update the"
" config accordingly as not setting `clip_sample` in the config might lead to incorrect results in"
" future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very"
" nice if you could open a Pull request for the `scheduler/scheduler_config.json` file"
)
deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False)
new_config = dict(scheduler.config)
new_config["clip_sample"] = False
scheduler._internal_dict = FrozenDict(new_config)
is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
version.parse(unet.config._diffusers_version).base_version
) < version.parse("0.9.0.dev0")
is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
deprecation_message = (
"The configuration file of the unet has set the default `sample_size` to smaller than"
" 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
" following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
" CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
" \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
" configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
" in the config might lead to incorrect results in future versions. If you have downloaded this"
" checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
" the `unet/config.json` file"
)
deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
new_config = dict(unet.config)
new_config["sample_size"] = 64
unet._internal_dict = FrozenDict(new_config)
self.register_modules(
vae=vae,
text_encoder=text_encoder,
tokenizer=tokenizer,
unet=unet,
# controlnet1=processors[0],
scheduler=scheduler,
)
self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
def enable_vae_slicing(self):
self.vae.enable_slicing()
def disable_vae_slicing(self):
self.vae.disable_slicing()
def enable_sequential_cpu_offload(self, gpu_id=0):
if is_accelerate_available():
else:
raise ImportError("Please install accelerate via `pip install accelerate`")
device = torch.device(f"cuda:{gpu_id}")
for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae]:
if cpu_offloaded_model is not None:
cpu_offload(cpu_offloaded_model, device)
@property
def _execution_device(self):
if self.device != torch.device("meta") or not hasattr(self.unet, "_hf_hook"):
return self.device
for module in self.unet.modules():
if (
hasattr(module, "_hf_hook")
and hasattr(module._hf_hook, "execution_device")
and module._hf_hook.execution_device is not None
):
return torch.device(module._hf_hook.execution_device)
return self.device
def _encode_prompt(self, prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt):
batch_size = len(prompt) if isinstance(prompt, list) else 1
text_inputs = self.tokenizer(
prompt,
padding="max_length",
max_length=self.tokenizer.model_max_length,
truncation=True,
return_tensors="pt",
)
text_input_ids = text_inputs.input_ids
untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids):
removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
logger.warning(
"The following part of your input was truncated because CLIP can only handle sequences up to"
f" {self.tokenizer.model_max_length} tokens: {removed_text}"
)
if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
attention_mask = text_inputs.attention_mask.to(device)
else:
attention_mask = None
text_embeddings = self.text_encoder(
text_input_ids.to(device),
attention_mask=attention_mask,
)
text_embeddings = text_embeddings[0]
# duplicate text embeddings for each generation per prompt, using mps friendly method
bs_embed, seq_len, _ = text_embeddings.shape
text_embeddings = text_embeddings.repeat(1, num_videos_per_prompt, 1)
text_embeddings = text_embeddings.view(bs_embed * num_videos_per_prompt, seq_len, -1)
# get unconditional embeddings for classifier free guidance
if do_classifier_free_guidance:
uncond_tokens: List[str]
if negative_prompt is None:
uncond_tokens = [""] * batch_size
elif type(prompt) is not type(negative_prompt):
raise TypeError(
f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
f" {type(prompt)}."
)
elif isinstance(negative_prompt, str):
uncond_tokens = [negative_prompt]
elif batch_size != len(negative_prompt):
raise ValueError(
f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
" the batch size of `prompt`."
)
else:
uncond_tokens = negative_prompt
max_length = text_input_ids.shape[-1]
uncond_input = self.tokenizer(
uncond_tokens,
padding="max_length",
max_length=max_length,
truncation=True,
return_tensors="pt",
)
if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
attention_mask = uncond_input.attention_mask.to(device)
else:
attention_mask = None
uncond_embeddings = self.text_encoder(
uncond_input.input_ids.to(device),
attention_mask=attention_mask,
)
uncond_embeddings = uncond_embeddings[0]
# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
seq_len = uncond_embeddings.shape[1]
uncond_embeddings = uncond_embeddings.repeat(1, num_videos_per_prompt, 1)
uncond_embeddings = uncond_embeddings.view(batch_size * num_videos_per_prompt, seq_len, -1)
# For classifier free guidance, we need to do two forward passes.
# Here we concatenate the unconditional and text embeddings into a single batch
# to avoid doing two forward passes
text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
return text_embeddings
def decode_latents(self, latents, rank, decoder_consistency=None):
video_length = latents.shape[2]
latents = 1 / 0.18215 * latents
latents = rearrange(latents, "b c f h w -> (b f) c h w")
# video = self.vae.decode(latents).sample
video = []
for frame_idx in tqdm(range(latents.shape[0]), disable=(rank!=0)):
if decoder_consistency is not None:
video.append(decoder_consistency(latents[frame_idx:frame_idx+1]))
else:
video.append(self.vae.decode(latents[frame_idx:frame_idx+1]).sample)
video = torch.cat(video)
video = rearrange(video, "(b f) c h w -> b c f h w", f=video_length)
video = (video / 2 + 0.5).clamp(0, 1)
# we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
video = video.cpu().float().numpy()
return video
def prepare_extra_step_kwargs(self, generator, eta):
# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
# and should be between [0, 1]
accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
extra_step_kwargs = {}
if accepts_eta:
extra_step_kwargs["eta"] = eta
# check if the scheduler accepts generator
accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
if accepts_generator:
extra_step_kwargs["generator"] = generator
return extra_step_kwargs
def check_inputs(self, prompt, height, width, callback_steps):
if not isinstance(prompt, str) and not isinstance(prompt, list):
raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
if height % 8 != 0 or width % 8 != 0:
raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
if (callback_steps is None) or (
callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
):
raise ValueError(
f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
f" {type(callback_steps)}."
)
def prepare_latents(self, batch_size, num_channels_latents, video_length, height, width, dtype, device, generator, latents=None, clip_length=16):
shape = (batch_size, num_channels_latents, clip_length, height // self.vae_scale_factor, width // self.vae_scale_factor)
if isinstance(generator, list) and len(generator) != batch_size:
raise ValueError(
f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
f" size of {batch_size}. Make sure the batch size matches the length of the generators."
)
if latents is None:
rand_device = "cpu" if device.type == "mps" else device
if isinstance(generator, list):
latents = [
torch.randn(shape, generator=generator[i], device=rand_device, dtype=dtype)
for i in range(batch_size)
]
latents = torch.cat(latents, dim=0).to(device)
else:
latents = torch.randn(shape, generator=generator, device=rand_device, dtype=dtype).to(device)
latents = latents.repeat(1, 1, video_length//clip_length, 1, 1)
else:
if latents.shape != shape:
raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
latents = latents.to(device)
# scale the initial noise by the standard deviation required by the scheduler
latents = latents * self.scheduler.init_noise_sigma
return latents
def prepare_condition(self, condition1, condition2, num_videos_per_prompt, device, dtype, do_classifier_free_guidance):
# Prepare first condition
condition1 = torch.from_numpy(condition1.copy()).to(device=device, dtype=dtype) / 255.0
condition1 = torch.stack([condition1 for _ in range(num_videos_per_prompt)], dim=0)
condition1 = rearrange(condition1, 'b f h w c -> (b f) c h w').clone()
# Prepare second condition
condition2 = torch.from_numpy(condition2.copy()).to(device=device, dtype=dtype) / 255.0
condition2 = torch.stack([condition2 for _ in range(num_videos_per_prompt)], dim=0)
condition2 = rearrange(condition2, 'b f h w c -> (b f) c h w').clone()
# Here, we're averaging the two conditions
combined_condition = (condition1*8+condition2*2)/10
if do_classifier_free_guidance:
combined_condition = torch.cat([combined_condition] * 2)
#combined_condition = torch.from_numpy(combined_condition.copy()).to(device=device, dtype=dtype)
return combined_condition
def next_step(
self,
model_output: torch.FloatTensor,
timestep: int,
x: torch.FloatTensor,
eta=0.,
verbose=False
):
"""
Inverse sampling for DDIM Inversion
"""
if verbose:
print("timestep: ", timestep)
next_step = timestep
timestep = min(timestep - self.scheduler.config.num_train_timesteps // self.scheduler.num_inference_steps, 999)
alpha_prod_t = self.scheduler.alphas_cumprod[timestep] if timestep >= 0 else self.scheduler.final_alpha_cumprod
alpha_prod_t_next = self.scheduler.alphas_cumprod[next_step]
beta_prod_t = 1 - alpha_prod_t
pred_x0 = (x - beta_prod_t**0.5 * model_output) / alpha_prod_t**0.5
pred_dir = (1 - alpha_prod_t_next)**0.5 * model_output
x_next = alpha_prod_t_next**0.5 * pred_x0 + pred_dir
return x_next, pred_x0
@torch.no_grad()
def images2latents(self, images, dtype):
"""
Convert RGB image to VAE latents
"""
device = self._execution_device
images = torch.from_numpy(images).float().to(dtype) / 127.5 - 1
images = rearrange(images, "f h w c -> f c h w").to(device)
latents = []
for frame_idx in range(images.shape[0]):
latents.append(self.vae.encode(images[frame_idx:frame_idx+1])['latent_dist'].mean * 0.18215)
latents = torch.cat(latents)
return latents
@torch.no_grad()
def invert(
self,
image: torch.Tensor,
prompt,
num_inference_steps=20,
num_actual_inference_steps=10,
eta=0.0,
return_intermediates=False,
**kwargs):
"""
Adapted from: https://github.com/Yujun-Shi/DragDiffusion/blob/main/drag_pipeline.py#L440
invert a real image into noise map with determinisc DDIM inversion
"""
device = self._execution_device
batch_size = image.shape[0]
if isinstance(prompt, list):
if batch_size == 1:
image = image.expand(len(prompt), -1, -1, -1)
elif isinstance(prompt, str):
if batch_size > 1:
prompt = [prompt] * batch_size
# text embeddings
text_input = self.tokenizer(
prompt,
padding="max_length",
max_length=77,
return_tensors="pt"
)
text_embeddings = self.text_encoder(text_input.input_ids.to(device))[0]
print("input text embeddings :", text_embeddings.shape)
# define initial latents
latents = self.images2latents(image)
print("latents shape: ", latents.shape)
# interative sampling
self.scheduler.set_timesteps(num_inference_steps)
print("Valid timesteps: ", reversed(self.scheduler.timesteps))
latents_list = [latents]
pred_x0_list = [latents]
for i, t in enumerate(tqdm(reversed(self.scheduler.timesteps), desc="DDIM Inversion")):
if num_actual_inference_steps is not None and i >= num_actual_inference_steps:
continue
model_inputs = latents
# predict the noise
# NOTE: the u-net here is UNet3D, therefore the model_inputs need to be of shape (b c f h w)
model_inputs = rearrange(model_inputs, "f c h w -> 1 c f h w")
noise_pred = self.unet(model_inputs, t, encoder_hidden_states=text_embeddings).sample
noise_pred = rearrange(noise_pred, "b c f h w -> (b f) c h w")
# compute the previous noise sample x_t-1 -> x_t
latents, pred_x0 = self.next_step(noise_pred, t, latents)
latents_list.append(latents)
pred_x0_list.append(pred_x0)
if return_intermediates:
# return the intermediate laters during inversion
return latents, latents_list
return latents
def interpolate_latents(self, latents: torch.Tensor, interpolation_factor:int, device ):
if interpolation_factor < 2:
return latents
new_latents = torch.zeros(
(latents.shape[0],latents.shape[1],((latents.shape[2]-1) * interpolation_factor)+1, latents.shape[3],latents.shape[4]),
device=latents.device,
dtype=latents.dtype,
)
org_video_length = latents.shape[2]
rate = [i/interpolation_factor for i in range(interpolation_factor)][1:]
new_index = 0
v0 = None
v1 = None
for i0,i1 in zip( range( org_video_length ),range( org_video_length )[1:] ):
v0 = latents[:,:,i0,:,:]
v1 = latents[:,:,i1,:,:]
new_latents[:,:,new_index,:,:] = v0
new_index += 1
for f in rate: | v = get_tensor_interpolation_method()(v0.to(device=device),v1.to(device=device),f) | 5 | 2023-12-15 01:22:37+00:00 | 24k |
Azure-Samples/functions-python-web-crawler | .venv/Lib/site-packages/urllib3/connection.py | [
{
"identifier": "HTTPHeaderDict",
"path": ".venv/Lib/site-packages/urllib3/_collections.py",
"snippet": "class HTTPHeaderDict(typing.MutableMapping[str, str]):\n \"\"\"\n :param headers:\n An iterable of field-value pairs. Must not contain multiple field names\n when compared case-in... | import datetime
import logging
import os
import re
import socket
import sys
import typing
import warnings
import ssl
from http.client import HTTPConnection as _HTTPConnection
from http.client import HTTPException as HTTPException # noqa: F401
from http.client import ResponseNotReady
from socket import timeout as SocketTimeout
from typing import Literal
from .response import HTTPResponse
from .util.ssl_ import _TYPE_PEER_CERT_RET_DICT
from .util.ssltransport import SSLTransport
from ._collections import HTTPHeaderDict
from .util.response import assert_header_parsing
from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT, Timeout
from .util.util import to_str
from .util.wait import wait_for_read
from ._base_connection import _TYPE_BODY
from ._base_connection import ProxyConfig as ProxyConfig
from ._base_connection import _ResponseOptions as _ResponseOptions
from ._version import __version__
from .exceptions import (
ConnectTimeoutError,
HeaderParsingError,
NameResolutionError,
NewConnectionError,
ProxyError,
SystemTimeWarning,
)
from .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection, ssl_
from .util.request import body_to_chunks
from .util.ssl_ import assert_fingerprint as _assert_fingerprint
from .util.ssl_ import (
create_urllib3_context,
is_ipaddress,
resolve_cert_reqs,
resolve_ssl_version,
ssl_wrap_socket,
)
from .util.ssl_match_hostname import CertificateError, match_hostname
from .util.url import Url
from .response import HTTPResponse | 15,841 | (
f"System time is way off (before {RECENT_DATE}). This will probably "
"lead to SSL verification errors"
),
SystemTimeWarning,
)
sock_and_verified = _ssl_wrap_socket_and_match_hostname(
sock=sock,
cert_reqs=self.cert_reqs,
ssl_version=self.ssl_version,
ssl_minimum_version=self.ssl_minimum_version,
ssl_maximum_version=self.ssl_maximum_version,
ca_certs=self.ca_certs,
ca_cert_dir=self.ca_cert_dir,
ca_cert_data=self.ca_cert_data,
cert_file=self.cert_file,
key_file=self.key_file,
key_password=self.key_password,
server_hostname=server_hostname,
ssl_context=self.ssl_context,
tls_in_tls=tls_in_tls,
assert_hostname=self.assert_hostname,
assert_fingerprint=self.assert_fingerprint,
)
self.sock = sock_and_verified.socket
self.is_verified = sock_and_verified.is_verified
# If there's a proxy to be connected to we are fully connected.
# This is set twice (once above and here) due to forwarding proxies
# not using tunnelling.
self._has_connected_to_proxy = bool(self.proxy)
def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:
"""
Establish a TLS connection to the proxy using the provided SSL context.
"""
# `_connect_tls_proxy` is called when self._tunnel_host is truthy.
proxy_config = typing.cast(ProxyConfig, self.proxy_config)
ssl_context = proxy_config.ssl_context
sock_and_verified = _ssl_wrap_socket_and_match_hostname(
sock,
cert_reqs=self.cert_reqs,
ssl_version=self.ssl_version,
ssl_minimum_version=self.ssl_minimum_version,
ssl_maximum_version=self.ssl_maximum_version,
ca_certs=self.ca_certs,
ca_cert_dir=self.ca_cert_dir,
ca_cert_data=self.ca_cert_data,
server_hostname=hostname,
ssl_context=ssl_context,
assert_hostname=proxy_config.assert_hostname,
assert_fingerprint=proxy_config.assert_fingerprint,
# Features that aren't implemented for proxies yet:
cert_file=None,
key_file=None,
key_password=None,
tls_in_tls=False,
)
self.proxy_is_verified = sock_and_verified.is_verified
return sock_and_verified.socket # type: ignore[return-value]
class _WrappedAndVerifiedSocket(typing.NamedTuple):
"""
Wrapped socket and whether the connection is
verified after the TLS handshake
"""
socket: ssl.SSLSocket | SSLTransport
is_verified: bool
def _ssl_wrap_socket_and_match_hostname(
sock: socket.socket,
*,
cert_reqs: None | str | int,
ssl_version: None | str | int,
ssl_minimum_version: int | None,
ssl_maximum_version: int | None,
cert_file: str | None,
key_file: str | None,
key_password: str | None,
ca_certs: str | None,
ca_cert_dir: str | None,
ca_cert_data: None | str | bytes,
assert_hostname: None | str | Literal[False],
assert_fingerprint: str | None,
server_hostname: str | None,
ssl_context: ssl.SSLContext | None,
tls_in_tls: bool = False,
) -> _WrappedAndVerifiedSocket:
"""Logic for constructing an SSLContext from all TLS parameters, passing
that down into ssl_wrap_socket, and then doing certificate verification
either via hostname or fingerprint. This function exists to guarantee
that both proxies and targets have the same behavior when connecting via TLS.
"""
default_ssl_context = False
if ssl_context is None:
default_ssl_context = True
context = create_urllib3_context(
ssl_version=resolve_ssl_version(ssl_version),
ssl_minimum_version=ssl_minimum_version,
ssl_maximum_version=ssl_maximum_version,
cert_reqs=resolve_cert_reqs(cert_reqs),
)
else:
context = ssl_context
context.verify_mode = resolve_cert_reqs(cert_reqs)
# In some cases, we want to verify hostnames ourselves
if (
# `ssl` can't verify fingerprints or alternate hostnames
assert_fingerprint
or assert_hostname
# assert_hostname can be set to False to disable hostname checking
or assert_hostname is False
# We still support OpenSSL 1.0.2, which prevents us from verifying
# hostnames easily: https://github.com/pyca/pyopenssl/pull/933
| from __future__ import annotations
if typing.TYPE_CHECKING:
try: # Compiled with SSL?
BaseSSLError = ssl.SSLError
except (ImportError, AttributeError):
ssl = None # type: ignore[assignment]
class BaseSSLError(BaseException): # type: ignore[no-redef]
pass
# Not a no-op, we're adding this to the namespace so it can be imported.
ConnectionError = ConnectionError
BrokenPipeError = BrokenPipeError
log = logging.getLogger(__name__)
port_by_scheme = {"http": 80, "https": 443}
# When it comes time to update this value as a part of regular maintenance
# (ie test_recent_date is failing) update it to ~6 months before the current date.
RECENT_DATE = datetime.date(2022, 1, 1)
_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]")
_HAS_SYS_AUDIT = hasattr(sys, "audit")
class HTTPConnection(_HTTPConnection):
"""
Based on :class:`http.client.HTTPConnection` but provides an extra constructor
backwards-compatibility layer between older and newer Pythons.
Additional keyword parameters are used to configure attributes of the connection.
Accepted parameters include:
- ``source_address``: Set the source address for the current connection.
- ``socket_options``: Set specific options on the underlying socket. If not specified, then
defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling
Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy.
For example, if you wish to enable TCP Keep Alive in addition to the defaults,
you might pass:
.. code-block:: python
HTTPConnection.default_socket_options + [
(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1),
]
Or you may want to disable the defaults by passing an empty list (e.g., ``[]``).
"""
default_port: typing.ClassVar[int] = port_by_scheme["http"] # type: ignore[misc]
#: Disable Nagle's algorithm by default.
#: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]``
default_socket_options: typing.ClassVar[connection._TYPE_SOCKET_OPTIONS] = [
(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
]
#: Whether this connection verifies the host's certificate.
is_verified: bool = False
#: Whether this proxy connection verified the proxy host's certificate.
# If no proxy is currently connected to the value will be ``None``.
proxy_is_verified: bool | None = None
blocksize: int
source_address: tuple[str, int] | None
socket_options: connection._TYPE_SOCKET_OPTIONS | None
_has_connected_to_proxy: bool
_response_options: _ResponseOptions | None
_tunnel_host: str | None
_tunnel_port: int | None
_tunnel_scheme: str | None
def __init__(
self,
host: str,
port: int | None = None,
*,
timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
source_address: tuple[str, int] | None = None,
blocksize: int = 16384,
socket_options: None
| (connection._TYPE_SOCKET_OPTIONS) = default_socket_options,
proxy: Url | None = None,
proxy_config: ProxyConfig | None = None,
) -> None:
super().__init__(
host=host,
port=port,
timeout=Timeout.resolve_default_timeout(timeout),
source_address=source_address,
blocksize=blocksize,
)
self.socket_options = socket_options
self.proxy = proxy
self.proxy_config = proxy_config
self._has_connected_to_proxy = False
self._response_options = None
self._tunnel_host: str | None = None
self._tunnel_port: int | None = None
self._tunnel_scheme: str | None = None
# https://github.com/python/mypy/issues/4125
# Mypy treats this as LSP violation, which is considered a bug.
# If `host` is made a property it violates LSP, because a writeable attribute is overridden with a read-only one.
# However, there is also a `host` setter so LSP is not violated.
# Potentially, a `@host.deleter` might be needed depending on how this issue will be fixed.
@property
def host(self) -> str:
"""
Getter method to remove any trailing dots that indicate the hostname is an FQDN.
In general, SSL certificates don't include the trailing dot indicating a
fully-qualified domain name, and thus, they don't validate properly when
checked against a domain name that includes the dot. In addition, some
servers may not expect to receive the trailing dot when provided.
However, the hostname with trailing dot is critical to DNS resolution; doing a
lookup with the trailing dot will properly only resolve the appropriate FQDN,
whereas a lookup without a trailing dot will search the system's search domain
list. Thus, it's important to keep the original host around for use only in
those cases where it's appropriate (i.e., when doing DNS lookup to establish the
actual TCP connection across which we're going to send HTTP requests).
"""
return self._dns_host.rstrip(".")
@host.setter
def host(self, value: str) -> None:
"""
Setter for the `host` property.
We assume that only urllib3 uses the _dns_host attribute; httplib itself
only uses `host`, and it seems reasonable that other libraries follow suit.
"""
self._dns_host = value
def _new_conn(self) -> socket.socket:
"""Establish a socket connection and set nodelay settings on it.
:return: New socket connection.
"""
try:
sock = connection.create_connection(
(self._dns_host, self.port),
self.timeout,
source_address=self.source_address,
socket_options=self.socket_options,
)
except socket.gaierror as e:
raise NameResolutionError(self.host, self, e) from e
except SocketTimeout as e:
raise ConnectTimeoutError(
self,
f"Connection to {self.host} timed out. (connect timeout={self.timeout})",
) from e
except OSError as e:
raise NewConnectionError(
self, f"Failed to establish a new connection: {e}"
) from e
# Audit hooks are only available in Python 3.8+
if _HAS_SYS_AUDIT:
sys.audit("http.client.connect", self, self.host, self.port)
return sock
def set_tunnel(
self,
host: str,
port: int | None = None,
headers: typing.Mapping[str, str] | None = None,
scheme: str = "http",
) -> None:
if scheme not in ("http", "https"):
raise ValueError(
f"Invalid proxy scheme for tunneling: {scheme!r}, must be either 'http' or 'https'"
)
super().set_tunnel(host, port=port, headers=headers)
self._tunnel_scheme = scheme
def connect(self) -> None:
self.sock = self._new_conn()
if self._tunnel_host:
# If we're tunneling it means we're connected to our proxy.
self._has_connected_to_proxy = True
# TODO: Fix tunnel so it doesn't depend on self.sock state.
self._tunnel() # type: ignore[attr-defined]
# If there's a proxy to be connected to we are fully connected.
# This is set twice (once above and here) due to forwarding proxies
# not using tunnelling.
self._has_connected_to_proxy = bool(self.proxy)
@property
def is_closed(self) -> bool:
return self.sock is None
@property
def is_connected(self) -> bool:
if self.sock is None:
return False
return not wait_for_read(self.sock, timeout=0.0)
@property
def has_connected_to_proxy(self) -> bool:
return self._has_connected_to_proxy
def close(self) -> None:
try:
super().close()
finally:
# Reset all stateful properties so connection
# can be re-used without leaking prior configs.
self.sock = None
self.is_verified = False
self.proxy_is_verified = None
self._has_connected_to_proxy = False
self._response_options = None
self._tunnel_host = None
self._tunnel_port = None
self._tunnel_scheme = None
def putrequest(
self,
method: str,
url: str,
skip_host: bool = False,
skip_accept_encoding: bool = False,
) -> None:
""""""
# Empty docstring because the indentation of CPython's implementation
# is broken but we don't want this method in our documentation.
match = _CONTAINS_CONTROL_CHAR_RE.search(method)
if match:
raise ValueError(
f"Method cannot contain non-token characters {method!r} (found at least {match.group()!r})"
)
return super().putrequest(
method, url, skip_host=skip_host, skip_accept_encoding=skip_accept_encoding
)
def putheader(self, header: str, *values: str) -> None:
""""""
if not any(isinstance(v, str) and v == SKIP_HEADER for v in values):
super().putheader(header, *values)
elif to_str(header.lower()) not in SKIPPABLE_HEADERS:
skippable_headers = "', '".join(
[str.title(header) for header in sorted(SKIPPABLE_HEADERS)]
)
raise ValueError(
f"urllib3.util.SKIP_HEADER only supports '{skippable_headers}'"
)
# `request` method's signature intentionally violates LSP.
# urllib3's API is different from `http.client.HTTPConnection` and the subclassing is only incidental.
def request( # type: ignore[override]
self,
method: str,
url: str,
body: _TYPE_BODY | None = None,
headers: typing.Mapping[str, str] | None = None,
*,
chunked: bool = False,
preload_content: bool = True,
decode_content: bool = True,
enforce_content_length: bool = True,
) -> None:
# Update the inner socket's timeout value to send the request.
# This only triggers if the connection is re-used.
if self.sock is not None:
self.sock.settimeout(self.timeout)
# Store these values to be fed into the HTTPResponse
# object later. TODO: Remove this in favor of a real
# HTTP lifecycle mechanism.
# We have to store these before we call .request()
# because sometimes we can still salvage a response
# off the wire even if we aren't able to completely
# send the request body.
self._response_options = _ResponseOptions(
request_method=method,
request_url=url,
preload_content=preload_content,
decode_content=decode_content,
enforce_content_length=enforce_content_length,
)
if headers is None:
headers = {}
header_keys = frozenset(to_str(k.lower()) for k in headers)
skip_accept_encoding = "accept-encoding" in header_keys
skip_host = "host" in header_keys
self.putrequest(
method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host
)
# Transform the body into an iterable of sendall()-able chunks
# and detect if an explicit Content-Length is doable.
chunks_and_cl = body_to_chunks(body, method=method, blocksize=self.blocksize)
chunks = chunks_and_cl.chunks
content_length = chunks_and_cl.content_length
# When chunked is explicit set to 'True' we respect that.
if chunked:
if "transfer-encoding" not in header_keys:
self.putheader("Transfer-Encoding", "chunked")
else:
# Detect whether a framing mechanism is already in use. If so
# we respect that value, otherwise we pick chunked vs content-length
# depending on the type of 'body'.
if "content-length" in header_keys:
chunked = False
elif "transfer-encoding" in header_keys:
chunked = True
# Otherwise we go off the recommendation of 'body_to_chunks()'.
else:
chunked = False
if content_length is None:
if chunks is not None:
chunked = True
self.putheader("Transfer-Encoding", "chunked")
else:
self.putheader("Content-Length", str(content_length))
# Now that framing headers are out of the way we send all the other headers.
if "user-agent" not in header_keys:
self.putheader("User-Agent", _get_default_user_agent())
for header, value in headers.items():
self.putheader(header, value)
self.endheaders()
# If we're given a body we start sending that in chunks.
if chunks is not None:
for chunk in chunks:
# Sending empty chunks isn't allowed for TE: chunked
# as it indicates the end of the body.
if not chunk:
continue
if isinstance(chunk, str):
chunk = chunk.encode("utf-8")
if chunked:
self.send(b"%x\r\n%b\r\n" % (len(chunk), chunk))
else:
self.send(chunk)
# Regardless of whether we have a body or not, if we're in
# chunked mode we want to send an explicit empty chunk.
if chunked:
self.send(b"0\r\n\r\n")
def request_chunked(
self,
method: str,
url: str,
body: _TYPE_BODY | None = None,
headers: typing.Mapping[str, str] | None = None,
) -> None:
"""
Alternative to the common request method, which sends the
body with chunked encoding and not as one block
"""
warnings.warn(
"HTTPConnection.request_chunked() is deprecated and will be removed "
"in urllib3 v2.1.0. Instead use HTTPConnection.request(..., chunked=True).",
category=DeprecationWarning,
stacklevel=2,
)
self.request(method, url, body=body, headers=headers, chunked=True)
def getresponse( # type: ignore[override]
self,
) -> HTTPResponse:
"""
Get the response from the server.
If the HTTPConnection is in the correct state, returns an instance of HTTPResponse or of whatever object is returned by the response_class variable.
If a request has not been sent or if a previous response has not be handled, ResponseNotReady is raised. If the HTTP response indicates that the connection should be closed, then it will be closed before the response is returned. When the connection is closed, the underlying socket is closed.
"""
# Raise the same error as http.client.HTTPConnection
if self._response_options is None:
raise ResponseNotReady()
# Reset this attribute for being used again.
resp_options = self._response_options
self._response_options = None
# Since the connection's timeout value may have been updated
# we need to set the timeout on the socket.
self.sock.settimeout(self.timeout)
# This is needed here to avoid circular import errors
# Get the response from http.client.HTTPConnection
httplib_response = super().getresponse()
try:
assert_header_parsing(httplib_response.msg)
except (HeaderParsingError, TypeError) as hpe:
log.warning(
"Failed to parse headers (url=%s): %s",
_url_from_connection(self, resp_options.request_url),
hpe,
exc_info=True,
)
headers = HTTPHeaderDict(httplib_response.msg.items())
response = HTTPResponse(
body=httplib_response,
headers=headers,
status=httplib_response.status,
version=httplib_response.version,
reason=httplib_response.reason,
preload_content=resp_options.preload_content,
decode_content=resp_options.decode_content,
original_response=httplib_response,
enforce_content_length=resp_options.enforce_content_length,
request_method=resp_options.request_method,
request_url=resp_options.request_url,
)
return response
class HTTPSConnection(HTTPConnection):
"""
Many of the parameters to this constructor are passed to the underlying SSL
socket by means of :py:func:`urllib3.util.ssl_wrap_socket`.
"""
default_port = port_by_scheme["https"] # type: ignore[misc]
cert_reqs: int | str | None = None
ca_certs: str | None = None
ca_cert_dir: str | None = None
ca_cert_data: None | str | bytes = None
ssl_version: int | str | None = None
ssl_minimum_version: int | None = None
ssl_maximum_version: int | None = None
assert_fingerprint: str | None = None
def __init__(
self,
host: str,
port: int | None = None,
*,
timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT,
source_address: tuple[str, int] | None = None,
blocksize: int = 16384,
socket_options: None
| (connection._TYPE_SOCKET_OPTIONS) = HTTPConnection.default_socket_options,
proxy: Url | None = None,
proxy_config: ProxyConfig | None = None,
cert_reqs: int | str | None = None,
assert_hostname: None | str | Literal[False] = None,
assert_fingerprint: str | None = None,
server_hostname: str | None = None,
ssl_context: ssl.SSLContext | None = None,
ca_certs: str | None = None,
ca_cert_dir: str | None = None,
ca_cert_data: None | str | bytes = None,
ssl_minimum_version: int | None = None,
ssl_maximum_version: int | None = None,
ssl_version: int | str | None = None, # Deprecated
cert_file: str | None = None,
key_file: str | None = None,
key_password: str | None = None,
) -> None:
super().__init__(
host,
port=port,
timeout=timeout,
source_address=source_address,
blocksize=blocksize,
socket_options=socket_options,
proxy=proxy,
proxy_config=proxy_config,
)
self.key_file = key_file
self.cert_file = cert_file
self.key_password = key_password
self.ssl_context = ssl_context
self.server_hostname = server_hostname
self.assert_hostname = assert_hostname
self.assert_fingerprint = assert_fingerprint
self.ssl_version = ssl_version
self.ssl_minimum_version = ssl_minimum_version
self.ssl_maximum_version = ssl_maximum_version
self.ca_certs = ca_certs and os.path.expanduser(ca_certs)
self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)
self.ca_cert_data = ca_cert_data
# cert_reqs depends on ssl_context so calculate last.
if cert_reqs is None:
if self.ssl_context is not None:
cert_reqs = self.ssl_context.verify_mode
else:
cert_reqs = resolve_cert_reqs(None)
self.cert_reqs = cert_reqs
def set_cert(
self,
key_file: str | None = None,
cert_file: str | None = None,
cert_reqs: int | str | None = None,
key_password: str | None = None,
ca_certs: str | None = None,
assert_hostname: None | str | Literal[False] = None,
assert_fingerprint: str | None = None,
ca_cert_dir: str | None = None,
ca_cert_data: None | str | bytes = None,
) -> None:
"""
This method should only be called once, before the connection is used.
"""
warnings.warn(
"HTTPSConnection.set_cert() is deprecated and will be removed "
"in urllib3 v2.1.0. Instead provide the parameters to the "
"HTTPSConnection constructor.",
category=DeprecationWarning,
stacklevel=2,
)
# If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also
# have an SSLContext object in which case we'll use its verify_mode.
if cert_reqs is None:
if self.ssl_context is not None:
cert_reqs = self.ssl_context.verify_mode
else:
cert_reqs = resolve_cert_reqs(None)
self.key_file = key_file
self.cert_file = cert_file
self.cert_reqs = cert_reqs
self.key_password = key_password
self.assert_hostname = assert_hostname
self.assert_fingerprint = assert_fingerprint
self.ca_certs = ca_certs and os.path.expanduser(ca_certs)
self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir)
self.ca_cert_data = ca_cert_data
def connect(self) -> None:
sock: socket.socket | ssl.SSLSocket
self.sock = sock = self._new_conn()
server_hostname: str = self.host
tls_in_tls = False
# Do we need to establish a tunnel?
if self._tunnel_host is not None:
# We're tunneling to an HTTPS origin so need to do TLS-in-TLS.
if self._tunnel_scheme == "https":
self.sock = sock = self._connect_tls_proxy(self.host, sock)
tls_in_tls = True
# If we're tunneling it means we're connected to our proxy.
self._has_connected_to_proxy = True
self._tunnel() # type: ignore[attr-defined]
# Override the host with the one we're requesting data from.
server_hostname = self._tunnel_host
if self.server_hostname is not None:
server_hostname = self.server_hostname
is_time_off = datetime.date.today() < RECENT_DATE
if is_time_off:
warnings.warn(
(
f"System time is way off (before {RECENT_DATE}). This will probably "
"lead to SSL verification errors"
),
SystemTimeWarning,
)
sock_and_verified = _ssl_wrap_socket_and_match_hostname(
sock=sock,
cert_reqs=self.cert_reqs,
ssl_version=self.ssl_version,
ssl_minimum_version=self.ssl_minimum_version,
ssl_maximum_version=self.ssl_maximum_version,
ca_certs=self.ca_certs,
ca_cert_dir=self.ca_cert_dir,
ca_cert_data=self.ca_cert_data,
cert_file=self.cert_file,
key_file=self.key_file,
key_password=self.key_password,
server_hostname=server_hostname,
ssl_context=self.ssl_context,
tls_in_tls=tls_in_tls,
assert_hostname=self.assert_hostname,
assert_fingerprint=self.assert_fingerprint,
)
self.sock = sock_and_verified.socket
self.is_verified = sock_and_verified.is_verified
# If there's a proxy to be connected to we are fully connected.
# This is set twice (once above and here) due to forwarding proxies
# not using tunnelling.
self._has_connected_to_proxy = bool(self.proxy)
def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket:
"""
Establish a TLS connection to the proxy using the provided SSL context.
"""
# `_connect_tls_proxy` is called when self._tunnel_host is truthy.
proxy_config = typing.cast(ProxyConfig, self.proxy_config)
ssl_context = proxy_config.ssl_context
sock_and_verified = _ssl_wrap_socket_and_match_hostname(
sock,
cert_reqs=self.cert_reqs,
ssl_version=self.ssl_version,
ssl_minimum_version=self.ssl_minimum_version,
ssl_maximum_version=self.ssl_maximum_version,
ca_certs=self.ca_certs,
ca_cert_dir=self.ca_cert_dir,
ca_cert_data=self.ca_cert_data,
server_hostname=hostname,
ssl_context=ssl_context,
assert_hostname=proxy_config.assert_hostname,
assert_fingerprint=proxy_config.assert_fingerprint,
# Features that aren't implemented for proxies yet:
cert_file=None,
key_file=None,
key_password=None,
tls_in_tls=False,
)
self.proxy_is_verified = sock_and_verified.is_verified
return sock_and_verified.socket # type: ignore[return-value]
class _WrappedAndVerifiedSocket(typing.NamedTuple):
"""
Wrapped socket and whether the connection is
verified after the TLS handshake
"""
socket: ssl.SSLSocket | SSLTransport
is_verified: bool
def _ssl_wrap_socket_and_match_hostname(
sock: socket.socket,
*,
cert_reqs: None | str | int,
ssl_version: None | str | int,
ssl_minimum_version: int | None,
ssl_maximum_version: int | None,
cert_file: str | None,
key_file: str | None,
key_password: str | None,
ca_certs: str | None,
ca_cert_dir: str | None,
ca_cert_data: None | str | bytes,
assert_hostname: None | str | Literal[False],
assert_fingerprint: str | None,
server_hostname: str | None,
ssl_context: ssl.SSLContext | None,
tls_in_tls: bool = False,
) -> _WrappedAndVerifiedSocket:
"""Logic for constructing an SSLContext from all TLS parameters, passing
that down into ssl_wrap_socket, and then doing certificate verification
either via hostname or fingerprint. This function exists to guarantee
that both proxies and targets have the same behavior when connecting via TLS.
"""
default_ssl_context = False
if ssl_context is None:
default_ssl_context = True
context = create_urllib3_context(
ssl_version=resolve_ssl_version(ssl_version),
ssl_minimum_version=ssl_minimum_version,
ssl_maximum_version=ssl_maximum_version,
cert_reqs=resolve_cert_reqs(cert_reqs),
)
else:
context = ssl_context
context.verify_mode = resolve_cert_reqs(cert_reqs)
# In some cases, we want to verify hostnames ourselves
if (
# `ssl` can't verify fingerprints or alternate hostnames
assert_fingerprint
or assert_hostname
# assert_hostname can be set to False to disable hostname checking
or assert_hostname is False
# We still support OpenSSL 1.0.2, which prevents us from verifying
# hostnames easily: https://github.com/pyca/pyopenssl/pull/933 | or ssl_.IS_PYOPENSSL | 18 | 2023-12-16 04:12:01+00:00 | 24k |
YaoFANGUK/video-subtitle-remover | backend/scenedetect/scene_manager.py | [
{
"identifier": "SimpleTableCell",
"path": "backend/scenedetect/_thirdparty/simpletable.py",
"snippet": "class SimpleTableCell(object):\n \"\"\"A table class to create table cells.\n\n Example:\n cell = SimpleTableCell('Hello, world!')\n \"\"\"\n\n def __init__(self, text, header=False):\... | import csv
import threading
import queue
import logging
import math
import sys
import cv2
import numpy as np
from enum import Enum
from typing import Iterable, List, Tuple, Optional, Dict, Callable, Union, TextIO
from backend.scenedetect._thirdparty.simpletable import (SimpleTableCell, SimpleTableImage, SimpleTableRow,
SimpleTable, HTMLPage)
from backend.scenedetect.platform import (tqdm, get_and_create_path, get_cv2_imwrite_params, Template)
from backend.scenedetect.frame_timecode import FrameTimecode
from backend.scenedetect.video_stream import VideoStream
from backend.scenedetect.scene_detector import SceneDetector, SparseSceneDetector
from backend.scenedetect.stats_manager import StatsManager, FrameMetricRegistered | 14,698 | '%d' % (i + 1),
'%d' % (start.get_frames() + 1),
start.get_timecode(),
'%.3f' % start.get_seconds(),
'%d' % end.get_frames(),
end.get_timecode(),
'%.3f' % end.get_seconds(),
'%d' % duration.get_frames(),
duration.get_timecode(),
'%.3f' % duration.get_seconds()
])
if image_filenames:
for image in image_filenames[i]:
row.add_cell(
SimpleTableCell(
SimpleTableImage(image, width=image_width, height=image_height)))
if i == 0:
scene_table = SimpleTable(rows=[row], header_row=header_row, css_class=css_class)
else:
scene_table.add_row(row=row)
# Write html file
page = HTMLPage()
page.add_table(timecode_table)
page.add_table(scene_table)
page.css = css
page.save(output_html_filename)
#
# TODO(v1.0): Refactor to take a SceneList object; consider moving this and save scene list
# to a better spot, or just move them to scene_list.py.
#
def save_images(scene_list: List[Tuple[FrameTimecode, FrameTimecode]],
video: VideoStream,
num_images: int = 3,
frame_margin: int = 1,
image_extension: str = 'jpg',
encoder_param: int = 95,
image_name_template: str = '$VIDEO_NAME-Scene-$SCENE_NUMBER-$IMAGE_NUMBER',
output_dir: Optional[str] = None,
show_progress: Optional[bool] = False,
scale: Optional[float] = None,
height: Optional[int] = None,
width: Optional[int] = None,
interpolation: Interpolation = Interpolation.CUBIC,
video_manager=None) -> Dict[int, List[str]]:
"""Save a set number of images from each scene, given a list of scenes
and the associated video/frame source.
Arguments:
scene_list: A list of scenes (pairs of FrameTimecode objects) returned
from calling a SceneManager's detect_scenes() method.
video: A VideoStream object corresponding to the scene list.
Note that the video will be closed/re-opened and seeked through.
num_images: Number of images to generate for each scene. Minimum is 1.
frame_margin: Number of frames to pad each scene around the beginning
and end (e.g. moves the first/last image into the scene by N frames).
Can set to 0, but will result in some video files failing to extract
the very last frame.
image_extension: Type of image to save (must be one of 'jpg', 'png', or 'webp').
encoder_param: Quality/compression efficiency, based on type of image:
'jpg' / 'webp': Quality 0-100, higher is better quality. 100 is lossless for webp.
'png': Compression from 1-9, where 9 achieves best filesize but is slower to encode.
image_name_template: Template to use when creating the images on disk. Can
use the macros $VIDEO_NAME, $SCENE_NUMBER, and $IMAGE_NUMBER. The image
extension is applied automatically as per the argument image_extension.
output_dir: Directory to output the images into. If not set, the output
is created in the working directory.
show_progress: If True, shows a progress bar if tqdm is installed.
scale: Optional factor by which to rescale saved images. A scaling factor of 1 would
not result in rescaling. A value < 1 results in a smaller saved image, while a
value > 1 results in an image larger than the original. This value is ignored if
either the height or width values are specified.
height: Optional value for the height of the saved images. Specifying both the height
and width will resize images to an exact size, regardless of aspect ratio.
Specifying only height will rescale the image to that number of pixels in height
while preserving the aspect ratio.
width: Optional value for the width of the saved images. Specifying both the width
and height will resize images to an exact size, regardless of aspect ratio.
Specifying only width will rescale the image to that number of pixels wide
while preserving the aspect ratio.
interpolation: Type of interpolation to use when resizing images.
video_manager: [DEPRECATED] DO NOT USE. For backwards compatibility only.
Returns:
Dictionary of the format { scene_num : [image_paths] }, where scene_num is the
number of the scene in scene_list (starting from 1), and image_paths is a list of
the paths to the newly saved/created images.
Raises:
ValueError: Raised if any arguments are invalid or out of range (e.g.
if num_images is negative).
"""
# TODO(v0.7): Add DeprecationWarning that `video_manager` will be removed in v0.8.
if video_manager is not None:
logger.error('`video_manager` argument is deprecated, use `video` instead.')
video = video_manager
if not scene_list:
return {}
if num_images <= 0 or frame_margin < 0:
raise ValueError()
# TODO: Validate that encoder_param is within the proper range.
# Should be between 0 and 100 (inclusive) for jpg/webp, and 1-9 for png.
imwrite_param = [get_cv2_imwrite_params()[image_extension], encoder_param
] if encoder_param is not None else []
video.reset()
# Setup flags and init progress bar if available.
completed = True
logger.info('Generating output images (%d per scene)...', num_images)
progress_bar = None
if show_progress:
progress_bar = tqdm(total=len(scene_list) * num_images, unit='images', dynamic_ncols=True)
| # -*- coding: utf-8 -*-
#
# PySceneDetect: Python-Based Video Scene Detector
# -------------------------------------------------------------------
# [ Site: https://scenedetect.com ]
# [ Docs: https://scenedetect.com/docs/ ]
# [ Github: https://github.com/Breakthrough/PySceneDetect/ ]
#
# Copyright (C) 2014-2023 Brandon Castellano <http://www.bcastell.com>.
# PySceneDetect is licensed under the BSD 3-Clause License; see the
# included LICENSE file, or visit one of the above pages for details.
#
"""``scenedetect.scene_manager`` Module
This module implements :class:`SceneManager`, coordinates running a
:mod:`SceneDetector <scenedetect.detectors>` over the frames of a video
(:mod:`VideoStream <scenedetect.video_stream>`). Video decoding is done in a separate thread to
improve performance.
This module also contains other helper functions (e.g. :func:`save_images`) which can be used to
process the resulting scene list.
===============================================================
Usage
===============================================================
The following example shows basic usage of a :class:`SceneManager`:
.. code:: python
from scenedetect import open_video, SceneManager, ContentDetector
video = open_video(video_path)
scene_manager = SceneManager()
scene_manager.add_detector(ContentDetector())
# Detect all scenes in video from current position to end.
scene_manager.detect_scenes(video)
# `get_scene_list` returns a list of start/end timecode pairs
# for each scene that was found.
scenes = scene_manager.get_scene_list()
An optional callback can also be invoked on each detected scene, for example:
.. code:: python
from scenedetect import open_video, SceneManager, ContentDetector
# Callback to invoke on the first frame of every new scene detection.
def on_new_scene(frame_img: numpy.ndarray, frame_num: int):
print("New scene found at frame %d." % frame_num)
video = open_video(test_video_file)
scene_manager = SceneManager()
scene_manager.add_detector(ContentDetector())
scene_manager.detect_scenes(video=video, callback=on_new_scene)
To use a `SceneManager` with a webcam/device or existing `cv2.VideoCapture` device, use the
:class:`VideoCaptureAdapter <scenedetect.backends.opencv.VideoCaptureAdapter>` instead of
`open_video`.
=======================================================================
Storing Per-Frame Statistics
=======================================================================
`SceneManager` can use an optional
:class:`StatsManager <scenedetect.stats_manager.StatsManager>` to save frame statistics to disk:
.. code:: python
from scenedetect import open_video, ContentDetector, SceneManager, StatsManager
video = open_video(test_video_file)
scene_manager = SceneManager(stats_manager=StatsManager())
scene_manager.add_detector(ContentDetector())
scene_manager.detect_scenes(video=video)
scene_list = scene_manager.get_scene_list()
print_scenes(scene_list=scene_list)
# Save per-frame statistics to disk.
scene_manager.stats_manager.save_to_csv(csv_file=STATS_FILE_PATH)
The statsfile can be used to find a better threshold for certain inputs, or perform statistical
analysis of the video.
"""
logger = logging.getLogger('pyscenedetect')
# TODO: This value can and should be tuned for performance improvements as much as possible,
# until accuracy falls, on a large enough dataset. This has yet to be done, but the current
# value doesn't seem to have caused any issues at least.
DEFAULT_MIN_WIDTH: int = 256
"""The default minimum width a frame will be downscaled to when calculating a downscale factor."""
MAX_FRAME_QUEUE_LENGTH: int = 4
"""Maximum number of decoded frames which can be buffered while waiting to be processed."""
PROGRESS_BAR_DESCRIPTION = 'Detected: %d | Progress'
"""Template to use for progress bar."""
class Interpolation(Enum):
"""Interpolation method used for image resizing. Based on constants defined in OpenCV."""
NEAREST = cv2.INTER_NEAREST
"""Nearest neighbor interpolation."""
LINEAR = cv2.INTER_LINEAR
"""Bilinear interpolation."""
CUBIC = cv2.INTER_CUBIC
"""Bicubic interpolation."""
AREA = cv2.INTER_AREA
"""Pixel area relation resampling. Provides moire'-free downscaling."""
LANCZOS4 = cv2.INTER_LANCZOS4
"""Lanczos interpolation over 8x8 neighborhood."""
def compute_downscale_factor(frame_width: int, effective_width: int = DEFAULT_MIN_WIDTH) -> int:
"""Get the optimal default downscale factor based on a video's resolution (currently only
the width in pixels is considered).
The resulting effective width of the video will be between frame_width and 1.5 * frame_width
pixels (e.g. if frame_width is 200, the range of effective widths will be between 200 and 300).
Arguments:
frame_width: Actual width of the video frame in pixels.
effective_width: Desired minimum width in pixels.
Returns:
int: The default downscale factor to use to achieve at least the target effective_width.
"""
assert not (frame_width < 1 or effective_width < 1)
if frame_width < effective_width:
return 1
return frame_width // effective_width
def get_scenes_from_cuts(
cut_list: Iterable[FrameTimecode],
start_pos: Union[int, FrameTimecode],
end_pos: Union[int, FrameTimecode],
base_timecode: Optional[FrameTimecode] = None,
) -> List[Tuple[FrameTimecode, FrameTimecode]]:
"""Returns a list of tuples of start/end FrameTimecodes for each scene based on a
list of detected scene cuts/breaks.
This function is called when using the :meth:`SceneManager.get_scene_list` method.
The scene list is generated from a cutting list (:meth:`SceneManager.get_cut_list`),
noting that each scene is contiguous, starting from the first to last frame of the input.
If `cut_list` is empty, the resulting scene will span from `start_pos` to `end_pos`.
Arguments:
cut_list: List of FrameTimecode objects where scene cuts/breaks occur.
base_timecode: The base_timecode of which all FrameTimecodes in the cut_list are based on.
num_frames: The number of frames, or FrameTimecode representing duration, of the video that
was processed (used to generate last scene's end time).
start_frame: The start frame or FrameTimecode of the cut list. Used to generate the first
scene's start time.
base_timecode: [DEPRECATED] DO NOT USE. For backwards compatibility only.
Returns:
List of tuples in the form (start_time, end_time), where both start_time and
end_time are FrameTimecode objects representing the exact time/frame where each
scene occupies based on the input cut_list.
"""
# TODO(v0.7): Use the warnings module to turn this into a warning.
if base_timecode is not None:
logger.error('`base_timecode` argument is deprecated has no effect.')
# Scene list, where scenes are tuples of (Start FrameTimecode, End FrameTimecode).
scene_list = []
if not cut_list:
scene_list.append((start_pos, end_pos))
return scene_list
# Initialize last_cut to the first frame we processed,as it will be
# the start timecode for the first scene in the list.
last_cut = start_pos
for cut in cut_list:
scene_list.append((last_cut, cut))
last_cut = cut
# Last scene is from last cut to end of video.
scene_list.append((last_cut, end_pos))
return scene_list
def write_scene_list(output_csv_file: TextIO,
scene_list: Iterable[Tuple[FrameTimecode, FrameTimecode]],
include_cut_list: bool = True,
cut_list: Optional[Iterable[FrameTimecode]] = None) -> None:
"""Writes the given list of scenes to an output file handle in CSV format.
Arguments:
output_csv_file: Handle to open file in write mode.
scene_list: List of pairs of FrameTimecodes denoting each scene's start/end FrameTimecode.
include_cut_list: Bool indicating if the first row should include the timecodes where
each scene starts. Should be set to False if RFC 4180 compliant CSV output is required.
cut_list: Optional list of FrameTimecode objects denoting the cut list (i.e. the frames
in the video that need to be split to generate individual scenes). If not specified,
the cut list is generated using the start times of each scene following the first one.
"""
csv_writer = csv.writer(output_csv_file, lineterminator='\n')
# If required, output the cutting list as the first row (i.e. before the header row).
if include_cut_list:
csv_writer.writerow(
["Timecode List:"] +
cut_list if cut_list else [start.get_timecode() for start, _ in scene_list[1:]])
csv_writer.writerow([
"Scene Number", "Start Frame", "Start Timecode", "Start Time (seconds)", "End Frame",
"End Timecode", "End Time (seconds)", "Length (frames)", "Length (timecode)",
"Length (seconds)"
])
for i, (start, end) in enumerate(scene_list):
duration = end - start
csv_writer.writerow([
'%d' % (i + 1),
'%d' % (start.get_frames() + 1),
start.get_timecode(),
'%.3f' % start.get_seconds(),
'%d' % end.get_frames(),
end.get_timecode(),
'%.3f' % end.get_seconds(),
'%d' % duration.get_frames(),
duration.get_timecode(),
'%.3f' % duration.get_seconds()
])
def write_scene_list_html(output_html_filename,
scene_list,
cut_list=None,
css=None,
css_class='mytable',
image_filenames=None,
image_width=None,
image_height=None):
"""Writes the given list of scenes to an output file handle in html format.
Arguments:
output_html_filename: filename of output html file
scene_list: List of pairs of FrameTimecodes denoting each scene's start/end FrameTimecode.
cut_list: Optional list of FrameTimecode objects denoting the cut list (i.e. the frames
in the video that need to be split to generate individual scenes). If not passed,
the start times of each scene (besides the 0th scene) is used instead.
css: String containing all the css information for the resulting html page.
css_class: String containing the named css class
image_filenames: dict where key i contains a list with n elements (filenames of
the n saved images from that scene)
image_width: Optional desired width of images in table in pixels
image_height: Optional desired height of images in table in pixels
"""
if not css:
css = """
table.mytable {
font-family: times;
font-size:12px;
color:#000000;
border-width: 1px;
border-color: #eeeeee;
border-collapse: collapse;
background-color: #ffffff;
width=100%;
max-width:550px;
table-layout:fixed;
}
table.mytable th {
border-width: 1px;
padding: 8px;
border-style: solid;
border-color: #eeeeee;
background-color: #e6eed6;
color:#000000;
}
table.mytable td {
border-width: 1px;
padding: 8px;
border-style: solid;
border-color: #eeeeee;
}
#code {
display:inline;
font-family: courier;
color: #3d9400;
}
#string {
display:inline;
font-weight: bold;
}
"""
# Output Timecode list
timecode_table = SimpleTable(
[["Timecode List:"] +
(cut_list if cut_list else [start.get_timecode() for start, _ in scene_list[1:]])],
css_class=css_class)
# Output list of scenes
header_row = [
"Scene Number", "Start Frame", "Start Timecode", "Start Time (seconds)", "End Frame",
"End Timecode", "End Time (seconds)", "Length (frames)", "Length (timecode)",
"Length (seconds)"
]
for i, (start, end) in enumerate(scene_list):
duration = end - start
row = SimpleTableRow([
'%d' % (i + 1),
'%d' % (start.get_frames() + 1),
start.get_timecode(),
'%.3f' % start.get_seconds(),
'%d' % end.get_frames(),
end.get_timecode(),
'%.3f' % end.get_seconds(),
'%d' % duration.get_frames(),
duration.get_timecode(),
'%.3f' % duration.get_seconds()
])
if image_filenames:
for image in image_filenames[i]:
row.add_cell(
SimpleTableCell(
SimpleTableImage(image, width=image_width, height=image_height)))
if i == 0:
scene_table = SimpleTable(rows=[row], header_row=header_row, css_class=css_class)
else:
scene_table.add_row(row=row)
# Write html file
page = HTMLPage()
page.add_table(timecode_table)
page.add_table(scene_table)
page.css = css
page.save(output_html_filename)
#
# TODO(v1.0): Refactor to take a SceneList object; consider moving this and save scene list
# to a better spot, or just move them to scene_list.py.
#
def save_images(scene_list: List[Tuple[FrameTimecode, FrameTimecode]],
video: VideoStream,
num_images: int = 3,
frame_margin: int = 1,
image_extension: str = 'jpg',
encoder_param: int = 95,
image_name_template: str = '$VIDEO_NAME-Scene-$SCENE_NUMBER-$IMAGE_NUMBER',
output_dir: Optional[str] = None,
show_progress: Optional[bool] = False,
scale: Optional[float] = None,
height: Optional[int] = None,
width: Optional[int] = None,
interpolation: Interpolation = Interpolation.CUBIC,
video_manager=None) -> Dict[int, List[str]]:
"""Save a set number of images from each scene, given a list of scenes
and the associated video/frame source.
Arguments:
scene_list: A list of scenes (pairs of FrameTimecode objects) returned
from calling a SceneManager's detect_scenes() method.
video: A VideoStream object corresponding to the scene list.
Note that the video will be closed/re-opened and seeked through.
num_images: Number of images to generate for each scene. Minimum is 1.
frame_margin: Number of frames to pad each scene around the beginning
and end (e.g. moves the first/last image into the scene by N frames).
Can set to 0, but will result in some video files failing to extract
the very last frame.
image_extension: Type of image to save (must be one of 'jpg', 'png', or 'webp').
encoder_param: Quality/compression efficiency, based on type of image:
'jpg' / 'webp': Quality 0-100, higher is better quality. 100 is lossless for webp.
'png': Compression from 1-9, where 9 achieves best filesize but is slower to encode.
image_name_template: Template to use when creating the images on disk. Can
use the macros $VIDEO_NAME, $SCENE_NUMBER, and $IMAGE_NUMBER. The image
extension is applied automatically as per the argument image_extension.
output_dir: Directory to output the images into. If not set, the output
is created in the working directory.
show_progress: If True, shows a progress bar if tqdm is installed.
scale: Optional factor by which to rescale saved images. A scaling factor of 1 would
not result in rescaling. A value < 1 results in a smaller saved image, while a
value > 1 results in an image larger than the original. This value is ignored if
either the height or width values are specified.
height: Optional value for the height of the saved images. Specifying both the height
and width will resize images to an exact size, regardless of aspect ratio.
Specifying only height will rescale the image to that number of pixels in height
while preserving the aspect ratio.
width: Optional value for the width of the saved images. Specifying both the width
and height will resize images to an exact size, regardless of aspect ratio.
Specifying only width will rescale the image to that number of pixels wide
while preserving the aspect ratio.
interpolation: Type of interpolation to use when resizing images.
video_manager: [DEPRECATED] DO NOT USE. For backwards compatibility only.
Returns:
Dictionary of the format { scene_num : [image_paths] }, where scene_num is the
number of the scene in scene_list (starting from 1), and image_paths is a list of
the paths to the newly saved/created images.
Raises:
ValueError: Raised if any arguments are invalid or out of range (e.g.
if num_images is negative).
"""
# TODO(v0.7): Add DeprecationWarning that `video_manager` will be removed in v0.8.
if video_manager is not None:
logger.error('`video_manager` argument is deprecated, use `video` instead.')
video = video_manager
if not scene_list:
return {}
if num_images <= 0 or frame_margin < 0:
raise ValueError()
# TODO: Validate that encoder_param is within the proper range.
# Should be between 0 and 100 (inclusive) for jpg/webp, and 1-9 for png.
imwrite_param = [get_cv2_imwrite_params()[image_extension], encoder_param
] if encoder_param is not None else []
video.reset()
# Setup flags and init progress bar if available.
completed = True
logger.info('Generating output images (%d per scene)...', num_images)
progress_bar = None
if show_progress:
progress_bar = tqdm(total=len(scene_list) * num_images, unit='images', dynamic_ncols=True)
| filename_template = Template(image_name_template) | 5 | 2023-10-25 02:50:01+00:00 | 24k |
EulerSearch/embedding_studio | plugins/default_fine_tuning_method.py | [
{
"identifier": "settings",
"path": "embedding_studio/core/config.py",
"snippet": "class Settings(BaseSettings):\n API_V1_STR: str = \"/api/v1\"\n SECRET_KEY: str = secrets.token_urlsafe(32)\n ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8\n BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = []\n F... | from typing import List
from sentence_transformers import SentenceTransformer
from embedding_studio.core.config import settings
from embedding_studio.core.plugin import FineTuningMethod
from embedding_studio.embeddings.data.clickstream.parsers.s3_parser import (
AWSS3ClickstreamParser,
)
from embedding_studio.embeddings.data.clickstream.search_event import (
DummyEventType,
SearchResult,
)
from embedding_studio.embeddings.data.clickstream.splitter import (
ClickstreamSessionsSplitter,
)
from embedding_studio.embeddings.data.clickstream.text_query_item import (
TextQueryItem,
)
from embedding_studio.embeddings.data.clickstream.text_query_retriever import (
TextQueryRetriever,
)
from embedding_studio.embeddings.data.loaders.s3.s3_loader import (
AWSS3DataLoader,
)
from embedding_studio.embeddings.data.storages.producers.clip import (
CLIPItemStorageProducer,
)
from embedding_studio.embeddings.data.utils.fields_normalizer import (
DatasetFieldsNormalizer,
)
from embedding_studio.embeddings.losses.prob_cosine_margin_ranking_loss import (
CosineProbMarginRankingLoss,
)
from embedding_studio.embeddings.models.text_to_image.clip import (
TextToImageCLIPModel,
)
from embedding_studio.models.clickstream.sessions import SessionWithEvents
from embedding_studio.models.plugin import FineTuningBuilder, PluginMeta
from embedding_studio.workers.fine_tuning.data.prepare_data import prepare_data
from embedding_studio.workers.fine_tuning.experiments.experiments_tracker import (
ExperimentsManager,
)
from embedding_studio.workers.fine_tuning.experiments.finetuning_settings import (
FineTuningSettings,
)
from embedding_studio.workers.fine_tuning.experiments.initial_params.clip import (
INITIAL_PARAMS,
)
from embedding_studio.workers.fine_tuning.experiments.metrics_accumulator import (
MetricsAccumulator,
) | 16,533 |
class DefaultFineTuningMethod(FineTuningMethod):
meta = PluginMeta(
name="Default Fine Tuning Method",
version="0.0.1",
description="A default fine-tuning plugin",
)
def __init__(self):
# uncomment and pass your credentials to use your own s3 bucket
# creds = {
# "role_arn": "arn:aws:iam::123456789012:role/some_data"
# "aws_access_key_id": "TESTACCESSKEIDTEST11",
# "aws_secret_access_key": "QWERTY1232qdsadfasfg5349BBdf30ekp23odk03",
# }
# self.data_loader = AWSS3DataLoader(**creds)
# with empty creds, use anonymous session
creds = {
}
self.data_loader = AWSS3DataLoader(**creds)
self.retriever = TextQueryRetriever()
self.parser = AWSS3ClickstreamParser(
|
class DefaultFineTuningMethod(FineTuningMethod):
meta = PluginMeta(
name="Default Fine Tuning Method",
version="0.0.1",
description="A default fine-tuning plugin",
)
def __init__(self):
# uncomment and pass your credentials to use your own s3 bucket
# creds = {
# "role_arn": "arn:aws:iam::123456789012:role/some_data"
# "aws_access_key_id": "TESTACCESSKEIDTEST11",
# "aws_secret_access_key": "QWERTY1232qdsadfasfg5349BBdf30ekp23odk03",
# }
# self.data_loader = AWSS3DataLoader(**creds)
# with empty creds, use anonymous session
creds = {
}
self.data_loader = AWSS3DataLoader(**creds)
self.retriever = TextQueryRetriever()
self.parser = AWSS3ClickstreamParser( | TextQueryItem, SearchResult, DummyEventType | 4 | 2023-10-31 00:33:13+00:00 | 24k |
facebookresearch/minimax | src/minimax/runners/xp_runner.py | [
{
"identifier": "EvalRunner",
"path": "src/minimax/runners/eval_runner.py",
"snippet": "class EvalRunner:\n def __init__(\n self,\n pop,\n env_names,\n env_kwargs=None,\n n_episodes=10,\n agent_idxs='*',\n render_mode=None):\n\n self.pop = pop\n... | import copy
import time
import numpy as np
import jax
import minimax.envs as envs
import minimax.models as models
import minimax.agents as agents
from functools import partial
from collections import defaultdict
from jax.sharding import Mesh, PartitionSpec as P
from jax.experimental import mesh_utils
from jax.experimental.shard_map import shard_map
from .eval_runner import EvalRunner
from .dr_runner import DRRunner
from .paired_runner import PAIREDRunner
from .plr_runner import PLRRunner
from minimax.util.rl import UEDScore, PopPLRManager | 16,361 | """
Copyright (c) Meta Platforms, Inc. and affiliates.
All rights reserved.
This source code is licensed under the license found in the
LICENSE file in the root directory of this source tree.
"""
class RunnerInfo:
def __init__(
self,
runner_cls,
is_ued=False):
self.runner_cls = runner_cls
self.is_ued = is_ued
RUNNER_INFO = {
'dr': RunnerInfo(
| """
Copyright (c) Meta Platforms, Inc. and affiliates.
All rights reserved.
This source code is licensed under the license found in the
LICENSE file in the root directory of this source tree.
"""
class RunnerInfo:
def __init__(
self,
runner_cls,
is_ued=False):
self.runner_cls = runner_cls
self.is_ued = is_ued
RUNNER_INFO = {
'dr': RunnerInfo( | runner_cls=DRRunner, | 1 | 2023-10-28 12:12:01+00:00 | 24k |
nv-tlabs/vid2player3d | poselib/poselib/skeleton/tests/test_skeleton.py | [
{
"identifier": "SkeletonTree",
"path": "poselib/poselib/skeleton/skeleton3d.py",
"snippet": "class SkeletonTree(Serializable):\n \"\"\"\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\n over a list of nodes with their names indicated by strings... | from ...core import *
from ..skeleton3d import SkeletonTree, SkeletonState, SkeletonMotion
from ...visualization.common import (
plot_skeleton_state,
plot_skeleton_motion_interactive,
)
from ...visualization.plt_plotter import Matplotlib3DPlotter
from ...visualization.skeleton_plotter_tasks import (
Draw3DSkeletonMotion,
Draw3DSkeletonState,
)
import numpy as np
import torch | 18,606 | # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
def test_skel_tree():
skel_tree = SkeletonTree.from_mjcf(
"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml",
backend="pytorch",
)
skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend="pytorch")
# assert skel_tree.to_str() == skel_tree_rec.to_str()
print(skel_tree.node_names)
print(skel_tree.local_translation)
print(skel_tree.parent_indices)
skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
skel_state = skel_state.drop_nodes_by_names(["right_hip", "left_hip"])
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
def test_skel_motion():
skel_motion = SkeletonMotion.from_file(
"/tmp/tmp.npy", backend="pytorch", load_context=True
)
plot_skeleton_motion_interactive(skel_motion)
def test_grad():
source_motion = SkeletonMotion.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\motions\\JogFlatTerrain_01_ase.npy",
backend="pytorch",
device="cuda:0",
)
source_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\fox_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\flex_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_skeleton_tree = target_tpose.skeleton_tree
joint_mapping = {
"upArm_r": "right_shoulder",
"upArm_l": "left_shoulder",
"loArm_r": "right_elbow",
"loArm_l": "left_elbow",
"upLeg_r": "right_hip",
"upLeg_l": "left_hip",
"loLeg_r": "right_knee",
"loLeg_l": "left_knee",
"foot_r": "right_ankle",
"foot_l": "left_ankle",
"hips": "pelvis",
"neckA": "neck",
"spineA": "abdomen",
}
rotation_to_target_skeleton = quat_from_angle_axis(
angle=torch.tensor(90.0).float(),
axis=torch.tensor([1, 0, 0]).float(),
degree=True,
)
target_motion = source_motion.retarget_to(
joint_mapping=joint_mapping,
source_tpose_local_rotation=source_tpose.local_rotation,
source_tpose_root_translation=source_tpose.root_translation,
target_skeleton_tree=target_skeleton_tree,
target_tpose_local_rotation=target_tpose.local_rotation,
target_tpose_root_translation=target_tpose.root_translation,
rotation_to_target_skeleton=rotation_to_target_skeleton,
scale_to_target_skeleton=0.01,
)
target_state = SkeletonState(
target_motion.tensor[800, :],
target_motion.skeleton_tree,
target_motion.is_local,
)
skeleton_tree = target_state.skeleton_tree
root_translation = target_state.root_translation
global_translation = target_state.global_translation
q = np.zeros((len(skeleton_tree), 4), dtype=np.float32)
q[..., 3] = 1.0
q = torch.from_numpy(q)
max_its = 10000
| # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
def test_skel_tree():
skel_tree = SkeletonTree.from_mjcf(
"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml",
backend="pytorch",
)
skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend="pytorch")
# assert skel_tree.to_str() == skel_tree_rec.to_str()
print(skel_tree.node_names)
print(skel_tree.local_translation)
print(skel_tree.parent_indices)
skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
skel_state = skel_state.drop_nodes_by_names(["right_hip", "left_hip"])
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
def test_skel_motion():
skel_motion = SkeletonMotion.from_file(
"/tmp/tmp.npy", backend="pytorch", load_context=True
)
plot_skeleton_motion_interactive(skel_motion)
def test_grad():
source_motion = SkeletonMotion.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\motions\\JogFlatTerrain_01_ase.npy",
backend="pytorch",
device="cuda:0",
)
source_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\fox_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_tpose = SkeletonState.from_file(
"c:\\Users\\bmatusch\\carbmimic\\data\\skeletons\\flex_tpose.npy",
backend="pytorch",
device="cuda:0",
)
target_skeleton_tree = target_tpose.skeleton_tree
joint_mapping = {
"upArm_r": "right_shoulder",
"upArm_l": "left_shoulder",
"loArm_r": "right_elbow",
"loArm_l": "left_elbow",
"upLeg_r": "right_hip",
"upLeg_l": "left_hip",
"loLeg_r": "right_knee",
"loLeg_l": "left_knee",
"foot_r": "right_ankle",
"foot_l": "left_ankle",
"hips": "pelvis",
"neckA": "neck",
"spineA": "abdomen",
}
rotation_to_target_skeleton = quat_from_angle_axis(
angle=torch.tensor(90.0).float(),
axis=torch.tensor([1, 0, 0]).float(),
degree=True,
)
target_motion = source_motion.retarget_to(
joint_mapping=joint_mapping,
source_tpose_local_rotation=source_tpose.local_rotation,
source_tpose_root_translation=source_tpose.root_translation,
target_skeleton_tree=target_skeleton_tree,
target_tpose_local_rotation=target_tpose.local_rotation,
target_tpose_root_translation=target_tpose.root_translation,
rotation_to_target_skeleton=rotation_to_target_skeleton,
scale_to_target_skeleton=0.01,
)
target_state = SkeletonState(
target_motion.tensor[800, :],
target_motion.skeleton_tree,
target_motion.is_local,
)
skeleton_tree = target_state.skeleton_tree
root_translation = target_state.root_translation
global_translation = target_state.global_translation
q = np.zeros((len(skeleton_tree), 4), dtype=np.float32)
q[..., 3] = 1.0
q = torch.from_numpy(q)
max_its = 10000
| task = Draw3DSkeletonState(task_name="", skeleton_state=target_state) | 7 | 2023-10-30 20:43:43+00:00 | 24k |
masked-spacetime-hashing/msth | MSTH/SpaceTimeHashing/permute_field.py | [
{
"identifier": "RaySamples",
"path": "nerfstudio/cameras/rays.py",
"snippet": "class RaySamples(TensorDataclass):\n \"\"\"Samples along a ray\"\"\"\n\n frustums: Frustums\n \"\"\"Frustums along ray.\"\"\"\n camera_indices: Optional[TensorType[\"bs\":..., 1]] = None\n \"\"\"Camera index.\... | import torch
import numpy as np
import tinycudann as tcnn
from typing import *
from nerfacc import ContractionType, contract
from torch.nn.parameter import Parameter
from torchtyping import TensorType
from dataclasses import dataclass, field
from nerfstudio.cameras.rays import RaySamples, Frustums, RayBundle
from nerfstudio.data.scene_box import SceneBox
from nerfstudio.field_components.activations import trunc_exp
from nerfstudio.field_components.embedding import Embedding
from nerfstudio.field_components.field_heads import FieldHeadNames
from nerfstudio.fields.base_field import Field
from nerfstudio.model_components.ray_samplers import (
ProposalNetworkSampler,
UniformSampler,
)
from nerfstudio.model_components.renderers import (
AccumulationRenderer,
DepthRenderer,
NormalsRenderer,
RGBRenderer,
)
from nerfstudio.field_components.spatial_distortions import (
SceneContraction,
SpatialDistortion,
)
from nerfstudio.model_components.losses import (
MSELoss,
distortion_loss,
interlevel_loss,
orientation_loss,
pred_normal_loss,
)
from torchmetrics import PeakSignalNoiseRatio
from torchmetrics.functional import structural_similarity_index_measure
from torchmetrics.image.lpip import LearnedPerceptualImagePatchSimilarity
from nerfstudio.field_components.spatial_distortions import SceneContraction
from nerfstudio.fields.density_fields import HashMLPDensityField
from nerfstudio.model_components.scene_colliders import NearFarCollider
from nerfstudio.model_components.shaders import NormalsShader
from nerfstudio.models.base_model import Model, ModelConfig
from nerfstudio.utils import colormaps
from nerfstudio.cameras.rays import RayBundle
from nerfstudio.engine.callbacks import (
TrainingCallback,
TrainingCallbackAttributes,
TrainingCallbackLocation,
)
from MSTH.SpaceTimeHashing.ray_samplers import ProposalNetworkSamplerSpatial, spacetime, spacetime_concat
from rich.console import Console | 17,600 |
CONSOLE = Console(width=120)
class SpaceTimeDensityFieldWithPermutation(Field):
def __init__(
self,
aabb: TensorType,
num_layers: int = 2,
hidden_dim: int = 64,
spatial_distortion: Optional[SpatialDistortion] = None,
use_linear: bool = False,
num_levels: int = 8,
max_res: int = 1024,
base_res: int = 16,
log2_hashmap_size: int = 18,
features_per_level: int = 2,
) -> None:
super().__init__()
self.register_buffer("aabb", aabb)
self.spatial_distortion = spatial_distortion
self.use_linear = use_linear
growth_factor = np.exp((np.log(max_res) - np.log(base_res)) / (num_levels - 1))
self.register_buffer("max_res", torch.tensor(max_res))
self.register_buffer("num_levels", torch.tensor(num_levels))
self.register_buffer("log2_hashmap_size", torch.tensor(log2_hashmap_size))
config = {
"encoding": {
"otype": "HashGrid",
"n_levels": num_levels,
"n_features_per_level": features_per_level,
"log2_hashmap_size": log2_hashmap_size,
"base_resolution": base_res,
"per_level_scale": growth_factor,
},
"network": {
"otype": "FullyFusedMLP",
"activation": "ReLU",
"output_activation": "None",
"n_neurons": hidden_dim,
"n_hidden_layers": num_layers - 1,
},
}
if not self.use_linear:
self.mlp_base = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.spatial_mlp_base = tcnn.NetworkWithInputEncoding(
n_input_dims=3,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.xyzt = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.xtyz = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.xytz = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.txyz = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
else:
self.encoding = tcnn.Encoding(n_input_dims=4, encoding_config=config["encoding"])
self.linear = torch.nn.Linear(self.encoding.n_output_dims, 1)
|
CONSOLE = Console(width=120)
class SpaceTimeDensityFieldWithPermutation(Field):
def __init__(
self,
aabb: TensorType,
num_layers: int = 2,
hidden_dim: int = 64,
spatial_distortion: Optional[SpatialDistortion] = None,
use_linear: bool = False,
num_levels: int = 8,
max_res: int = 1024,
base_res: int = 16,
log2_hashmap_size: int = 18,
features_per_level: int = 2,
) -> None:
super().__init__()
self.register_buffer("aabb", aabb)
self.spatial_distortion = spatial_distortion
self.use_linear = use_linear
growth_factor = np.exp((np.log(max_res) - np.log(base_res)) / (num_levels - 1))
self.register_buffer("max_res", torch.tensor(max_res))
self.register_buffer("num_levels", torch.tensor(num_levels))
self.register_buffer("log2_hashmap_size", torch.tensor(log2_hashmap_size))
config = {
"encoding": {
"otype": "HashGrid",
"n_levels": num_levels,
"n_features_per_level": features_per_level,
"log2_hashmap_size": log2_hashmap_size,
"base_resolution": base_res,
"per_level_scale": growth_factor,
},
"network": {
"otype": "FullyFusedMLP",
"activation": "ReLU",
"output_activation": "None",
"n_neurons": hidden_dim,
"n_hidden_layers": num_layers - 1,
},
}
if not self.use_linear:
self.mlp_base = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.spatial_mlp_base = tcnn.NetworkWithInputEncoding(
n_input_dims=3,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.xyzt = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.xtyz = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.xytz = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
self.txyz = tcnn.NetworkWithInputEncoding(
n_input_dims=4,
n_output_dims=1,
encoding_config=config["encoding"],
network_config=config["network"],
)
else:
self.encoding = tcnn.Encoding(n_input_dims=4, encoding_config=config["encoding"])
self.linear = torch.nn.Linear(self.encoding.n_output_dims, 1)
| def get_density(self, ray_samples: RaySamples) -> Tuple[TensorType, None]: | 0 | 2023-10-26 04:39:15+00:00 | 24k |
chenruduan/OAReactDiff | oa_reactdiff/trainer/pl_trainer.py | [
{
"identifier": "ProcessedQM9",
"path": "oa_reactdiff/dataset/qm9.py",
"snippet": "class ProcessedQM9(BaseQM9):\n def __init__(\n self,\n npz_path,\n center=True,\n pad_fragments=2,\n device=\"cpu\",\n zero_charge=False,\n remove_h=False,\n **kw... | from typing import Dict, List, Optional, Tuple
from pathlib import Path
from torch import nn
from torch.utils.data import DataLoader
from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts, StepLR
from pytorch_lightning import LightningModule
from torchmetrics.classification import (
BinaryAccuracy,
BinaryAUROC,
BinaryF1Score,
BinaryPrecision,
BinaryCohenKappa,
)
from torchmetrics import PearsonCorrCoef, SpearmanCorrCoef, MeanAbsoluteError
from oa_reactdiff.dataset import (
ProcessedQM9,
ProcessedDoubleQM9,
ProcessedTripleQM9,
ProcessedTS1x,
)
from oa_reactdiff.dynamics import EGNNDynamics, Confidence
from oa_reactdiff.diffusion._schedule import DiffSchedule, PredefinedNoiseSchedule
from oa_reactdiff.diffusion._normalizer import Normalizer, FEATURE_MAPPING
from oa_reactdiff.diffusion.en_diffusion import EnVariationalDiffusion
from oa_reactdiff.trainer._metrics import average_over_batch_metrics, pretty_print
from oa_reactdiff.analyze.rmsd import batch_rmsd
import torch
import copy
import torch.nn.functional as F
import numpy as np
import pandas as pd
import oa_reactdiff.utils.training_tools as utils | 20,037 |
PROCESS_FUNC = {
"QM9": ProcessedQM9,
"DoubleQM9": ProcessedDoubleQM9,
"TripleQM9": ProcessedTripleQM9,
"TS1x": ProcessedTS1x,
}
FILE_TYPE = {
"QM9": ".npz",
"DoubleQM9": ".npz",
"TripleQM9": ".npz",
"TS1x": ".pkl",
}
LR_SCHEDULER = {
"cos": CosineAnnealingWarmRestarts,
"step": StepLR,
}
class DDPMModule(LightningModule):
def __init__(
self,
model_config: Dict,
optimizer_config: Dict,
training_config: Dict,
node_nfs: List[int] = [9] * 3,
edge_nf: int = 4,
condition_nf: int = 3,
fragment_names: List[str] = ["inorg_node", "org_edge", "org_node"],
pos_dim: int = 3,
update_pocket_coords: bool = True,
condition_time: bool = True,
edge_cutoff: Optional[float] = None,
norm_values: Tuple = (1.0, 1.0, 1.0),
norm_biases: Tuple = (0.0, 0.0, 0.0),
noise_schedule: str = "polynomial_2",
timesteps: int = 1000,
precision: float = 1e-5,
loss_type: str = "l2",
pos_only: bool = False,
process_type: Optional[str] = None,
model: nn.Module = None,
enforce_same_encoding: Optional[List] = None,
scales: List[float] = [1.0, 1.0, 1.0],
eval_epochs: int = 20,
source: Optional[Dict] = None,
fixed_idx: Optional[List] = None,
) -> None:
super().__init__()
egnn_dynamics = EGNNDynamics(
model_config=model_config,
node_nfs=node_nfs,
edge_nf=edge_nf,
condition_nf=condition_nf,
fragment_names=fragment_names,
pos_dim=pos_dim,
update_pocket_coords=update_pocket_coords,
condition_time=condition_time,
edge_cutoff=edge_cutoff,
model=model,
enforce_same_encoding=enforce_same_encoding,
source=source,
)
normalizer = Normalizer(
norm_values=norm_values,
norm_biases=norm_biases,
pos_dim=pos_dim,
)
gamma_module = PredefinedNoiseSchedule(
noise_schedule=noise_schedule,
timesteps=timesteps,
precision=precision,
)
|
PROCESS_FUNC = {
"QM9": ProcessedQM9,
"DoubleQM9": ProcessedDoubleQM9,
"TripleQM9": ProcessedTripleQM9,
"TS1x": ProcessedTS1x,
}
FILE_TYPE = {
"QM9": ".npz",
"DoubleQM9": ".npz",
"TripleQM9": ".npz",
"TS1x": ".pkl",
}
LR_SCHEDULER = {
"cos": CosineAnnealingWarmRestarts,
"step": StepLR,
}
class DDPMModule(LightningModule):
def __init__(
self,
model_config: Dict,
optimizer_config: Dict,
training_config: Dict,
node_nfs: List[int] = [9] * 3,
edge_nf: int = 4,
condition_nf: int = 3,
fragment_names: List[str] = ["inorg_node", "org_edge", "org_node"],
pos_dim: int = 3,
update_pocket_coords: bool = True,
condition_time: bool = True,
edge_cutoff: Optional[float] = None,
norm_values: Tuple = (1.0, 1.0, 1.0),
norm_biases: Tuple = (0.0, 0.0, 0.0),
noise_schedule: str = "polynomial_2",
timesteps: int = 1000,
precision: float = 1e-5,
loss_type: str = "l2",
pos_only: bool = False,
process_type: Optional[str] = None,
model: nn.Module = None,
enforce_same_encoding: Optional[List] = None,
scales: List[float] = [1.0, 1.0, 1.0],
eval_epochs: int = 20,
source: Optional[Dict] = None,
fixed_idx: Optional[List] = None,
) -> None:
super().__init__()
egnn_dynamics = EGNNDynamics(
model_config=model_config,
node_nfs=node_nfs,
edge_nf=edge_nf,
condition_nf=condition_nf,
fragment_names=fragment_names,
pos_dim=pos_dim,
update_pocket_coords=update_pocket_coords,
condition_time=condition_time,
edge_cutoff=edge_cutoff,
model=model,
enforce_same_encoding=enforce_same_encoding,
source=source,
)
normalizer = Normalizer(
norm_values=norm_values,
norm_biases=norm_biases,
pos_dim=pos_dim,
)
gamma_module = PredefinedNoiseSchedule(
noise_schedule=noise_schedule,
timesteps=timesteps,
precision=precision,
) | schedule = DiffSchedule(gamma_module=gamma_module, norm_values=norm_values) | 6 | 2023-10-30 02:53:38+00:00 | 24k |
nv-tlabs/pacer | poselib/poselib/skeleton/tests/test_skeleton.py | [
{
"identifier": "SkeletonTree",
"path": "poselib/poselib/skeleton/skeleton3d.py",
"snippet": "class SkeletonTree(Serializable):\n \"\"\"\n A skeleton tree gives a complete description of a rigid skeleton. It describes a tree structure\n over a list of nodes with their names indicated by strings... | from ...core import *
from ..skeleton3d import SkeletonTree, SkeletonState, SkeletonMotion
from ...visualization.common import (
plot_skeleton_state,
plot_skeleton_motion_interactive,
)
from ...visualization.plt_plotter import Matplotlib3DPlotter
from ...visualization.skeleton_plotter_tasks import (
Draw3DSkeletonMotion,
Draw3DSkeletonState,
)
import numpy as np
import torch | 18,248 | # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
def test_skel_tree():
skel_tree = SkeletonTree.from_mjcf(
"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml",
backend="pytorch",
)
skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend="pytorch")
# assert skel_tree.to_str() == skel_tree_rec.to_str()
print(skel_tree.node_names)
print(skel_tree.local_translation)
print(skel_tree.parent_indices)
skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
skel_state = skel_state.drop_nodes_by_names(["right_hip", "left_hip"])
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
def test_skel_motion():
skel_motion = SkeletonMotion.from_file(
"/tmp/tmp.npy", backend="pytorch", load_context=True
)
| # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
def test_skel_tree():
skel_tree = SkeletonTree.from_mjcf(
"/home/serfcx/DL_Animation/rl_mimic/data/skeletons/humanoid_mimic_mod_2_noind.xml",
backend="pytorch",
)
skel_tree_rec = SkeletonTree.from_dict(skel_tree.to_dict(), backend="pytorch")
# assert skel_tree.to_str() == skel_tree_rec.to_str()
print(skel_tree.node_names)
print(skel_tree.local_translation)
print(skel_tree.parent_indices)
skel_state = SkeletonState.zero_pose(skeleton_tree=skel_tree)
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
skel_state = skel_state.drop_nodes_by_names(["right_hip", "left_hip"])
plot_skeleton_state(task_name="draw_skeleton", skeleton_state=skel_state)
def test_skel_motion():
skel_motion = SkeletonMotion.from_file(
"/tmp/tmp.npy", backend="pytorch", load_context=True
)
| plot_skeleton_motion_interactive(skel_motion) | 4 | 2023-10-31 20:47:12+00:00 | 24k |
Improbable-AI/dexenv | dexenv/envs/dclaw_multiobjs.py | [
{
"identifier": "DClawBase",
"path": "dexenv/envs/dclaw_base.py",
"snippet": "class DClawBase(VecTask):\n\n def __init__(self, cfg, sim_device, rl_device, graphics_device_id):\n\n self.cfg = cfg\n headless = self.cfg.headless\n self.randomize = self.cfg[\"task\"][\"randomize\"]\n... | import numpy as np
import torch
import dexenv
from gym.utils import seeding
from isaacgym import gymapi
from loguru import logger
from tqdm import tqdm
from dexenv.envs.dclaw_base import DClawBase
from dexenv.utils.common import chunker_list
from dexenv.utils.common import get_all_files_with_name
from dexenv.utils.common import load_from_pickle
from dexenv.utils.isaac_utils import load_a_goal_object_asset
from dexenv.utils.isaac_utils import load_an_object_asset
from dexenv.utils.isaac_utils import load_obj_texture | 14,864 | self.gym.create_asset_force_sensor(dclaw_asset, ft_handle, sensor_pose)
dclaw_start_pose = self.get_dclaw_start_pose()
object_start_pose = self.get_object_start_pose(dclaw_start_pose)
goal_start_pose = self.get_goal_object_start_pose(object_start_pose=object_start_pose)
self.dclaws = []
self.envs = []
self.object_init_state = []
self.hand_start_states = []
self.hand_indices = []
self.fingertip_indices = []
self.object_indices = []
self.object_cat_indices = []
self.goal_object_indices = []
self.render_camera_handles = []
if self.cfg.rgb_render:
render_cam_pose, render_cam_params = self.get_visual_render_camera_setup()
self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in
self.fingertips]
dclaw_rb_count = self.gym.get_asset_rigid_body_count(dclaw_asset)
object_rb_count = self.gym.get_asset_rigid_body_count(object_assets[0])
self.object_rb_handles = list(range(dclaw_rb_count, dclaw_rb_count + object_rb_count))
self.object_handles = []
num_object_assets = len(object_assets)
env_obj_ids = []
for i in range(self.num_envs):
# create env instance
obj_asset_id = i % num_object_assets
env_obj_ids.append(object_ids[obj_asset_id])
env_ptr = self.gym.create_env(
self.sim, lower, upper, num_per_row
)
if self.aggregate_mode >= 1:
# compute aggregate size
obj_num_bodies = self.gym.get_asset_rigid_body_count(object_assets[obj_asset_id])
obj_num_shapes = self.gym.get_asset_rigid_shape_count(object_assets[obj_asset_id])
max_agg_bodies = self.num_dclaw_bodies + obj_num_bodies * 2 + 1
max_agg_shapes = self.num_dclaw_shapes + obj_num_shapes * 2 + 1
self.gym.begin_aggregate(env_ptr, max_agg_bodies, max_agg_shapes, True)
self.create_hand_actor(env_ptr=env_ptr,
dclaw_asset=dclaw_asset,
dclaw_start_pose=dclaw_start_pose,
dclaw_dof_props=dclaw_dof_props,
env_id=i)
# add object
object_handle = self.gym.create_actor(env_ptr, object_assets[obj_asset_id],
object_start_pose, "object", i, 0, 1)
self.object_handles.append(object_handle)
self.object_init_state.append([object_start_pose.p.x, object_start_pose.p.y, object_start_pose.p.z,
object_start_pose.r.x, object_start_pose.r.y, object_start_pose.r.z,
object_start_pose.r.w,
0, 0, 0, 0, 0, 0])
object_idx = self.gym.get_actor_index(env_ptr, object_handle, gymapi.DOMAIN_SIM)
self.object_indices.append(object_idx)
self.object_cat_indices.append(object_cat_ids[obj_asset_id])
# add goal object
goal_handle = self.gym.create_actor(env_ptr, goal_assets[obj_asset_id],
goal_start_pose, "goal_object",
i + self.num_envs,
0, 2)
goal_object_idx = self.gym.get_actor_index(env_ptr, goal_handle, gymapi.DOMAIN_SIM)
self.goal_object_indices.append(goal_object_idx)
if self.cfg.obj.load_texture:
self.gym.set_rigid_body_texture(env_ptr,
object_handle,
0,
gymapi.MESH_VISUAL_AND_COLLISION,
object_textures[obj_asset_id]
)
self.gym.set_rigid_body_texture(env_ptr,
goal_handle,
0,
gymapi.MESH_VISUAL_AND_COLLISION,
object_textures[obj_asset_id]
)
else:
color = np.array([179, 193, 134]) / 255.0
self.gym.set_rigid_body_color(
env_ptr, object_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))
self.gym.set_rigid_body_color(
env_ptr, goal_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))
table_handle = self.gym.create_actor(env_ptr, table_asset, table_pose, "table", i, 0)
self.gym.set_rigid_body_color(env_ptr, table_handle, 0, gymapi.MESH_VISUAL,
gymapi.Vec3(180 / 255., 180 / 255., 180 / 255.))
if self.cfg.rgb_render:
render_camera_handle = self.create_camera(render_cam_pose, env_ptr, render_cam_params)
self.render_camera_handles.append(render_camera_handle[0])
if self.aggregate_mode > 0:
self.gym.end_aggregate(env_ptr)
self.envs.append(env_ptr)
object_rb_props = self.gym.get_actor_rigid_body_properties(env_ptr, object_handle)
self.object_rb_masses = [prop.mass for prop in object_rb_props]
self.setup_torch_states()
self.env_obj_ids = torch.LongTensor(env_obj_ids).to(self.device).view(-1, 1)
self.object_cat_indices = torch.LongTensor(self.object_cat_indices).to(self.device).view(-1, 1)
def parse_obj_dataset(self, dataset):
asset_root = dexenv.LIB_PATH.joinpath('assets')
split_dataset_name = dataset.split(':')
if len(split_dataset_name) == 1:
dataset_path = asset_root.joinpath(dataset, 'train')
else:
target_object = split_dataset_name[1]
dataset_path = asset_root.joinpath(split_dataset_name[0], 'train', target_object)
logger.warning(f'Dataset path:{dataset_path}')
|
class DclawMultiObjs(DClawBase):
def __init__(self, cfg, sim_device, rl_device, graphics_device_id):
self.set_random_gen()
self.object_urdfs, self.dataset_path, self.obj_name_to_cat_id = self.parse_obj_dataset(cfg.obj.dataset)
self.num_objects = len(self.object_urdfs)
logger.info(f'Object urdf root path:{self.dataset_path}.')
logger.info(f'Number of available objects:{self.num_objects}.')
super().__init__(cfg=cfg,
sim_device=sim_device,
rl_device=rl_device,
graphics_device_id=graphics_device_id)
def set_random_gen(self, seed=12345):
self.np_random, seed = seeding.np_random(seed)
def _create_envs(self, num_envs, spacing, num_per_row):
lower = gymapi.Vec3(-spacing, -spacing, 0.0)
upper = gymapi.Vec3(spacing, spacing, spacing)
asset_root = dexenv.LIB_PATH.joinpath('assets', 'dclaw').as_posix()
dclaw_asset, dclaw_dof_props = self.get_dclaw_asset(asset_root=asset_root)
# load manipulated object and goal assets
table_asset = self.get_table_asset()
table_pose = self.get_table_pose()
object_assets, goal_assets, object_ids, object_textures, object_ptds, object_cat_ids = self.load_object_asset()
# create fingertip force sensors, if needed
if self.obs_type == "full_state":
sensor_pose = gymapi.Transform()
for ft_handle in self.fingertip_handles:
self.gym.create_asset_force_sensor(dclaw_asset, ft_handle, sensor_pose)
dclaw_start_pose = self.get_dclaw_start_pose()
object_start_pose = self.get_object_start_pose(dclaw_start_pose)
goal_start_pose = self.get_goal_object_start_pose(object_start_pose=object_start_pose)
self.dclaws = []
self.envs = []
self.object_init_state = []
self.hand_start_states = []
self.hand_indices = []
self.fingertip_indices = []
self.object_indices = []
self.object_cat_indices = []
self.goal_object_indices = []
self.render_camera_handles = []
if self.cfg.rgb_render:
render_cam_pose, render_cam_params = self.get_visual_render_camera_setup()
self.fingertip_handles = [self.gym.find_asset_rigid_body_index(dclaw_asset, name) for name in
self.fingertips]
dclaw_rb_count = self.gym.get_asset_rigid_body_count(dclaw_asset)
object_rb_count = self.gym.get_asset_rigid_body_count(object_assets[0])
self.object_rb_handles = list(range(dclaw_rb_count, dclaw_rb_count + object_rb_count))
self.object_handles = []
num_object_assets = len(object_assets)
env_obj_ids = []
for i in range(self.num_envs):
# create env instance
obj_asset_id = i % num_object_assets
env_obj_ids.append(object_ids[obj_asset_id])
env_ptr = self.gym.create_env(
self.sim, lower, upper, num_per_row
)
if self.aggregate_mode >= 1:
# compute aggregate size
obj_num_bodies = self.gym.get_asset_rigid_body_count(object_assets[obj_asset_id])
obj_num_shapes = self.gym.get_asset_rigid_shape_count(object_assets[obj_asset_id])
max_agg_bodies = self.num_dclaw_bodies + obj_num_bodies * 2 + 1
max_agg_shapes = self.num_dclaw_shapes + obj_num_shapes * 2 + 1
self.gym.begin_aggregate(env_ptr, max_agg_bodies, max_agg_shapes, True)
self.create_hand_actor(env_ptr=env_ptr,
dclaw_asset=dclaw_asset,
dclaw_start_pose=dclaw_start_pose,
dclaw_dof_props=dclaw_dof_props,
env_id=i)
# add object
object_handle = self.gym.create_actor(env_ptr, object_assets[obj_asset_id],
object_start_pose, "object", i, 0, 1)
self.object_handles.append(object_handle)
self.object_init_state.append([object_start_pose.p.x, object_start_pose.p.y, object_start_pose.p.z,
object_start_pose.r.x, object_start_pose.r.y, object_start_pose.r.z,
object_start_pose.r.w,
0, 0, 0, 0, 0, 0])
object_idx = self.gym.get_actor_index(env_ptr, object_handle, gymapi.DOMAIN_SIM)
self.object_indices.append(object_idx)
self.object_cat_indices.append(object_cat_ids[obj_asset_id])
# add goal object
goal_handle = self.gym.create_actor(env_ptr, goal_assets[obj_asset_id],
goal_start_pose, "goal_object",
i + self.num_envs,
0, 2)
goal_object_idx = self.gym.get_actor_index(env_ptr, goal_handle, gymapi.DOMAIN_SIM)
self.goal_object_indices.append(goal_object_idx)
if self.cfg.obj.load_texture:
self.gym.set_rigid_body_texture(env_ptr,
object_handle,
0,
gymapi.MESH_VISUAL_AND_COLLISION,
object_textures[obj_asset_id]
)
self.gym.set_rigid_body_texture(env_ptr,
goal_handle,
0,
gymapi.MESH_VISUAL_AND_COLLISION,
object_textures[obj_asset_id]
)
else:
color = np.array([179, 193, 134]) / 255.0
self.gym.set_rigid_body_color(
env_ptr, object_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))
self.gym.set_rigid_body_color(
env_ptr, goal_handle, 0, gymapi.MESH_VISUAL, gymapi.Vec3(*color))
table_handle = self.gym.create_actor(env_ptr, table_asset, table_pose, "table", i, 0)
self.gym.set_rigid_body_color(env_ptr, table_handle, 0, gymapi.MESH_VISUAL,
gymapi.Vec3(180 / 255., 180 / 255., 180 / 255.))
if self.cfg.rgb_render:
render_camera_handle = self.create_camera(render_cam_pose, env_ptr, render_cam_params)
self.render_camera_handles.append(render_camera_handle[0])
if self.aggregate_mode > 0:
self.gym.end_aggregate(env_ptr)
self.envs.append(env_ptr)
object_rb_props = self.gym.get_actor_rigid_body_properties(env_ptr, object_handle)
self.object_rb_masses = [prop.mass for prop in object_rb_props]
self.setup_torch_states()
self.env_obj_ids = torch.LongTensor(env_obj_ids).to(self.device).view(-1, 1)
self.object_cat_indices = torch.LongTensor(self.object_cat_indices).to(self.device).view(-1, 1)
def parse_obj_dataset(self, dataset):
asset_root = dexenv.LIB_PATH.joinpath('assets')
split_dataset_name = dataset.split(':')
if len(split_dataset_name) == 1:
dataset_path = asset_root.joinpath(dataset, 'train')
else:
target_object = split_dataset_name[1]
dataset_path = asset_root.joinpath(split_dataset_name[0], 'train', target_object)
logger.warning(f'Dataset path:{dataset_path}') | urdf_files = get_all_files_with_name(dataset_path, name='model.urdf') | 2 | 2023-10-25 17:22:41+00:00 | 24k |
ai-safety-foundation/sparse_autoencoder | sparse_autoencoder/activation_resampler/tests/test_activation_resampler.py | [
{
"identifier": "ActivationResampler",
"path": "sparse_autoencoder/activation_resampler/activation_resampler.py",
"snippet": "class ActivationResampler:\n \"\"\"Activation resampler.\n\n Collates the number of times each neuron fires over a set number of learned activation vectors,\n and then p... | from jaxtyping import Float, Int64
from torch import Tensor
from torch.nn import Parameter
from sparse_autoencoder.activation_resampler.activation_resampler import ActivationResampler
from sparse_autoencoder.activation_store.base_store import ActivationStore
from sparse_autoencoder.activation_store.tensor_store import TensorActivationStore
from sparse_autoencoder.autoencoder.model import SparseAutoencoder, SparseAutoencoderConfig
from sparse_autoencoder.loss.decoded_activations_l2 import L2ReconstructionLoss
from sparse_autoencoder.loss.learned_activations_l1 import LearnedActivationsL1Loss
from sparse_autoencoder.loss.reducer import LossReducer
from sparse_autoencoder.tensor_types import Axis
import pytest
import torch | 16,481 | """Tests for the resample_neurons module."""
DEFAULT_N_ACTIVATIONS_STORE: int = 100
DEFAULT_N_INPUT_FEATURES: int = 3
DEFAULT_N_LEARNED_FEATURES: int = 5
DEFAULT_N_COMPONENTS: int = 2
@pytest.fixture()
def full_activation_store() -> ActivationStore:
"""Create a dummy activation store, pre-populated with data."""
store = TensorActivationStore(
max_items=DEFAULT_N_ACTIVATIONS_STORE,
n_components=DEFAULT_N_COMPONENTS,
n_neurons=DEFAULT_N_INPUT_FEATURES,
)
store.fill_with_test_data(
batch_size=DEFAULT_N_ACTIVATIONS_STORE,
input_features=DEFAULT_N_INPUT_FEATURES,
n_batches=1,
n_components=DEFAULT_N_COMPONENTS,
)
return store
@pytest.fixture()
def autoencoder_model() -> SparseAutoencoder:
"""Create a dummy autoencoder model."""
return SparseAutoencoder(
| """Tests for the resample_neurons module."""
DEFAULT_N_ACTIVATIONS_STORE: int = 100
DEFAULT_N_INPUT_FEATURES: int = 3
DEFAULT_N_LEARNED_FEATURES: int = 5
DEFAULT_N_COMPONENTS: int = 2
@pytest.fixture()
def full_activation_store() -> ActivationStore:
"""Create a dummy activation store, pre-populated with data."""
store = TensorActivationStore(
max_items=DEFAULT_N_ACTIVATIONS_STORE,
n_components=DEFAULT_N_COMPONENTS,
n_neurons=DEFAULT_N_INPUT_FEATURES,
)
store.fill_with_test_data(
batch_size=DEFAULT_N_ACTIVATIONS_STORE,
input_features=DEFAULT_N_INPUT_FEATURES,
n_batches=1,
n_components=DEFAULT_N_COMPONENTS,
)
return store
@pytest.fixture()
def autoencoder_model() -> SparseAutoencoder:
"""Create a dummy autoencoder model."""
return SparseAutoencoder( | SparseAutoencoderConfig( | 4 | 2023-10-27 07:37:15+00:00 | 24k |
OATML-Markslab/ProteinNPT | scripts/train.py | [
{
"identifier": "ProteinNPTModel",
"path": "proteinnpt/model.py",
"snippet": "class ProteinNPTModel(nn.Module):\n def __init__(self, args, alphabet):\n super().__init__()\n self.args = args\n self.alphabet = alphabet\n self.alphabet_size = len(alphabet)\n self.paddi... | import os,gc
import json
import argparse
import random
import numpy as np
import pandas as pd
import wandb
import torch
import proteinnpt,baselines,utils
from collections import defaultdict
from proteinnpt.model import ProteinNPTModel
from baselines.model import AugmentedPropertyPredictor
from utils.esm.data import Alphabet
from utils.tranception.model_pytorch import get_tranception_tokenizer
from utils.data_utils import get_train_val_test_data, standardize, pnpt_count_non_nan, pnpt_spearmanr
from utils.msa_utils import process_MSA
from utils.model_utils import Trainer | 21,137 | if args.model_type=="ProteinNPT": normalization = test_eval_results['eval_num_masked_targets'][target_name]
test_logs['Test loss '+str(target_name)+' per seq.'] = test_eval_results['eval_target_prediction_loss_dict'][target_name] / normalization
with open(logs_folder+os.sep+"test_performance_by_fold_"+args.model_name_suffix+".csv", "a") as perf_tracker:
if os.path.getsize(logs_folder+os.sep+"test_performance_by_fold_"+args.model_name_suffix+".csv") == 0:
header="fold_index,model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss"
for target_name in target_names: header += (",loss_" + target_name + ",Spearman_" + target_name + ",num_obs_Spearman_" + target_name)
perf_tracker.write(header+"\n")
perf = ",".join([str(x) for x in perf_list]) + "," + str(round(test_logs['Test total loss per seq.'],5))
for target_name in target_names: perf += ("," + str(round(test_logs['Test loss '+str(target_name)+' per seq.'],5)) +","+str(spearmans[target_name])+","+str(num_obs_spearmans[target_name]))
perf_tracker.write(perf+"\n")
return test_logs, spearmans
def log_performance_all_folds(args,target_names,all_test_predictions_across_folds,spearmans_across_folds,perf_list,logs_folder=None):
if not os.path.exists(args.output_scores_location + os.sep + 'all_aggregated_predictions'): os.mkdir(args.output_scores_location + os.sep + 'all_aggregated_predictions')
all_test_predictions_across_folds = pd.DataFrame.from_dict(all_test_predictions_across_folds)
all_test_predictions_across_folds.to_csv(args.output_scores_location + os.sep + 'all_aggregated_predictions' + os.sep + model_name_prefix + ".csv", index=False)
if logs_folder is None:
dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
logs_folder = dir_path+os.sep+'output'
if not os.path.exists(logs_folder): os.mkdir(logs_folder)
with open(logs_folder+os.sep+"test_performance_overall_"+perf_list[2]+".csv", "a") as overall_perf:
if os.path.getsize(logs_folder+os.sep+"test_performance_overall_"+perf_list[2]+".csv") == 0:
header = "model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss"
for target_name in target_names: header += (",loss_" + target_name + ",Spearman_" + target_name + ",Std_dev_Spearman_" + target_name + ",num_obs_Spearman_" + target_name + ",standardized_loss_" + target_name + ",standardized_Spearman_" + target_name)
overall_perf.write(header+"\n")
perf = ",".join([str(x) for x in perf_list[1:]]) #Remove fold_index from perf_list
for target_name in target_names:
missing_mask = np.isnan(all_test_predictions_across_folds['labels_'+target_name]) | np.equal(all_test_predictions_across_folds['labels_'+target_name],-100)
MSE = ((all_test_predictions_across_folds['predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()
spearman = pnpt_spearmanr(all_test_predictions_across_folds['predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])
num_obs_spearman = pnpt_count_non_nan(all_test_predictions_across_folds['labels_'+target_name])
MSE_standardized = ((all_test_predictions_across_folds['fold_standardized_predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()
spearman_standardized = pnpt_spearmanr(all_test_predictions_across_folds['fold_standardized_predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])
spearman_std_dev = np.array(spearmans_across_folds[target_name]).std()
perf += ("," + str(MSE) +","+str(spearman) + ","+ str(spearman_std_dev) + "," + str(num_obs_spearman) + "," + str(MSE_standardized) +","+str(spearman_standardized))
overall_perf.write(perf+"\n")
def main(args):
# Set random seeds
torch.manual_seed(args.seed)
np.random.seed(args.seed)
random.seed(args.seed)
# target_names are the true targets we want to predict. target_names_input also includes auxiliary labels (as used in ProteinNPT)
target_names = [x for x in args.target_config.keys() if args.target_config[x]["in_NPT_loss"]]
target_names_input = args.target_config.keys()
num_targets = len(target_names)
num_targets_input = len(target_names_input)
print("We want to predict {} target(s): {}".format(num_targets, ' and '.join(target_names)))
if num_targets_input > num_targets: print("We leverage {} target(s) and auxiliary labels: {}".format(num_targets_input, ' and '.join(target_names_input)))
assay_reference_file = pd.read_csv(args.assay_reference_file_location)
assay_id=assay_reference_file["DMS_id"][args.assay_index]
args.seq_len = int(assay_reference_file["seq_len"][assay_reference_file["DMS_id"]==assay_id].values[0])
args.MSA_seq_len = int(assay_reference_file["MSA_len"][assay_reference_file["DMS_id"]==assay_id].values[0])
print("Training model for assay: {}, where the test_fold index is: {}".format(assay_id, args.test_fold_index))
args.save_model_checkpoint = not args.do_not_save_model_checkpoint
args.frozen_embedding_parameters = not args.fine_tune_model_embedding_parameters
if args.model_type=="MSA_Transformer_pred": assert args.num_MSA_sequences_per_training_instance==args.num_MSA_sequences_per_eval_instance, "MSA_Transformer_pred only supports same size of MSA for train and eval"
effective_batch_size = args.gradient_accumulation * args.training_num_assay_sequences_per_batch_per_gpu
print("Effective batch size is {}".format(effective_batch_size))
model_hypers = [args.aa_embeddings,args.target_prediction_model,args.target_prediction_head,args.augmentation,args.frozen_embedding_parameters,args.dropout,args.weight_decay, \
args.early_stopping_patience, args.use_validation_set, args.training_num_assay_sequences_per_batch_per_gpu, args.eval_num_sequences_to_score_per_batch_per_gpu, args.eval_num_training_sequences_per_batch_per_gpu, \
args.eval_training_sequences_sampling_method, args.num_MSA_sequences_per_training_instance, args.embed_dim, args.ffn_embed_dim, args.attention_heads, args.conv_kernel_size, args.num_protein_npt_layers]
model_hypers_str = ','.join([str(x) for x in model_hypers])
model_name_prefix = '_'.join([str(x) for x in [args.model_type,assay_id,"_".join(target_names_input),args.fold_variable_name,'embed_'+args.aa_embeddings,'head_'+str(args.target_prediction_model),'aug_'+str(args.augmentation_short), \
'froz_'+str(args.frozen_embedding_parameters),'drop_'+str(args.dropout),'val_'+str(args.use_validation_set),args.model_name_suffix]])
model_name = model_name_prefix + "_fold-" + str(args.test_fold_index)
if not os.path.exists(args.model_location+os.sep+model_name): os.mkdir(args.model_location+os.sep+model_name)
with open(args.model_location+os.sep+model_name+os.sep+'training_arguments', 'w') as f:
json.dump(args.__dict__, f, indent=2)
print("Model name: "+model_name)
assay_file_name = assay_reference_file["DMS_filename"][assay_reference_file["DMS_id"]==assay_id].values[0] # File name of main assay used during training (if single property, this is also the only assay). Retrieved embeddings are always for this assay.
args.sequence_embeddings_location = args.sequence_embeddings_folder + os.sep + assay_file_name.split(".csv")[0] + '.h5' if args.sequence_embeddings_folder else None
print("Sequence embeddings: {}".format(args.sequence_embeddings_location))
if args.use_wandb: wandb.login()
# Create & initiate model
alphabet = get_tranception_tokenizer() if args.aa_embeddings=="Tranception" else Alphabet.from_architecture("msa_transformer")
if args.model_type=="ProteinNPT":
model = ProteinNPTModel(args, alphabet)
elif args.model_type in ["MSA_Transformer_pred", "ESM1v_pred", "Tranception_pred", "TranceptEVE_pred", "Linear_Embedding_pred", "DeepSequence_pred"]:
model = AugmentedPropertyPredictor(args, alphabet)
if args.frozen_embedding_parameters and args.aa_embeddings in ["MSA_Transformer", "ESM1v", "Tranception"]:
for para in model.aa_embedding.parameters():
para.requires_grad = False
# List of assays involved in training
if num_targets==1:
# Single property prediction
assay_file_names={
target_names[0]: assay_file_name
}
if "zero_shot_fitness_predictions" in target_names_input: assay_file_names["zero_shot_fitness_predictions"] = assay_file_name
else:
# Multiple properties prediction
assay_file_names={}
for target in target_names_input:
if target=="zero_shot_fitness_predictions":
assay_file_names[target] = assay_file_name # The name of the zero-shot prediction file matches that of the main assay
else:
assay_file_names[target] = assay_reference_file[target][assay_reference_file["DMS_id"]==assay_id].values[0]
# Load training, val and test data
UniProt_id = assay_reference_file["UniProt_ID"][assay_reference_file["DMS_id"]==assay_id].values[0]
MSA_filename = assay_reference_file["MSA_filename"][assay_reference_file["DMS_id"]==assay_id].values[0]
MSA_weights_filename = assay_reference_file["weight_file_name"][assay_reference_file["DMS_id"]==assay_id].values[0]
MSA_start_position = int(assay_reference_file["MSA_start"][assay_reference_file["DMS_id"]==assay_id].values[0])
MSA_end_position = int(assay_reference_file["MSA_end"][assay_reference_file["DMS_id"]==assay_id].values[0])
train_data, val_data, test_data, target_processing = get_train_val_test_data(args = args, assay_file_names = assay_file_names)
MSA_sequences, MSA_weights = process_MSA(args, MSA_filename, MSA_weights_filename) if args.aa_embeddings=="MSA_Transformer" else (None, None)
if args.use_wandb:
combined_dict = {**vars(args), "parameter_count": sum(p.numel() for p in model.parameters()), "world_size": world_size, "assay_id": assay_id, "UniProt_id": UniProt_id}
wandb.init(project=os.getenv("WANDB_PROJECT"), config=combined_dict, name=model_name, dir=args.wandb_location, save_code=True)
# Define trainer
|
def setup_config_and_paths(args):
# All parameters that are not defined by end user are fetched from the config file
if args.model_config_location is not None:
args.main_config=json.load(open(args.model_config_location))
for key in args.main_config:
if args.__dict__[key] is None:
args.__dict__[key] = args.main_config[key]
# File paths config
for local_path in ['embedding_model_location','MSA_data_folder','MSA_weight_data_folder','path_to_hhfilter']:
if getattr(args, local_path): setattr(args, local_path, args.data_location + os.sep + getattr(args, local_path))
if not os.path.exists(args.data_location + os.sep + 'model_predictions'): os.mkdir(args.data_location + os.sep + 'model_predictions')
if not os.path.exists(args.data_location + os.sep + 'checkpoint'): os.mkdir(args.data_location + os.sep + 'checkpoint')
args.output_scores_location = args.data_location + os.sep + 'model_predictions' + os.sep + args.model_name_suffix
if not os.path.exists(args.output_scores_location): os.mkdir(args.output_scores_location)
args.model_location = args.data_location + os.sep + 'checkpoint' + os.sep + args.model_name_suffix
if not os.path.exists(args.model_location): os.mkdir(args.model_location)
# Target config
args.target_config=json.load(open(args.target_config_location))
zero_shot_predictions_mapping={
"MSA_Transformer_pred": "MSA_Transformer_ensemble",
"ESM1v_pred": "ESM1v_ensemble",
"TranceptEVE_pred": "TranceptEVE_L",
"Tranception_pred": "Tranception_L",
"DeepSequence_pred": "DeepSequence_ensemble"
}
if args.model_type=="ProteinNPT": zero_shot_predictions_mapping["ProteinNPT"]=zero_shot_predictions_mapping[args.aa_embeddings+"_pred"]
if args.augmentation=="zero_shot_fitness_predictions_auxiliary_labels": # Add auxiliary label to target_config
assert args.zero_shot_fitness_predictions_location is not None, "Location of zero-shot fitness predictions to use as auxiliary labels not properly referenced"
print("Using zero-shot fitness predictions as auxiliary labels")
args.target_config["zero_shot_fitness_predictions"] = {
"type": "continuous",
"dim": 1,
"var_name": zero_shot_predictions_mapping[args.model_type], #Select the relevant model for zero-shot fitness predictions
"location": args.zero_shot_fitness_predictions_location,
"in_NPT_loss": False,
"main_target": False
}
args.augmentation_short="auxiliary"
elif args.augmentation=="zero_shot_fitness_predictions_covariate": # Will use zero-shot fitness predictions as an additional model covariate
assert args.zero_shot_fitness_predictions_location is not None, "Location of zero-shot fitness predictions to use as model covariate not properly referenced"
print("Using zero-shot fitness predictions as covariate")
args.augmentation_short="covariate"
args.zero_shot_fitness_predictions_var_name = zero_shot_predictions_mapping[args.model_type]
else:
args.augmentation_short="none"
for target_index,target in enumerate(args.target_config):
if "location" not in args.target_config[target].keys(): # Note: the case of zero-shot fitness predictions is already handled above if present
if args.assay_location is not None: # We passed at least one path for the assay location
num_targets = [x for x in args.target_config.keys() if args.target_config[x]["in_NPT_loss"]]
if len(args.assay_location) > 1:
assert len(args.assay_location)==num_targets, "Trying to predict {} targets, but only referencing {} distinct paths for them.".format(num_targets,len(args.assay_location))
args.target_config[target]["location"] = args.assay_location[target_index]
print("Location used for target {} if {}".format(target,args.assay_location[target_index]))
else:
args.target_config[target]["location"] = args.assay_location[0]
print("Location used for target {} if {}".format(target,args.assay_location[0]))
else:
print("Assay location not provided. Defaulting to location for single substitutions fitness assays: {}".format(args.data_location + os.sep + 'data/fitness/substitutions_singles'))
args.target_config[target]["location"] = args.data_location + os.sep + 'data/fitness/substitutions_singles'
return args
def log_performance_fold(args,target_names,test_eval_results,trainer_final_status,perf_list,logs_folder=None):
test_logs = {'total_training_steps': trainer_final_status['total_training_steps'], 'total_training_epochs': trainer_final_status['total_training_epochs'], 'total_train_time': trainer_final_status['total_train_time']}
if logs_folder is None:
dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
logs_folder = dir_path+os.sep+'output'
if not os.path.exists(logs_folder): os.mkdir(logs_folder)
if args.model_type=="ProteinNPT":
normalization = 0
for target_name in target_names: normalization += test_eval_results['eval_num_masked_targets'][target_name]
else:
normalization = test_eval_results['eval_num_predicted_targets']
test_logs['Test total loss per seq.'] = test_eval_results['eval_total_loss'] / normalization
spearmans = {target_name: pnpt_spearmanr(test_eval_results['output_scores']['predictions_'+target_name], test_eval_results['output_scores']['labels_'+target_name]) for target_name in target_names}
num_obs_spearmans = {target_name: pnpt_count_non_nan(test_eval_results['output_scores']['labels_'+target_name]) for target_name in target_names}
for target_name in target_names:
print("Spearman {} target: {}".format(target_name,spearmans[target_name]))
test_logs['Test Spearman '+target_name] = spearmans[target_name]
if args.model_type=="ProteinNPT": normalization = test_eval_results['eval_num_masked_targets'][target_name]
test_logs['Test loss '+str(target_name)+' per seq.'] = test_eval_results['eval_target_prediction_loss_dict'][target_name] / normalization
with open(logs_folder+os.sep+"test_performance_by_fold_"+args.model_name_suffix+".csv", "a") as perf_tracker:
if os.path.getsize(logs_folder+os.sep+"test_performance_by_fold_"+args.model_name_suffix+".csv") == 0:
header="fold_index,model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss"
for target_name in target_names: header += (",loss_" + target_name + ",Spearman_" + target_name + ",num_obs_Spearman_" + target_name)
perf_tracker.write(header+"\n")
perf = ",".join([str(x) for x in perf_list]) + "," + str(round(test_logs['Test total loss per seq.'],5))
for target_name in target_names: perf += ("," + str(round(test_logs['Test loss '+str(target_name)+' per seq.'],5)) +","+str(spearmans[target_name])+","+str(num_obs_spearmans[target_name]))
perf_tracker.write(perf+"\n")
return test_logs, spearmans
def log_performance_all_folds(args,target_names,all_test_predictions_across_folds,spearmans_across_folds,perf_list,logs_folder=None):
if not os.path.exists(args.output_scores_location + os.sep + 'all_aggregated_predictions'): os.mkdir(args.output_scores_location + os.sep + 'all_aggregated_predictions')
all_test_predictions_across_folds = pd.DataFrame.from_dict(all_test_predictions_across_folds)
all_test_predictions_across_folds.to_csv(args.output_scores_location + os.sep + 'all_aggregated_predictions' + os.sep + model_name_prefix + ".csv", index=False)
if logs_folder is None:
dir_path = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
logs_folder = dir_path+os.sep+'output'
if not os.path.exists(logs_folder): os.mkdir(logs_folder)
with open(logs_folder+os.sep+"test_performance_overall_"+perf_list[2]+".csv", "a") as overall_perf:
if os.path.getsize(logs_folder+os.sep+"test_performance_overall_"+perf_list[2]+".csv") == 0:
header = "model_type,model_name_suffix,targets,assay_id,UniProt_id,fold_variable_name,total_training_steps,total_training_epochs,aa_embeddings,target_prediction_model,target_prediction_head,augmentation,frozen_embedding_parameters,dropout,weight_decay,early_stopping_patience,use_validation_set,training_num_assay_sequences_per_batch_per_gpu,eval_num_sequences_to_score_per_batch_per_gpu,eval_num_training_sequences_per_batch_per_gpu,eval_training_sequences_sampling_method,num_MSA_sequences_per_training_instance,embed_dim,ffn_embed_dim,attention_heads,conv_kernel_size,num_protein_npt_layers,total_loss"
for target_name in target_names: header += (",loss_" + target_name + ",Spearman_" + target_name + ",Std_dev_Spearman_" + target_name + ",num_obs_Spearman_" + target_name + ",standardized_loss_" + target_name + ",standardized_Spearman_" + target_name)
overall_perf.write(header+"\n")
perf = ",".join([str(x) for x in perf_list[1:]]) #Remove fold_index from perf_list
for target_name in target_names:
missing_mask = np.isnan(all_test_predictions_across_folds['labels_'+target_name]) | np.equal(all_test_predictions_across_folds['labels_'+target_name],-100)
MSE = ((all_test_predictions_across_folds['predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()
spearman = pnpt_spearmanr(all_test_predictions_across_folds['predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])
num_obs_spearman = pnpt_count_non_nan(all_test_predictions_across_folds['labels_'+target_name])
MSE_standardized = ((all_test_predictions_across_folds['fold_standardized_predictions_'+target_name][~missing_mask] - all_test_predictions_across_folds['labels_'+target_name][~missing_mask])**2).mean()
spearman_standardized = pnpt_spearmanr(all_test_predictions_across_folds['fold_standardized_predictions_'+target_name], all_test_predictions_across_folds['labels_'+target_name])
spearman_std_dev = np.array(spearmans_across_folds[target_name]).std()
perf += ("," + str(MSE) +","+str(spearman) + ","+ str(spearman_std_dev) + "," + str(num_obs_spearman) + "," + str(MSE_standardized) +","+str(spearman_standardized))
overall_perf.write(perf+"\n")
def main(args):
# Set random seeds
torch.manual_seed(args.seed)
np.random.seed(args.seed)
random.seed(args.seed)
# target_names are the true targets we want to predict. target_names_input also includes auxiliary labels (as used in ProteinNPT)
target_names = [x for x in args.target_config.keys() if args.target_config[x]["in_NPT_loss"]]
target_names_input = args.target_config.keys()
num_targets = len(target_names)
num_targets_input = len(target_names_input)
print("We want to predict {} target(s): {}".format(num_targets, ' and '.join(target_names)))
if num_targets_input > num_targets: print("We leverage {} target(s) and auxiliary labels: {}".format(num_targets_input, ' and '.join(target_names_input)))
assay_reference_file = pd.read_csv(args.assay_reference_file_location)
assay_id=assay_reference_file["DMS_id"][args.assay_index]
args.seq_len = int(assay_reference_file["seq_len"][assay_reference_file["DMS_id"]==assay_id].values[0])
args.MSA_seq_len = int(assay_reference_file["MSA_len"][assay_reference_file["DMS_id"]==assay_id].values[0])
print("Training model for assay: {}, where the test_fold index is: {}".format(assay_id, args.test_fold_index))
args.save_model_checkpoint = not args.do_not_save_model_checkpoint
args.frozen_embedding_parameters = not args.fine_tune_model_embedding_parameters
if args.model_type=="MSA_Transformer_pred": assert args.num_MSA_sequences_per_training_instance==args.num_MSA_sequences_per_eval_instance, "MSA_Transformer_pred only supports same size of MSA for train and eval"
effective_batch_size = args.gradient_accumulation * args.training_num_assay_sequences_per_batch_per_gpu
print("Effective batch size is {}".format(effective_batch_size))
model_hypers = [args.aa_embeddings,args.target_prediction_model,args.target_prediction_head,args.augmentation,args.frozen_embedding_parameters,args.dropout,args.weight_decay, \
args.early_stopping_patience, args.use_validation_set, args.training_num_assay_sequences_per_batch_per_gpu, args.eval_num_sequences_to_score_per_batch_per_gpu, args.eval_num_training_sequences_per_batch_per_gpu, \
args.eval_training_sequences_sampling_method, args.num_MSA_sequences_per_training_instance, args.embed_dim, args.ffn_embed_dim, args.attention_heads, args.conv_kernel_size, args.num_protein_npt_layers]
model_hypers_str = ','.join([str(x) for x in model_hypers])
model_name_prefix = '_'.join([str(x) for x in [args.model_type,assay_id,"_".join(target_names_input),args.fold_variable_name,'embed_'+args.aa_embeddings,'head_'+str(args.target_prediction_model),'aug_'+str(args.augmentation_short), \
'froz_'+str(args.frozen_embedding_parameters),'drop_'+str(args.dropout),'val_'+str(args.use_validation_set),args.model_name_suffix]])
model_name = model_name_prefix + "_fold-" + str(args.test_fold_index)
if not os.path.exists(args.model_location+os.sep+model_name): os.mkdir(args.model_location+os.sep+model_name)
with open(args.model_location+os.sep+model_name+os.sep+'training_arguments', 'w') as f:
json.dump(args.__dict__, f, indent=2)
print("Model name: "+model_name)
assay_file_name = assay_reference_file["DMS_filename"][assay_reference_file["DMS_id"]==assay_id].values[0] # File name of main assay used during training (if single property, this is also the only assay). Retrieved embeddings are always for this assay.
args.sequence_embeddings_location = args.sequence_embeddings_folder + os.sep + assay_file_name.split(".csv")[0] + '.h5' if args.sequence_embeddings_folder else None
print("Sequence embeddings: {}".format(args.sequence_embeddings_location))
if args.use_wandb: wandb.login()
# Create & initiate model
alphabet = get_tranception_tokenizer() if args.aa_embeddings=="Tranception" else Alphabet.from_architecture("msa_transformer")
if args.model_type=="ProteinNPT":
model = ProteinNPTModel(args, alphabet)
elif args.model_type in ["MSA_Transformer_pred", "ESM1v_pred", "Tranception_pred", "TranceptEVE_pred", "Linear_Embedding_pred", "DeepSequence_pred"]:
model = AugmentedPropertyPredictor(args, alphabet)
if args.frozen_embedding_parameters and args.aa_embeddings in ["MSA_Transformer", "ESM1v", "Tranception"]:
for para in model.aa_embedding.parameters():
para.requires_grad = False
# List of assays involved in training
if num_targets==1:
# Single property prediction
assay_file_names={
target_names[0]: assay_file_name
}
if "zero_shot_fitness_predictions" in target_names_input: assay_file_names["zero_shot_fitness_predictions"] = assay_file_name
else:
# Multiple properties prediction
assay_file_names={}
for target in target_names_input:
if target=="zero_shot_fitness_predictions":
assay_file_names[target] = assay_file_name # The name of the zero-shot prediction file matches that of the main assay
else:
assay_file_names[target] = assay_reference_file[target][assay_reference_file["DMS_id"]==assay_id].values[0]
# Load training, val and test data
UniProt_id = assay_reference_file["UniProt_ID"][assay_reference_file["DMS_id"]==assay_id].values[0]
MSA_filename = assay_reference_file["MSA_filename"][assay_reference_file["DMS_id"]==assay_id].values[0]
MSA_weights_filename = assay_reference_file["weight_file_name"][assay_reference_file["DMS_id"]==assay_id].values[0]
MSA_start_position = int(assay_reference_file["MSA_start"][assay_reference_file["DMS_id"]==assay_id].values[0])
MSA_end_position = int(assay_reference_file["MSA_end"][assay_reference_file["DMS_id"]==assay_id].values[0])
train_data, val_data, test_data, target_processing = get_train_val_test_data(args = args, assay_file_names = assay_file_names)
MSA_sequences, MSA_weights = process_MSA(args, MSA_filename, MSA_weights_filename) if args.aa_embeddings=="MSA_Transformer" else (None, None)
if args.use_wandb:
combined_dict = {**vars(args), "parameter_count": sum(p.numel() for p in model.parameters()), "world_size": world_size, "assay_id": assay_id, "UniProt_id": UniProt_id}
wandb.init(project=os.getenv("WANDB_PROJECT"), config=combined_dict, name=model_name, dir=args.wandb_location, save_code=True)
# Define trainer | trainer = Trainer( | 9 | 2023-10-28 11:41:05+00:00 | 24k |
CVHub520/yolov5_obb | detect.py | [
{
"identifier": "DetectMultiBackend",
"path": "models/common.py",
"snippet": "class DetectMultiBackend(nn.Module):\n # YOLOv5 MultiBackend class for python inference on various backends\n def __init__(self, weights='yolov5s.pt', device=None, dnn=False):\n # Usage:\n # PyTorch: ... | import argparse
import os
import sys
import cv2
import torch
import torch.backends.cudnn as cudnn
from pathlib import Path
from models.common import DetectMultiBackend
from utils.datasets import IMG_FORMATS, VID_FORMATS, LoadImages, LoadStreams
from utils.general import (LOGGER, check_file, check_img_size, check_imshow, check_requirements, colorstr,
increment_path, non_max_suppression, non_max_suppression_obb, print_args, scale_coords, scale_polys, strip_optimizer, xyxy2xywh)
from utils.plots import Annotator, colors, save_one_box
from utils.torch_utils import select_device, time_sync
from utils.rboxs_utils import poly2rbox, rbox2poly | 15,619 | # pred: list*(n, [xylsθ, conf, cls]) θ ∈ [-pi/2, pi/2)
pred = non_max_suppression_obb(pred, conf_thres, iou_thres, classes, agnostic_nms, multi_label=True, max_det=max_det)
dt[2] += time_sync() - t3
# Second-stage classifier (optional)
# pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
# Process predictions
for i, det in enumerate(pred): # per image
pred_poly = rbox2poly(det[:, :5]) # (n, [x1 y1 x2 y2 x3 y3 x4 y4])
seen += 1
if webcam: # batch_size >= 1
p, im0, frame = path[i], im0s[i].copy(), dataset.count
s += f'{i}: '
else:
p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # im.jpg
txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # im.txt
s += '%gx%g ' % im.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
imc = im0.copy() if save_crop else im0 # for save_crop
annotator = Annotator(im0, line_width=line_thickness, example=str(names))
if len(det):
# Rescale polys from img_size to im0 size
# det[:, :4] = scale_coords(im.shape[2:], det[:, :4], im0.shape).round()
pred_poly = scale_polys(im.shape[2:], pred_poly, im0.shape)
det = torch.cat((pred_poly, det[:, -2:]), dim=1) # (n, [poly conf cls])
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
# Write results
for *poly, conf, cls in reversed(det):
if save_txt: # Write to file
# xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
poly = poly.tolist()
line = (cls, *poly, conf) if save_conf else (cls, *poly) # label format
with open(txt_path + '.txt', 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
if save_img or save_crop or view_img: # Add poly to image
c = int(cls) # integer class
label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')
# annotator.box_label(xyxy, label, color=colors(c, True))
annotator.poly_label(poly, label, color=colors(c, True))
if save_crop: # Yolov5-obb doesn't support it yet
# save_one_box(xyxy, imc, file=save_dir / 'crops' / names[c] / f'{p.stem}.jpg', BGR=True)
pass
# Print time (inference-only)
LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)')
# Stream results
im0 = annotator.result()
if view_img:
cv2.imshow(str(p), im0)
cv2.waitKey(1) # 1 millisecond
# Save results (image with detections)
if save_img:
if dataset.mode == 'image':
cv2.imwrite(save_path, im0)
else: # 'video' or 'stream'
if vid_path[i] != save_path: # new video
vid_path[i] = save_path
if isinstance(vid_writer[i], cv2.VideoWriter):
vid_writer[i].release() # release previous video writer
if vid_cap: # video
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
else: # stream
fps, w, h = 30, im0.shape[1], im0.shape[0]
save_path += '.mp4'
vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
vid_writer[i].write(im0)
# Print results
t = tuple(x / seen * 1E3 for x in dt) # speeds per image
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t)
if save_txt or save_img:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}{s}")
if update:
strip_optimizer(weights) # update model (to fix SourceChangeWarning)
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs/train/yolov5n_DroneVehicle/weights/best.pt', help='model path(s)')
parser.add_argument('--source', type=str, default='/media/test/4d846cae-2315-4928-8d1b-ca6d3a61a3c6/DroneVehicle/val/raw/images/', help='file/dir/URL/glob, 0 for webcam')
parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[840], help='inference size h,w')
parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')
parser.add_argument('--iou-thres', type=float, default=0.2, help='NMS IoU threshold')
parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')
parser.add_argument('--device', default='3', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--view-img', action='store_true', help='show results')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--save-crop', action='store_true', help='save cropped prediction boxes')
parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')
parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--visualize', action='store_true', help='visualize features')
parser.add_argument('--update', action='store_true', help='update all models')
parser.add_argument('--project', default='runs/detect', help='save results to project/name')
parser.add_argument('--name', default='exp', help='save results to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
parser.add_argument('--line-thickness', default=2, type=int, help='bounding box thickness (pixels)')
parser.add_argument('--hide-labels', default=False, action='store_true', help='hide labels')
parser.add_argument('--hide-conf', default=False, action='store_true', help='hide confidences')
parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
opt = parser.parse_args()
opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand
| # YOLOv5 🚀 by Ultralytics, GPL-3.0 license
"""
Run inference on images, videos, directories, streams, etc.
Usage:
$ python path/to/detect.py --weights yolov5s.pt --source 0 # webcam
img.jpg # image
vid.mp4 # video
path/ # directory
path/*.jpg # glob
'https://youtu.be/Zgi9g1ksQHc' # YouTube
'rtsp://example.com/media.mp4' # RTSP, RTMP, HTTP stream
"""
FILE = Path(__file__).resolve()
ROOT = FILE.parents[0] # YOLOv5 root directory
if str(ROOT) not in sys.path:
sys.path.append(str(ROOT)) # add ROOT to PATH
ROOT = Path(os.path.relpath(ROOT, Path.cwd())) # relative
@torch.no_grad()
def run(weights=ROOT / 'yolov5s.pt', # model.pt path(s)
source=ROOT / 'data/images', # file/dir/URL/glob, 0 for webcam
imgsz=(640, 640), # inference size (height, width)
conf_thres=0.25, # confidence threshold
iou_thres=0.45, # NMS IOU threshold
max_det=1000, # maximum detections per image
device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
view_img=False, # show results
save_txt=False, # save results to *.txt
save_conf=False, # save confidences in --save-txt labels
save_crop=False, # save cropped prediction boxes
nosave=False, # do not save images/videos
classes=None, # filter by class: --class 0, or --class 0 2 3
agnostic_nms=False, # class-agnostic NMS
augment=False, # augmented inference
visualize=False, # visualize features
update=False, # update all models
project=ROOT / 'runs/detect', # save results to project/name
name='exp', # save results to project/name
exist_ok=False, # existing project/name ok, do not increment
line_thickness=3, # bounding box thickness (pixels)
hide_labels=False, # hide labels
hide_conf=False, # hide confidences
half=False, # use FP16 half-precision inference
dnn=False, # use OpenCV DNN for ONNX inference
):
source = str(source)
save_img = not nosave and not source.endswith('.txt') # save inference images
is_file = Path(source).suffix[1:] in (IMG_FORMATS + VID_FORMATS)
is_url = source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://'))
webcam = source.isnumeric() or source.endswith('.txt') or (is_url and not is_file)
if is_url and is_file:
source = check_file(source) # download
# Directories
save_dir = increment_path(Path(project) / name, exist_ok=exist_ok) # increment run
(save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True) # make dir
# Load model
device = select_device(device)
model = DetectMultiBackend(weights, device=device, dnn=dnn)
stride, names, pt, jit, onnx, engine = model.stride, model.names, model.pt, model.jit, model.onnx, model.engine
imgsz = check_img_size(imgsz, s=stride) # check image size
# Half
half &= (pt or jit or engine) and device.type != 'cpu' # half precision only supported by PyTorch on CUDA
if pt or jit:
model.model.half() if half else model.model.float()
# Dataloader
if webcam:
view_img = check_imshow()
cudnn.benchmark = True # set True to speed up constant image size inference
dataset = LoadStreams(source, img_size=imgsz, stride=stride, auto=pt)
bs = len(dataset) # batch_size
else:
dataset = LoadImages(source, img_size=imgsz, stride=stride, auto=pt)
bs = 1 # batch_size
vid_path, vid_writer = [None] * bs, [None] * bs
# Run inference
model.warmup(imgsz=(1, 3, *imgsz), half=half) # warmup
dt, seen = [0.0, 0.0, 0.0], 0
for path, im, im0s, vid_cap, s in dataset:
t1 = time_sync()
im = torch.from_numpy(im).to(device)
im = im.half() if half else im.float() # uint8 to fp16/32
im /= 255 # 0 - 255 to 0.0 - 1.0
if len(im.shape) == 3:
im = im[None] # expand for batch dim
t2 = time_sync()
dt[0] += t2 - t1
# Inference
visualize = increment_path(save_dir / Path(path).stem, mkdir=True) if visualize else False
pred = model(im, augment=augment, visualize=visualize)
t3 = time_sync()
dt[1] += t3 - t2
# NMS
# pred: list*(n, [xylsθ, conf, cls]) θ ∈ [-pi/2, pi/2)
pred = non_max_suppression_obb(pred, conf_thres, iou_thres, classes, agnostic_nms, multi_label=True, max_det=max_det)
dt[2] += time_sync() - t3
# Second-stage classifier (optional)
# pred = utils.general.apply_classifier(pred, classifier_model, im, im0s)
# Process predictions
for i, det in enumerate(pred): # per image
pred_poly = rbox2poly(det[:, :5]) # (n, [x1 y1 x2 y2 x3 y3 x4 y4])
seen += 1
if webcam: # batch_size >= 1
p, im0, frame = path[i], im0s[i].copy(), dataset.count
s += f'{i}: '
else:
p, im0, frame = path, im0s.copy(), getattr(dataset, 'frame', 0)
p = Path(p) # to Path
save_path = str(save_dir / p.name) # im.jpg
txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # im.txt
s += '%gx%g ' % im.shape[2:] # print string
gn = torch.tensor(im0.shape)[[1, 0, 1, 0]] # normalization gain whwh
imc = im0.copy() if save_crop else im0 # for save_crop
annotator = Annotator(im0, line_width=line_thickness, example=str(names))
if len(det):
# Rescale polys from img_size to im0 size
# det[:, :4] = scale_coords(im.shape[2:], det[:, :4], im0.shape).round()
pred_poly = scale_polys(im.shape[2:], pred_poly, im0.shape)
det = torch.cat((pred_poly, det[:, -2:]), dim=1) # (n, [poly conf cls])
# Print results
for c in det[:, -1].unique():
n = (det[:, -1] == c).sum() # detections per class
s += f"{n} {names[int(c)]}{'s' * (n > 1)}, " # add to string
# Write results
for *poly, conf, cls in reversed(det):
if save_txt: # Write to file
# xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist() # normalized xywh
poly = poly.tolist()
line = (cls, *poly, conf) if save_conf else (cls, *poly) # label format
with open(txt_path + '.txt', 'a') as f:
f.write(('%g ' * len(line)).rstrip() % line + '\n')
if save_img or save_crop or view_img: # Add poly to image
c = int(cls) # integer class
label = None if hide_labels else (names[c] if hide_conf else f'{names[c]} {conf:.2f}')
# annotator.box_label(xyxy, label, color=colors(c, True))
annotator.poly_label(poly, label, color=colors(c, True))
if save_crop: # Yolov5-obb doesn't support it yet
# save_one_box(xyxy, imc, file=save_dir / 'crops' / names[c] / f'{p.stem}.jpg', BGR=True)
pass
# Print time (inference-only)
LOGGER.info(f'{s}Done. ({t3 - t2:.3f}s)')
# Stream results
im0 = annotator.result()
if view_img:
cv2.imshow(str(p), im0)
cv2.waitKey(1) # 1 millisecond
# Save results (image with detections)
if save_img:
if dataset.mode == 'image':
cv2.imwrite(save_path, im0)
else: # 'video' or 'stream'
if vid_path[i] != save_path: # new video
vid_path[i] = save_path
if isinstance(vid_writer[i], cv2.VideoWriter):
vid_writer[i].release() # release previous video writer
if vid_cap: # video
fps = vid_cap.get(cv2.CAP_PROP_FPS)
w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
else: # stream
fps, w, h = 30, im0.shape[1], im0.shape[0]
save_path += '.mp4'
vid_writer[i] = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
vid_writer[i].write(im0)
# Print results
t = tuple(x / seen * 1E3 for x in dt) # speeds per image
LOGGER.info(f'Speed: %.1fms pre-process, %.1fms inference, %.1fms NMS per image at shape {(1, 3, *imgsz)}' % t)
if save_txt or save_img:
s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
LOGGER.info(f"Results saved to {colorstr('bold', save_dir)}{s}")
if update:
strip_optimizer(weights) # update model (to fix SourceChangeWarning)
def parse_opt():
parser = argparse.ArgumentParser()
parser.add_argument('--weights', nargs='+', type=str, default=ROOT / 'runs/train/yolov5n_DroneVehicle/weights/best.pt', help='model path(s)')
parser.add_argument('--source', type=str, default='/media/test/4d846cae-2315-4928-8d1b-ca6d3a61a3c6/DroneVehicle/val/raw/images/', help='file/dir/URL/glob, 0 for webcam')
parser.add_argument('--imgsz', '--img', '--img-size', nargs='+', type=int, default=[840], help='inference size h,w')
parser.add_argument('--conf-thres', type=float, default=0.25, help='confidence threshold')
parser.add_argument('--iou-thres', type=float, default=0.2, help='NMS IoU threshold')
parser.add_argument('--max-det', type=int, default=1000, help='maximum detections per image')
parser.add_argument('--device', default='3', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
parser.add_argument('--view-img', action='store_true', help='show results')
parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
parser.add_argument('--save-crop', action='store_true', help='save cropped prediction boxes')
parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --classes 0, or --classes 0 2 3')
parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
parser.add_argument('--augment', action='store_true', help='augmented inference')
parser.add_argument('--visualize', action='store_true', help='visualize features')
parser.add_argument('--update', action='store_true', help='update all models')
parser.add_argument('--project', default='runs/detect', help='save results to project/name')
parser.add_argument('--name', default='exp', help='save results to project/name')
parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
parser.add_argument('--line-thickness', default=2, type=int, help='bounding box thickness (pixels)')
parser.add_argument('--hide-labels', default=False, action='store_true', help='hide labels')
parser.add_argument('--hide-conf', default=False, action='store_true', help='hide confidences')
parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
parser.add_argument('--dnn', action='store_true', help='use OpenCV DNN for ONNX inference')
opt = parser.parse_args()
opt.imgsz *= 2 if len(opt.imgsz) == 1 else 1 # expand | print_args(FILE.stem, opt) | 14 | 2023-10-31 06:06:41+00:00 | 24k |
serengil/LightPHE | lightphe/models/Ciphertext.py | [
{
"identifier": "Homomorphic",
"path": "lightphe/models/Homomorphic.py",
"snippet": "class Homomorphic(ABC):\n keys: dict\n plaintext_modulo: int\n ciphertext_modulo: int\n\n @abstractmethod\n def generate_keys(self, key_size: int, s: Optional[int] = None) -> dict:\n pass\n\n @a... | from typing import Union
from lightphe.models.Homomorphic import Homomorphic
from lightphe.models.Algorithm import Algorithm
from lightphe.cryptosystems.RSA import RSA
from lightphe.cryptosystems.ElGamal import ElGamal
from lightphe.cryptosystems.Paillier import Paillier
from lightphe.cryptosystems.DamgardJurik import DamgardJurik
from lightphe.cryptosystems.OkamotoUchiyama import OkamotoUchiyama
from lightphe.cryptosystems.Benaloh import Benaloh
from lightphe.cryptosystems.NaccacheStern import NaccacheStern
from lightphe.cryptosystems.GoldwasserMicali import GoldwasserMicali
from lightphe.cryptosystems.EllipticCurveElGamal import EllipticCurveElGamal
from lightphe.commons import phe_utils
from lightphe.commons.logger import Logger | 18,005 |
logger = Logger(module="lightphe/models/Ciphertext.py")
# pylint: disable=too-few-public-methods, no-else-return
class Ciphertext:
def __init__(self, algorithm_name: str, keys: dict, value: Union[int, tuple, list]):
self.algorithm_name = algorithm_name
self.keys = keys
self.value = value
if algorithm_name == Algorithm.RSA:
cs = RSA(keys=keys)
elif algorithm_name == Algorithm.ElGamal:
cs = ElGamal(keys=keys)
elif algorithm_name == Algorithm.ExponentialElGamal:
cs = ElGamal(keys=keys, exponential=True)
elif algorithm_name == Algorithm.EllipticCurveElGamal:
cs = EllipticCurveElGamal(keys=keys)
elif algorithm_name == Algorithm.Paillier:
cs = Paillier(keys=keys)
elif algorithm_name == Algorithm.DamgardJurik:
cs = DamgardJurik(keys=keys)
elif algorithm_name == Algorithm.OkamotoUchiyama:
cs = OkamotoUchiyama(keys=keys)
elif algorithm_name == Algorithm.Benaloh:
cs = Benaloh(keys=keys)
elif algorithm_name == Algorithm.NaccacheStern:
cs = NaccacheStern(keys=keys)
elif algorithm_name == Algorithm.GoldwasserMicali:
cs = GoldwasserMicali(keys=keys)
else:
raise ValueError(f"unimplemented algorithm - {algorithm_name}")
self.cs: Homomorphic = cs
def __str__(self) -> str:
return f"Ciphertext({self.value})"
def __repr__(self) -> str:
return f"Ciphertext({self.value})"
def __add__(self, other: "Ciphertext") -> "Ciphertext":
"""
Perform homomorphic addition methods
Args:
other (Ciperhtext): some other ciphertext
Returns:
ciphertext (Ciphertext): homomorphic addition of ciphertext
"""
if self.cs.keys.get("public_key") is None:
raise ValueError("You must have public key to perform homomorphic addition")
result = self.cs.add(ciphertext1=self.value, ciphertext2=other.value)
return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)
def __mul__(self, other: Union["Ciphertext", int, float]) -> "Ciphertext":
"""
Perform homomorphic multiplication or multiply a ciphertext with a known constant
Args:
other (int | float | Ciphertext): a known plain constant of some other ciphertext
Returns
homomorphic multiplication of ciphertexts | scalar multiplication of ciphertext
"""
if self.cs.keys.get("public_key") is None:
raise ValueError("You must have public key to perform homomorphic multiplication")
if isinstance(other, Ciphertext):
# Handle multiplication with another EncryptedObject
result = self.cs.multiply(ciphertext1=self.value, ciphertext2=other.value)
elif isinstance(other, int):
result = self.cs.multiply_by_contant(ciphertext=self.value, constant=other)
elif isinstance(other, float):
|
logger = Logger(module="lightphe/models/Ciphertext.py")
# pylint: disable=too-few-public-methods, no-else-return
class Ciphertext:
def __init__(self, algorithm_name: str, keys: dict, value: Union[int, tuple, list]):
self.algorithm_name = algorithm_name
self.keys = keys
self.value = value
if algorithm_name == Algorithm.RSA:
cs = RSA(keys=keys)
elif algorithm_name == Algorithm.ElGamal:
cs = ElGamal(keys=keys)
elif algorithm_name == Algorithm.ExponentialElGamal:
cs = ElGamal(keys=keys, exponential=True)
elif algorithm_name == Algorithm.EllipticCurveElGamal:
cs = EllipticCurveElGamal(keys=keys)
elif algorithm_name == Algorithm.Paillier:
cs = Paillier(keys=keys)
elif algorithm_name == Algorithm.DamgardJurik:
cs = DamgardJurik(keys=keys)
elif algorithm_name == Algorithm.OkamotoUchiyama:
cs = OkamotoUchiyama(keys=keys)
elif algorithm_name == Algorithm.Benaloh:
cs = Benaloh(keys=keys)
elif algorithm_name == Algorithm.NaccacheStern:
cs = NaccacheStern(keys=keys)
elif algorithm_name == Algorithm.GoldwasserMicali:
cs = GoldwasserMicali(keys=keys)
else:
raise ValueError(f"unimplemented algorithm - {algorithm_name}")
self.cs: Homomorphic = cs
def __str__(self) -> str:
return f"Ciphertext({self.value})"
def __repr__(self) -> str:
return f"Ciphertext({self.value})"
def __add__(self, other: "Ciphertext") -> "Ciphertext":
"""
Perform homomorphic addition methods
Args:
other (Ciperhtext): some other ciphertext
Returns:
ciphertext (Ciphertext): homomorphic addition of ciphertext
"""
if self.cs.keys.get("public_key") is None:
raise ValueError("You must have public key to perform homomorphic addition")
result = self.cs.add(ciphertext1=self.value, ciphertext2=other.value)
return Ciphertext(algorithm_name=self.algorithm_name, keys=self.keys, value=result)
def __mul__(self, other: Union["Ciphertext", int, float]) -> "Ciphertext":
"""
Perform homomorphic multiplication or multiply a ciphertext with a known constant
Args:
other (int | float | Ciphertext): a known plain constant of some other ciphertext
Returns
homomorphic multiplication of ciphertexts | scalar multiplication of ciphertext
"""
if self.cs.keys.get("public_key") is None:
raise ValueError("You must have public key to perform homomorphic multiplication")
if isinstance(other, Ciphertext):
# Handle multiplication with another EncryptedObject
result = self.cs.multiply(ciphertext1=self.value, ciphertext2=other.value)
elif isinstance(other, int):
result = self.cs.multiply_by_contant(ciphertext=self.value, constant=other)
elif isinstance(other, float): | constant = phe_utils.parse_int(value=other, modulo=self.cs.plaintext_modulo) | 11 | 2023-10-28 14:57:59+00:00 | 24k |
chenran-li/RQL-release | stable_baselines3/sac_residual/sac_residual.py | [
{
"identifier": "ReplayBuffer",
"path": "stable_baselines3/common/buffers.py",
"snippet": "class ReplayBuffer(BaseBuffer):\n \"\"\"\n Replay buffer used in off-policy algorithms like SAC/TD3.\n\n :param buffer_size: Max number of element in the buffer\n :param observation_space: Observation ... | from typing import Any, Dict, List, Optional, Tuple, Type, TypeVar, Union
from gym import spaces
from torch.nn import functional as F
from stable_baselines3.common.buffers import ReplayBuffer
from stable_baselines3.common.noise import ActionNoise
from stable_baselines3.common.off_policy_algorithm import OffPolicyAlgorithm
from stable_baselines3.common.policies import BasePolicy
from stable_baselines3.common.type_aliases import GymEnv, MaybeCallback, Schedule
from stable_baselines3.common.utils import get_parameters_by_name, polyak_update
from stable_baselines3.sac_residual.policies import ResidualCnnPolicy, ResidualMlpPolicy, ResidualMultiInputPolicy, ResidualSACPolicy
from stable_baselines3.sac.sac import SAC
import numpy as np
import torch as th | 17,049 | target_update_interval=target_update_interval,
target_entropy=target_entropy,
use_sde=use_sde,
sde_sample_freq=sde_sample_freq,
use_sde_at_warmup=use_sde_at_warmup,
tensorboard_log=tensorboard_log,
policy_kwargs=policy_kwargs,
verbose=verbose,
seed=seed,
device=device,
_init_setup_model=_init_setup_model,
)
def _setup_model(self) -> None:
super()._setup_model()
self.policy.prior_model = SAC.load(self.prior_model_path,env=self.env)
self.policy.prior_model.policy.set_training_mode(False) # freeze prior model parameters
def train(self, gradient_steps: int, batch_size: int = 64) -> None:
# Switch to train mode (this affects batch norm / dropout)
self.policy.set_training_mode(True)
# Update optimizers learning rate
optimizers = [self.actor.optimizer, self.critic.optimizer]
if self.ent_coef_optimizer is not None:
optimizers += [self.ent_coef_optimizer]
# Update learning rate according to lr schedule
self._update_learning_rate(optimizers)
ent_coef_losses, ent_coefs = [], []
actor_losses, critic_losses = [], []
for gradient_step in range(gradient_steps):
# Sample replay buffer
replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)
# We need to sample because `log_std` may have changed between two gradient steps
if self.use_sde:
self.actor.reset_noise()
# Action by the current actor for the sampled state
actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)
log_prob = log_prob.reshape(-1, 1)
# SAC and GAIL prior policy
prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.observations, actions_pi)
prior_log_prob = prior_log_prob.reshape(-1, 1)
ent_coef_loss = None
if self.ent_coef_optimizer is not None:
# Important: detach the variable from the graph
# so we don't change it with other losses
# see https://github.com/rail-berkeley/softlearning/issues/60
ent_coef = th.exp(self.log_ent_coef.detach())
ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean()
ent_coef_losses.append(ent_coef_loss.item())
else:
ent_coef = self.ent_coef_tensor
ent_coefs.append(ent_coef.item())
# pre reward normalize to current reward.
ent_coef_prior = self.policy.prior_model.ent_coef if not isinstance(self.policy.prior_model.ent_coef, str) else ent_coef
if ent_coef_prior == 0:
ent_coef_prior = ent_coef
if self.num_timesteps < self.warmstarting_num_timesteps:
ent_coef_prior = self.warmstarting_scale * ent_coef_prior
# Optimize entropy coefficient, also called
# entropy temperature or alpha in the paper
if ent_coef_loss is not None:
self.ent_coef_optimizer.zero_grad()
ent_coef_loss.backward()
self.ent_coef_optimizer.step()
with th.no_grad():
# Select action according to policy
next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)
next_log_prob = next_log_prob.reshape(-1, 1)
# SAC and GAIL
next_prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.next_observations, next_actions)
next_prior_log_prob = next_prior_log_prob.reshape(-1, 1)
# Compute the next Q values: min over all critics targets
next_q_values = th.cat(self.critic_target(replay_data.next_observations, next_actions), dim=1)
next_q_values, _ = th.min(next_q_values, dim=1, keepdim=True)
# add entropy term and prior policy logprob
next_q_values = next_q_values + ent_coef_prior * next_prior_log_prob - ent_coef * next_log_prob
# td error + entropy term
target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values
# Get current Q-values estimates for each critic network
# using action from the replay buffer
current_q_values = self.critic(replay_data.observations, replay_data.actions)
# Compute critic loss
critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values) for current_q in current_q_values)
critic_losses.append(critic_loss.item())
# Optimize the critic
self.critic.optimizer.zero_grad()
critic_loss.backward()
self.critic.optimizer.step()
# Compute actor loss
# Alternative: actor_loss = th.mean(log_prob - qf1_pi)
# Min over all critic networks
q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)
min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)
actor_loss = (ent_coef * log_prob - min_qf_pi - ent_coef_prior * prior_log_prob).mean()
actor_losses.append(actor_loss.item())
# Optimize the actor
self.actor.optimizer.zero_grad()
actor_loss.backward()
self.actor.optimizer.step()
# Update target networks
if gradient_step % self.target_update_interval == 0:
|
SelfResidualSAC = TypeVar("SelfResidualSAC", bound="ResidualSAC")
class ResidualSAC(SAC):
"""
Residual Soft Actor-Critic (SAC)
Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor,
This implementation borrows code from original implementation (https://github.com/haarnoja/sac)
from OpenAI Spinning Up (https://github.com/openai/spinningup), from the softlearning repo
(https://github.com/rail-berkeley/softlearning/)
and from Stable Baselines (https://github.com/hill-a/stable-baselines)
Paper: https://arxiv.org/abs/1801.01290
Introduction to SAC: https://spinningup.openai.com/en/latest/algorithms/sac.html
Note: we use double q target and not value target as discussed
in https://github.com/hill-a/stable-baselines/issues/270
:param policy: The policy model to use (MlpPolicy, CnnPolicy, ...)
:param env: The environment to learn from (if registered in Gym, can be str)
:param learning_rate: learning rate for adam optimizer,
the same learning rate will be used for all networks (Q-Values, Actor and Value function)
it can be a function of the current progress remaining (from 1 to 0)
:param buffer_size: size of the replay buffer
:param learning_starts: how many steps of the model to collect transitions for before learning starts
:param batch_size: Minibatch size for each gradient update
:param tau: the soft update coefficient ("Polyak update", between 0 and 1)
:param gamma: the discount factor
:param train_freq: Update the model every ``train_freq`` steps. Alternatively pass a tuple of frequency and unit
like ``(5, "step")`` or ``(2, "episode")``.
:param gradient_steps: How many gradient steps to do after each rollout (see ``train_freq``)
Set to ``-1`` means to do as many gradient steps as steps done in the environment
during the rollout.
:param action_noise: the action noise type (None by default), this can help
for hard exploration problem. Cf common.noise for the different action noise type.
:param replay_buffer_class: Replay buffer class to use (for instance ``HerReplayBuffer``).
If ``None``, it will be automatically selected.
:param replay_buffer_kwargs: Keyword arguments to pass to the replay buffer on creation.
:param optimize_memory_usage: Enable a memory efficient variant of the replay buffer
at a cost of more complexity.
See https://github.com/DLR-RM/stable-baselines3/issues/37#issuecomment-637501195
:param ent_coef: Entropy regularization coefficient. (Equivalent to
inverse of reward scale in the original SAC paper.) Controlling exploration/exploitation trade-off.
Set it to 'auto' to learn it automatically (and 'auto_0.1' for using 0.1 as initial value)
:param target_update_interval: update the target network every ``target_network_update_freq``
gradient steps.
:param target_entropy: target entropy when learning ``ent_coef`` (``ent_coef = 'auto'``)
:param use_sde: Whether to use generalized State Dependent Exploration (gSDE)
instead of action noise exploration (default: False)
:param sde_sample_freq: Sample a new noise matrix every n steps when using gSDE
Default: -1 (only sample at the beginning of the rollout)
:param use_sde_at_warmup: Whether to use gSDE instead of uniform sampling
during the warm up phase (before learning starts)
:param policy_kwargs: additional arguments to be passed to the policy on creation
:param verbose: Verbosity level: 0 for no output, 1 for info messages (such as device or wrappers used), 2 for
debug messages
:param seed: Seed for the pseudo random generators
:param device: Device (cpu, cuda, ...) on which the code should be run.
Setting it to auto, the code will be run on the GPU if possible.
:param _init_setup_model: Whether or not to build the network at the creation of the instance
"""
policy_aliases: Dict[str, Type[BasePolicy]] = {
"MlpPolicy": ResidualMlpPolicy,
"CnnPolicy": ResidualCnnPolicy,
"MultiInputPolicy": ResidualMultiInputPolicy,
}
def __init__(
self,
policy: Union[str, Type[ResidualSACPolicy]],
env: Union[GymEnv, str],
prior_model_path: str,
learning_rate: Union[float, Schedule] = 3e-4,
buffer_size: int = 1_000_000, # 1e6
learning_starts: int = 100,
batch_size: int = 256,
tau: float = 0.005,
gamma: float = 0.99,
train_freq: Union[int, Tuple[int, str]] = 1,
gradient_steps: int = 1,
warmstarting_num_timesteps: int = 0,
warmstarting_scale: int = 10,
action_noise: Optional[ActionNoise] = None,
replay_buffer_class: Optional[Type[ReplayBuffer]] = None,
replay_buffer_kwargs: Optional[Dict[str, Any]] = None,
optimize_memory_usage: bool = False,
ent_coef: Union[str, float] = "auto",
target_update_interval: int = 1,
target_entropy: Union[str, float] = "auto",
use_sde: bool = False,
sde_sample_freq: int = -1,
use_sde_at_warmup: bool = False,
tensorboard_log: Optional[str] = None,
policy_kwargs: Optional[Dict[str, Any]] = None,
verbose: int = 0,
seed: Optional[int] = None,
device: Union[th.device, str] = "auto",
_init_setup_model: bool = True,
):
self.warmstarting_num_timesteps = warmstarting_num_timesteps
self.warmstarting_scale = warmstarting_scale
self.prior_model_path = prior_model_path
super().__init__(
policy,
env,
learning_rate,
buffer_size,
learning_starts,
batch_size,
tau,
gamma,
train_freq,
gradient_steps,
action_noise,
replay_buffer_class=replay_buffer_class,
replay_buffer_kwargs=replay_buffer_kwargs,
optimize_memory_usage=optimize_memory_usage,
ent_coef=ent_coef,
target_update_interval=target_update_interval,
target_entropy=target_entropy,
use_sde=use_sde,
sde_sample_freq=sde_sample_freq,
use_sde_at_warmup=use_sde_at_warmup,
tensorboard_log=tensorboard_log,
policy_kwargs=policy_kwargs,
verbose=verbose,
seed=seed,
device=device,
_init_setup_model=_init_setup_model,
)
def _setup_model(self) -> None:
super()._setup_model()
self.policy.prior_model = SAC.load(self.prior_model_path,env=self.env)
self.policy.prior_model.policy.set_training_mode(False) # freeze prior model parameters
def train(self, gradient_steps: int, batch_size: int = 64) -> None:
# Switch to train mode (this affects batch norm / dropout)
self.policy.set_training_mode(True)
# Update optimizers learning rate
optimizers = [self.actor.optimizer, self.critic.optimizer]
if self.ent_coef_optimizer is not None:
optimizers += [self.ent_coef_optimizer]
# Update learning rate according to lr schedule
self._update_learning_rate(optimizers)
ent_coef_losses, ent_coefs = [], []
actor_losses, critic_losses = [], []
for gradient_step in range(gradient_steps):
# Sample replay buffer
replay_data = self.replay_buffer.sample(batch_size, env=self._vec_normalize_env)
# We need to sample because `log_std` may have changed between two gradient steps
if self.use_sde:
self.actor.reset_noise()
# Action by the current actor for the sampled state
actions_pi, log_prob = self.actor.action_log_prob(replay_data.observations)
log_prob = log_prob.reshape(-1, 1)
# SAC and GAIL prior policy
prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.observations, actions_pi)
prior_log_prob = prior_log_prob.reshape(-1, 1)
ent_coef_loss = None
if self.ent_coef_optimizer is not None:
# Important: detach the variable from the graph
# so we don't change it with other losses
# see https://github.com/rail-berkeley/softlearning/issues/60
ent_coef = th.exp(self.log_ent_coef.detach())
ent_coef_loss = -(self.log_ent_coef * (log_prob + self.target_entropy).detach()).mean()
ent_coef_losses.append(ent_coef_loss.item())
else:
ent_coef = self.ent_coef_tensor
ent_coefs.append(ent_coef.item())
# pre reward normalize to current reward.
ent_coef_prior = self.policy.prior_model.ent_coef if not isinstance(self.policy.prior_model.ent_coef, str) else ent_coef
if ent_coef_prior == 0:
ent_coef_prior = ent_coef
if self.num_timesteps < self.warmstarting_num_timesteps:
ent_coef_prior = self.warmstarting_scale * ent_coef_prior
# Optimize entropy coefficient, also called
# entropy temperature or alpha in the paper
if ent_coef_loss is not None:
self.ent_coef_optimizer.zero_grad()
ent_coef_loss.backward()
self.ent_coef_optimizer.step()
with th.no_grad():
# Select action according to policy
next_actions, next_log_prob = self.actor.action_log_prob(replay_data.next_observations)
next_log_prob = next_log_prob.reshape(-1, 1)
# SAC and GAIL
next_prior_log_prob = self.policy.prior_model.actor.give_action_log_prob(replay_data.next_observations, next_actions)
next_prior_log_prob = next_prior_log_prob.reshape(-1, 1)
# Compute the next Q values: min over all critics targets
next_q_values = th.cat(self.critic_target(replay_data.next_observations, next_actions), dim=1)
next_q_values, _ = th.min(next_q_values, dim=1, keepdim=True)
# add entropy term and prior policy logprob
next_q_values = next_q_values + ent_coef_prior * next_prior_log_prob - ent_coef * next_log_prob
# td error + entropy term
target_q_values = replay_data.rewards + (1 - replay_data.dones) * self.gamma * next_q_values
# Get current Q-values estimates for each critic network
# using action from the replay buffer
current_q_values = self.critic(replay_data.observations, replay_data.actions)
# Compute critic loss
critic_loss = 0.5 * sum(F.mse_loss(current_q, target_q_values) for current_q in current_q_values)
critic_losses.append(critic_loss.item())
# Optimize the critic
self.critic.optimizer.zero_grad()
critic_loss.backward()
self.critic.optimizer.step()
# Compute actor loss
# Alternative: actor_loss = th.mean(log_prob - qf1_pi)
# Min over all critic networks
q_values_pi = th.cat(self.critic(replay_data.observations, actions_pi), dim=1)
min_qf_pi, _ = th.min(q_values_pi, dim=1, keepdim=True)
actor_loss = (ent_coef * log_prob - min_qf_pi - ent_coef_prior * prior_log_prob).mean()
actor_losses.append(actor_loss.item())
# Optimize the actor
self.actor.optimizer.zero_grad()
actor_loss.backward()
self.actor.optimizer.step()
# Update target networks
if gradient_step % self.target_update_interval == 0: | polyak_update(self.critic.parameters(), self.critic_target.parameters(), self.tau) | 6 | 2023-10-28 01:09:21+00:00 | 24k |
pytabular-ai/auto-scikit-dl | utils/model.py | [
{
"identifier": "MLP",
"path": "models/mlp.py",
"snippet": "class MLP(TabModel):\n def __init__(\n self,\n model_config: dict,\n n_num_features: int,\n categories: ty.Optional[ty.List[int]],\n n_labels: int,\n device: ty.Union[str, torch.device] = 'cuda',\n ... | import os
import time
import json
import yaml
import shutil
import random
import datetime
import numpy as np
import torch
import optuna
from pathlib import Path
from typing import Dict, List, Tuple, Union, Optional, Literal
from models import MLP, FTTransformer, AutoInt, DCNv2, NODE
from models.abstract import TabModel, check_dir
from data.utils import Dataset
from data.processor import DataProcessor | 15,711 |
MODEL_CARDS = {
'xgboost': None, 'catboost': None, 'lightgbm': None,
'mlp': MLP, 'autoint': AutoInt, 'dcnv2': DCNv2, 'node': NODE,
'ft-transformer': FTTransformer, 'saint': None,
't2g-former': None, 'excel-former': None,
}
HPOLib = Literal['optuna', 'hyperopt'] # TODO: add 'hyperopt' support
def get_model_cards():
return {
'ready': sorted(list([key for key, value in MODEL_CARDS.items() if value])),
'comming soon': sorted(list([key for key, value in MODEL_CARDS.items() if not value]))
}
def seed_everything(seed=42):
'''
Sets the seed of the entire notebook so results are the same every time we run.
This is for REPRODUCIBILITY.
'''
random.seed(seed)
# Set a fixed value for the hash seed
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
# When running on the CuDNN backend, two further options must be set
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def load_config_from_file(file):
file = str(file)
if file.endswith('.yaml'):
with open(file, 'r') as f:
cfg = yaml.safe_load(f)
elif file.endswith('.json'):
with open(file, 'r') as f:
cfg = json.load(f)
else:
raise AssertionError('Config files only support yaml or json format now.')
return cfg
def extract_config(model_config: dict, is_large_data: bool = False):
"""selection of different search spaces"""
used_cfgs = {"model": {}, "training": {}, 'meta': model_config.get('meta', {})}
for field in ['model', 'training']:
for k in model_config[field]:
cfgs = model_config[field][k]
if 'type2' not in cfgs:
used_cfg = cfgs
else:
if not is_large_data:
used_cfg = {k: v for k, v in cfgs.items() if not k.endswith('2')}
else:
used_cfg = {k[:-1]: v for k, v in cfgs.items() if k.endswith('2')}
used_cfgs[field][k] = used_cfg
return used_cfgs
def make_baseline(
model_name,
model_config: Union[dict, str],
n_num: int,
cat_card: Optional[List[int]],
n_labels: int,
sparsity_scheme: Optional[str] = None,
device: Union[str, torch.device] = 'cuda',
) -> TabModel:
"""Process Model Configs and Call Specific Model APIs"""
assert model_name in MODEL_CARDS, f"unrecognized `{model_name}` model name, choose one of valid models in {MODEL_CARDS}"
if isinstance(model_config, str):
model_config = load_config_from_file(model_config)['model']
if MODEL_CARDS[model_name] is None:
raise NotImplementedError("Please add corresponding model implementation to `models` module")
if sparsity_scheme is not None:
assert 'mlp' in model_name
return MODEL_CARDS[model_name](
model_config=model_config,
n_num_features=n_num, categories=cat_card, n_labels=n_labels,
sparsity_scheme=sparsity_scheme)
return MODEL_CARDS[model_name](
model_config=model_config,
n_num_features=n_num, categories=cat_card, n_labels=n_labels)
def tune(
model_name: str = None,
search_config: Union[dict, str] = None,
|
MODEL_CARDS = {
'xgboost': None, 'catboost': None, 'lightgbm': None,
'mlp': MLP, 'autoint': AutoInt, 'dcnv2': DCNv2, 'node': NODE,
'ft-transformer': FTTransformer, 'saint': None,
't2g-former': None, 'excel-former': None,
}
HPOLib = Literal['optuna', 'hyperopt'] # TODO: add 'hyperopt' support
def get_model_cards():
return {
'ready': sorted(list([key for key, value in MODEL_CARDS.items() if value])),
'comming soon': sorted(list([key for key, value in MODEL_CARDS.items() if not value]))
}
def seed_everything(seed=42):
'''
Sets the seed of the entire notebook so results are the same every time we run.
This is for REPRODUCIBILITY.
'''
random.seed(seed)
# Set a fixed value for the hash seed
os.environ['PYTHONHASHSEED'] = str(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
# When running on the CuDNN backend, two further options must be set
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def load_config_from_file(file):
file = str(file)
if file.endswith('.yaml'):
with open(file, 'r') as f:
cfg = yaml.safe_load(f)
elif file.endswith('.json'):
with open(file, 'r') as f:
cfg = json.load(f)
else:
raise AssertionError('Config files only support yaml or json format now.')
return cfg
def extract_config(model_config: dict, is_large_data: bool = False):
"""selection of different search spaces"""
used_cfgs = {"model": {}, "training": {}, 'meta': model_config.get('meta', {})}
for field in ['model', 'training']:
for k in model_config[field]:
cfgs = model_config[field][k]
if 'type2' not in cfgs:
used_cfg = cfgs
else:
if not is_large_data:
used_cfg = {k: v for k, v in cfgs.items() if not k.endswith('2')}
else:
used_cfg = {k[:-1]: v for k, v in cfgs.items() if k.endswith('2')}
used_cfgs[field][k] = used_cfg
return used_cfgs
def make_baseline(
model_name,
model_config: Union[dict, str],
n_num: int,
cat_card: Optional[List[int]],
n_labels: int,
sparsity_scheme: Optional[str] = None,
device: Union[str, torch.device] = 'cuda',
) -> TabModel:
"""Process Model Configs and Call Specific Model APIs"""
assert model_name in MODEL_CARDS, f"unrecognized `{model_name}` model name, choose one of valid models in {MODEL_CARDS}"
if isinstance(model_config, str):
model_config = load_config_from_file(model_config)['model']
if MODEL_CARDS[model_name] is None:
raise NotImplementedError("Please add corresponding model implementation to `models` module")
if sparsity_scheme is not None:
assert 'mlp' in model_name
return MODEL_CARDS[model_name](
model_config=model_config,
n_num_features=n_num, categories=cat_card, n_labels=n_labels,
sparsity_scheme=sparsity_scheme)
return MODEL_CARDS[model_name](
model_config=model_config,
n_num_features=n_num, categories=cat_card, n_labels=n_labels)
def tune(
model_name: str = None,
search_config: Union[dict, str] = None, | dataset: Dataset = None, | 7 | 2023-10-30 14:55:44+00:00 | 24k |
hyperspy/exspy | exspy/tests/models/test_eelsmodel.py | [
{
"identifier": "elements_db",
"path": "exspy/misc/elements.py",
"snippet": ""
},
{
"identifier": "_GOSH_URL",
"path": "exspy/misc/eels/gosh_gos.py",
"snippet": "_GOSH_URL = f\"doi:{_GOSH_DOI}/Segger_Guzzinati_Kohl_1.5.0.gosh\""
},
{
"identifier": "_GOSH_KNOWN_HASH",
"path": ... | import contextlib
import io
import numpy as np
import pooch
import pytest
import hyperspy.api as hs
from unittest import mock
from exspy.misc.elements import elements_db as elements
from hyperspy.decorators import lazifyTestClass
from exspy.misc.eels.gosh_gos import _GOSH_URL, _GOSH_KNOWN_HASH
from exspy.signals import EELSSpectrum
from exspy.models.eelsmodel import EELSModel
from hyperspy.components1d import PowerLaw
from hyperspy.components1d import PowerLaw | 18,768 | # -*- coding: utf-8 -*-
# Copyright 2007-2023 The exSpy developers
#
# This file is part of exSpy.
#
# exSpy is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# exSpy is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with exSpy. If not, see <https://www.gnu.org/licenses/#GPL>.
# Dask does not always work nicely with np.errstate,
# see: https://github.com/dask/dask/issues/3245, so
# filter out divide-by-zero warnings that only appear
# when the test is lazy. When the test is not lazy,
# internal use of np.errstate means the warnings never
# appear in the first place.
@pytest.mark.filterwarnings(
"ignore:invalid value encountered in subtract:RuntimeWarning"
)
@pytest.mark.filterwarnings("ignore:divide by zero encountered in log:RuntimeWarning")
@lazifyTestClass
class TestCreateEELSModel:
def setup_method(self, method):
| # -*- coding: utf-8 -*-
# Copyright 2007-2023 The exSpy developers
#
# This file is part of exSpy.
#
# exSpy is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# exSpy is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with exSpy. If not, see <https://www.gnu.org/licenses/#GPL>.
# Dask does not always work nicely with np.errstate,
# see: https://github.com/dask/dask/issues/3245, so
# filter out divide-by-zero warnings that only appear
# when the test is lazy. When the test is not lazy,
# internal use of np.errstate means the warnings never
# appear in the first place.
@pytest.mark.filterwarnings(
"ignore:invalid value encountered in subtract:RuntimeWarning"
)
@pytest.mark.filterwarnings("ignore:divide by zero encountered in log:RuntimeWarning")
@lazifyTestClass
class TestCreateEELSModel:
def setup_method(self, method): | s = EELSSpectrum(np.zeros(200)) | 3 | 2023-10-28 20:04:10+00:00 | 24k |
Elfenreigen/UniChest | train.py | [
{
"identifier": "utils",
"path": "factory/utils.py",
"snippet": "class SmoothedValue(object):\nclass MetricLogger(object):\nclass AttrDict(dict):\n def __init__(self, window_size=20, fmt=None):\n def update(self, value, n=1):\n def synchronize_between_processes(self):\n def median(self):\n ... | import argparse
import os
import logging
import yaml
import numpy as np
import random
import time
import datetime
import json
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.backends.cudnn as cudnn
import torch.distributed as dist
import socket
from pathlib import Path
from functools import partial
from sklearn.metrics import roc_auc_score
from collections import OrderedDict
from torch.utils.data import DataLoader
from tensorboardX import SummaryWriter
from transformers import AutoModel,BertConfig,AutoTokenizer
from factory import utils
from scheduler import create_scheduler
from optim import create_optimizer
from engine.train import train,valid_on_cheXpert,valid_on_chestxray14
from models.clip_tqn import CLP_clinical,ModelRes,TQN_Model,TQN_Model_Add,ModelDense,CLP_clinical2
from models.tokenization_bert import BertTokenizer
from dataset.dataset_entity import MIMIC_Dataset,Mergetrain_Dataset, Chestxray14_Dataset,CheXpert_Dataset
from io import BytesIO | 17,454 |
#### Dataset ####
print("Creating dataset")
if args.add_dataset == True:
train_dataset = Mergetrain_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)
else:
train_dataset = MIMIC_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)
train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
train_dataloader = DataLoader(
train_dataset,
batch_size=config['batch_size'],
num_workers=8,
pin_memory=True,
sampler=train_sampler,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
train_dataloader.num_samples = len(train_dataset)
train_dataloader.num_batches = len(train_dataloader)
val_dataset = Chestxray14_Dataset(config['chestxray_valid_file'],config['image_res'])
val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
val_dataloader =DataLoader(
val_dataset,
batch_size=config['batch_size'],
num_workers=8,
pin_memory=True,
sampler=val_sampler,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
val_dataloader.num_samples = len(val_dataset)
val_dataloader.num_batches = len(val_dataloader)
test_dataset = Chestxray14_Dataset(config['chestxray_test_file'],config['image_res'])
test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
test_dataloader =DataLoader(
test_dataset,
batch_size=config['batch_size'],
num_workers=8,
pin_memory=True,
sampler=test_sampler,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
test_dataloader.num_samples = len(test_dataset)
test_dataloader.num_batches = len(test_dataloader)
test_dataset_chexpert = CheXpert_Dataset(config['chexpert_valid_file'],config['image_res'])
test_sampler_chexpert = torch.utils.data.distributed.DistributedSampler(test_dataset_chexpert,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
test_dataloader_chexpert =DataLoader(
test_dataset_chexpert,
batch_size=config['batch_size'],
num_workers=4,
pin_memory=True,
sampler=test_sampler_chexpert,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
test_dataloader_chexpert.num_samples = len(test_dataset_chexpert)
test_dataloader_chexpert.num_batches = len(test_dataloader_chexpert)
if args.image_encoder_name == 'resnet':
image_encoder = ModelRes(res_base_model='resnet50').cuda()
elif args.image_encoder_name == 'dense':
image_encoder = ModelDense(dense_base_model = 'densenet121').cuda()
if args.bert_model_name == 'emilyalsentzer/Bio_ClinicalBERT':
tokenizer = BertTokenizer.from_pretrained(args.bert_model_name)
text_encoder = CLP_clinical2(bert_model_name=args.bert_model_name).cuda()
else:
tokenizer = AutoTokenizer.from_pretrained(args.bert_model_name,do_lower_case=True, local_files_only=True)
text_encoder = CLP_clinical(bert_model_name=args.bert_model_name).cuda()
if args.bert_pretrained:
checkpoint = torch.load(args.bert_pretrained, map_location='cpu')
state_dict = checkpoint["state_dict"]
text_encoder.load_state_dict(state_dict)
print('Load pretrained bert success from: ',args.bert_pretrained)
if args.freeze_bert:
for param in text_encoder.parameters():
param.requires_grad = False
if args.add_dataset:
if 'lam' in config:
model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim, lam = config['lam']).cuda()
else:
model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim).cuda()
else:
if 'lam' in config:
model = TQN_Model(class_num = args.class_num, lam = config['lam']).cuda()
else:
model = TQN_Model(class_num = args.class_num).cuda()
model = torch.nn.parallel.DistributedDataParallel(model, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)
model_without_ddp = model.module
if args.finetune:
image_encoder_without_ddp = image_encoder
else:
image_encoder = torch.nn.parallel.DistributedDataParallel(image_encoder, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)
image_encoder_without_ddp = image_encoder.module
text_encoder_without_ddp = text_encoder
arg_opt = utils.AttrDict(config['optimizer'])
|
# import ruamel.yaml as yaml
def main(args, config):
torch.cuda.current_device()
torch.cuda._initialized = True
print("Total CUDA devices: ", torch.cuda.device_count())
torch.set_default_tensor_type('torch.FloatTensor')
utils.init_distributed_mode(args)
device = torch.device(args.device)
# fix the seed for reproducibility
seed = args.seed + utils.get_rank()
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
cudnn.benchmark = True
start_epoch = 0
max_epoch = config['schedular']['epochs']
warmup_steps = config['schedular']['warmup_epochs']
num_tasks = utils.get_world_size()
global_rank = utils.get_rank()
sampler_rank = global_rank
print('sampler_rank',sampler_rank,'num_tasks',num_tasks)
#### Dataset ####
print("Creating dataset")
if args.add_dataset == True:
train_dataset = Mergetrain_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)
else:
train_dataset = MIMIC_Dataset(config['train_entity_file'], config['train_fg_query_file_v1'], config['mrsty_file'],config['image_res'], args)
train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
train_dataloader = DataLoader(
train_dataset,
batch_size=config['batch_size'],
num_workers=8,
pin_memory=True,
sampler=train_sampler,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
train_dataloader.num_samples = len(train_dataset)
train_dataloader.num_batches = len(train_dataloader)
val_dataset = Chestxray14_Dataset(config['chestxray_valid_file'],config['image_res'])
val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
val_dataloader =DataLoader(
val_dataset,
batch_size=config['batch_size'],
num_workers=8,
pin_memory=True,
sampler=val_sampler,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
val_dataloader.num_samples = len(val_dataset)
val_dataloader.num_batches = len(val_dataloader)
test_dataset = Chestxray14_Dataset(config['chestxray_test_file'],config['image_res'])
test_sampler = torch.utils.data.distributed.DistributedSampler(test_dataset,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
test_dataloader =DataLoader(
test_dataset,
batch_size=config['batch_size'],
num_workers=8,
pin_memory=True,
sampler=test_sampler,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
test_dataloader.num_samples = len(test_dataset)
test_dataloader.num_batches = len(test_dataloader)
test_dataset_chexpert = CheXpert_Dataset(config['chexpert_valid_file'],config['image_res'])
test_sampler_chexpert = torch.utils.data.distributed.DistributedSampler(test_dataset_chexpert,num_replicas=num_tasks, rank=sampler_rank, shuffle=True)
test_dataloader_chexpert =DataLoader(
test_dataset_chexpert,
batch_size=config['batch_size'],
num_workers=4,
pin_memory=True,
sampler=test_sampler_chexpert,
collate_fn=None,
worker_init_fn=utils.seed_worker,
drop_last=True,
)
test_dataloader_chexpert.num_samples = len(test_dataset_chexpert)
test_dataloader_chexpert.num_batches = len(test_dataloader_chexpert)
if args.image_encoder_name == 'resnet':
image_encoder = ModelRes(res_base_model='resnet50').cuda()
elif args.image_encoder_name == 'dense':
image_encoder = ModelDense(dense_base_model = 'densenet121').cuda()
if args.bert_model_name == 'emilyalsentzer/Bio_ClinicalBERT':
tokenizer = BertTokenizer.from_pretrained(args.bert_model_name)
text_encoder = CLP_clinical2(bert_model_name=args.bert_model_name).cuda()
else:
tokenizer = AutoTokenizer.from_pretrained(args.bert_model_name,do_lower_case=True, local_files_only=True)
text_encoder = CLP_clinical(bert_model_name=args.bert_model_name).cuda()
if args.bert_pretrained:
checkpoint = torch.load(args.bert_pretrained, map_location='cpu')
state_dict = checkpoint["state_dict"]
text_encoder.load_state_dict(state_dict)
print('Load pretrained bert success from: ',args.bert_pretrained)
if args.freeze_bert:
for param in text_encoder.parameters():
param.requires_grad = False
if args.add_dataset:
if 'lam' in config:
model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim, lam = config['lam']).cuda()
else:
model = TQN_Model_Add(class_num = args.class_num, gate_num = args.gate_num, high_dim = args.high_dim).cuda()
else:
if 'lam' in config:
model = TQN_Model(class_num = args.class_num, lam = config['lam']).cuda()
else:
model = TQN_Model(class_num = args.class_num).cuda()
model = torch.nn.parallel.DistributedDataParallel(model, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)
model_without_ddp = model.module
if args.finetune:
image_encoder_without_ddp = image_encoder
else:
image_encoder = torch.nn.parallel.DistributedDataParallel(image_encoder, device_ids = [args.gpu], find_unused_parameters=True, broadcast_buffers=False)
image_encoder_without_ddp = image_encoder.module
text_encoder_without_ddp = text_encoder
arg_opt = utils.AttrDict(config['optimizer']) | optimizer = create_optimizer(arg_opt, model_without_ddp,image_encoder_without_ddp,text_encoder_without_ddp) | 2 | 2023-10-30 00:24:16+00:00 | 24k |
ifrit98/storage-subnet | neurons/miner.py | [
{
"identifier": "hash_data",
"path": "storage/shared/ecc.py",
"snippet": "def hash_data(data):\n \"\"\"\n Compute a SHA3-256 hash of the input data and return its integer representation.\n\n The function handles both byte-like and non-byte-like inputs by converting non-byte inputs to\n strin... | import os
import sys
import copy
import json
import time
import torch
import typing
import base64
import asyncio
import aioredis
import argparse
import threading
import traceback
import bittensor as bt
import storage
from collections import defaultdict
from Crypto.Random import get_random_bytes
from typing import Dict
from pprint import pprint, pformat
from storage.shared.ecc import (
hash_data,
setup_CRS,
ECCommitment,
ecc_point_to_hex,
hex_to_ecc_point,
)
from storage.shared.merkle import (
MerkleTree,
)
from storage.shared.utils import b64_encode, b64_decode, chunk_data, safe_key_search
from storage.miner import (
run,
set_weights,
)
from storage.miner.utils import (
compute_subsequent_commitment,
save_data_to_filesystem,
load_from_filesystem,
commit_data_with_seed,
init_wandb,
get_directory_size,
get_free_disk_space,
update_storage_stats,
)
from storage.miner.config import (
config,
check_config,
add_args,
)
from storage.miner.database import (
store_chunk_metadata,
update_seed_info,
get_chunk_metadata,
) | 14,974 |
If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and
the function returns (True, "Unrecognized hotkey"). Otherwise, it returns (False,
"Hotkey recognized!"), allowing the synapse to interact with the network.
Usage:
This method is internally used by the network to ensure that only recognized
entities can participate in communication or transactions.
"""
if synapse.dendrite.hotkey not in self.metagraph.hotkeys:
# Ignore requests from unrecognized entities.
bt.logging.trace(
f"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}"
)
return True, "Unrecognized hotkey"
bt.logging.trace(
f"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}"
)
return False, "Hotkey recognized!"
def retrieve_priority_fn(self, synapse: storage.protocol.Retrieve) -> float:
"""
Assigns a priority to a given synapse based on the stake of the calling entity
in the metagraph. This function is crucial for prioritizing network requests
and ensuring that higher-stake entities are given precedence in processing.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey of the caller.
Returns:
- float: The priority value assigned to the synapse, derived from the stake of
the calling hotkey in the metagraph.
The priority is determined by the stake associated with the caller's UID in the
metagraph. A higher stake results in a higher priority.
Usage:
This method is used within the network's request handling mechanism to allocate
resources and processing time based on the stake-based priority of each request.
"""
caller_uid = self.metagraph.hotkeys.index(
synapse.dendrite.hotkey
) # Get the caller index.
prirority = float(
self.metagraph.S[caller_uid]
) # Return the stake as the priority.
bt.logging.trace(
f"Prioritizing {synapse.dendrite.hotkey} with value: ", prirority
)
return prirority
async def store(self, synapse: storage.protocol.Store) -> storage.protocol.Store:
"""
Processes the storage request from a synapse by securely storing the provided data and returning
a proof of storage. The data is committed using elliptic curve cryptography, stored on the filesystem,
and the metadata is recorded in a Redis database. A cryptographic proof of the commitment, along with
a digital signature from the server's hotkey, is returned in the synapse for verification by the requester.
Args:
synapse (storage.protocol.Store): An object containing the data to be stored,
encoded in base64 format, along with associated metadata like the cryptographic
curve parameters, a seed for the commitment, and the expected commitment group elements.
Returns:
storage.protocol.Store: The synapse is returned with additional fields populated,
including the randomness used in the commitment, the commitment point itself, a signature
from this storage server's hotkey, and a commitment hash that can be used for chained proofs.
The method performs the following operations:
1. Decodes the base64-encoded data into raw bytes.
2. Commits to the data using the provided elliptic curve parameters and the seed to generate a commitment point.
3. Stores the raw byte data in the filesystem using a hash of the data as the filename.
4. Records metadata about the stored data in the Redis database, including the file path, previous seed, and data size.
5. Updates the synapse object with the commitment details and a digital signature.
This process ensures the integrity and non-repudiation of the data storage, allowing clients to verify
that their data has been stored correctly without the need to retrieve the full data set.
Example usage:
Assuming an initialized 'committer' object and 'synapse' with necessary data:
>>> updated_synapse = self.store(synapse)
"""
bt.logging.info(f"received store request: {synapse.encrypted_data[:24]}")
self.request_count += 1
# Decode the data from base64 to raw bytes
encrypted_byte_data = base64.b64decode(synapse.encrypted_data)
bt.logging.trace(f"store b64decrypted data: {encrypted_byte_data[:24]}")
# Store the data with the hash as the key in the filesystem
bt.logging.trace(f"entering hash_data()")
data_hash = hash_data(encrypted_byte_data)
# If already storing this hash, simply update the validator seeds and return challenge
bt.logging.trace(f"checking if data already exists...")
if await self.database.exists(data_hash):
# update the validator seed challenge hash in storage
await update_seed_info(
self.database, data_hash, synapse.dendrite.hotkey, synapse.seed
)
else:
# Store the data in the filesystem
filepath = save_data_to_filesystem(
encrypted_byte_data, self.config.database.directory, str(data_hash)
)
bt.logging.trace(f"stored data {data_hash} in filepath: {filepath}")
# Add the initial chunk, size, and validator seed information
await store_chunk_metadata(
self.database,
data_hash,
filepath,
synapse.dendrite.hotkey,
sys.getsizeof(encrypted_byte_data),
synapse.seed,
)
# Commit to the entire data block
bt.logging.trace(f"entering ECCommitment()")
committer = ECCommitment(
| # The MIT License (MIT)
# Copyright © 2023 Yuma Rao
# Copyright © 2023 philanthrope
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
# the Software.
# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
# THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.
# import this repo
class miner:
@classmethod
def check_config(cls, config: "bt.Config"):
"""
Adds neuron-specific arguments to the argument parser.
Args:
parser (argparse.ArgumentParser): Parser to add arguments to.
This class method enriches the argument parser with options specific to the neuron's configuration.
"""
check_config(cls, config)
@classmethod
def add_args(cls, parser):
"""
Adds neuron-specific arguments to the argument parser.
Args:
parser (argparse.ArgumentParser): Parser to add arguments to.
This class method enriches the argument parser with options specific to the neuron's configuration.
"""
add_args(cls, parser)
@classmethod
def config(cls):
"""
Retrieves the configuration for the neuron.
Returns:
bt.Config: The configuration object for the neuron.
This class method returns the neuron's configuration, which is used throughout the neuron's lifecycle
for various functionalities and operations.
"""
return config(cls)
subtensor: "bt.subtensor"
wallet: "bt.wallet"
metagraph: "bt.metagraph"
def __init__(self):
self.config = miner.config()
self.check_config(self.config)
bt.logging(config=self.config, logging_dir=self.config.miner.full_path)
bt.logging.info(f"{self.config}")
bt.logging.info("miner.__init__()")
# Init device.
bt.logging.debug("loading device")
self.device = torch.device(self.config.miner.device)
bt.logging.debug(str(self.device))
# Init subtensor
bt.logging.debug("loading subtensor")
self.subtensor = bt.subtensor(config=self.config)
bt.logging.debug(str(self.subtensor))
self.current_block = self.subtensor.get_current_block()
# Init wallet.
bt.logging.debug("loading wallet")
self.wallet = bt.wallet(config=self.config)
self.wallet.create_if_non_existent()
if not self.config.wallet._mock:
if not self.subtensor.is_hotkey_registered_on_subnet(
hotkey_ss58=self.wallet.hotkey.ss58_address, netuid=self.config.netuid
):
raise Exception(
f"Wallet not currently registered on netuid {self.config.netuid}, please first register wallet before running"
)
bt.logging.debug(f"wallet: {str(self.wallet)}")
# Init metagraph.
bt.logging.debug("loading metagraph")
self.metagraph = bt.metagraph(
netuid=self.config.netuid, network=self.subtensor.network, sync=False
) # Make sure not to sync without passing subtensor
self.metagraph.sync(subtensor=self.subtensor) # Sync metagraph with subtensor.
bt.logging.debug(str(self.metagraph))
# Setup database
self.database = aioredis.StrictRedis(
host=self.config.database.host,
port=self.config.database.port,
db=self.config.database.index,
socket_keepalive=True,
socket_connect_timeout=300,
)
self.my_subnet_uid = self.metagraph.hotkeys.index(
self.wallet.hotkey.ss58_address
)
bt.logging.info(f"Running miner on uid: {self.my_subnet_uid}")
# Init wandb.
if not self.config.wandb.off:
bt.logging.debug("loading wandb")
init_wandb(self)
# The axon handles request processing, allowing validators to send this process requests.
self.axon = bt.axon(wallet=self.wallet, config=self.config)
bt.logging.info(f"Axon {self.axon}")
# Attach determiners which functions are called when servicing a request.
bt.logging.info(f"Attaching forward functions to axon.")
self.axon.attach(
forward_fn=self.store,
blacklist_fn=self.store_blacklist_fn,
priority_fn=self.store_priority_fn,
).attach(
forward_fn=self.challenge,
blacklist_fn=self.challenge_blacklist_fn,
priority_fn=self.challenge_priority_fn,
).attach(
forward_fn=self.retrieve,
blacklist_fn=self.retrieve_blacklist_fn,
priority_fn=self.retrieve_priority_fn,
)
# Serve passes the axon information to the network + netuid we are hosting on.
# This will auto-update if the axon port of external ip have changed.
bt.logging.info(
f"Serving axon {self.axon} on network: {self.subtensor.chain_endpoint} with netuid: {self.config.netuid}"
)
self.axon.serve(netuid=self.config.netuid, subtensor=self.subtensor)
# Start starts the miner's axon, making it active on the network.
bt.logging.info(f"Starting axon server on port: {self.config.axon.port}")
self.axon.start()
# Init the event loop.
self.loop = asyncio.get_event_loop()
# Instantiate runners
self.should_exit: bool = False
self.is_running: bool = False
self.thread: threading.Thread = None
self.lock = asyncio.Lock()
self.request_timestamps: Dict = {}
self.step = 0
# Init the miner's storage request tracker
self.request_count = 0
self.start_request_count_timer()
self.requests_per_hour = []
self.average_requests_per_hour = 0
# Init the miner's storage usage tracker
update_storage_stats(self)
def start_request_count_timer(self):
"""
Initializes and starts a timer for tracking the number of requests received by the miner in an hour.
This method sets up a one-hour timer that, upon expiration, calls the `reset_request_count` method to log
the number of requests received and reset the count for the next hour. The timer is set to run in a separate
thread to avoid blocking the main execution.
Usage:
Should be called during the initialization of the miner to start tracking requests per hour.
"""
self.request_count_timer = threading.Timer(3600, self.reset_request_count)
self.request_count_timer.start()
def reset_request_count(self):
"""
Logs the number of requests received in the last hour and resets the count.
This method is automatically called when the one-hour timer set by `start_request_count_timer` expires.
It logs the count of requests received in the last hour and then resets the count. Additionally, it
restarts the timer for the next hour.
Usage:
This method is intended to be called automatically by a timer and typically should not be called directly.
"""
bt.logging.info(
f"Number of requests received in the last hour: {self.request_count}"
)
self.requests_per_hour.append(self.request_count)
bt.logging.info(f"Requests per hour: {self.requests_per_hour}")
self.average_requests_per_hour = sum(self.requests_per_hour) / len(
self.requests_per_hour
)
bt.logging.info(f"Average requests per hour: {self.average_requests_per_hour}")
self.request_count = 0
self.start_request_count_timer()
@property
async def total_storage(self):
"""
Calculates the total size of data stored by the miner.
This method fetches all data keys from the Redis database and sums up the size of each data object.
It provides an estimate of the total amount of data currently held by the miner.
Returns:
int: Total size of data (in bytes) stored by the miner.
Example:
>>> miner.total_storage()
102400 # Example output indicating 102,400 bytes of data stored
"""
# Fetch all keys from Redis
all_keys = await safe_key_search(self.database, "*")
# Filter out keys that contain a period (temporary, remove later)
filtered_keys = [key for key in all_keys if b"." not in key]
# Get the size of each data object and sum them up
total_size = sum(
[
await get_chunk_metadata(self.database, key).get(b"size", 0)
for key in filtered_keys
]
)
return total_size
def store_blacklist_fn(
self, synapse: storage.protocol.Store
) -> typing.Tuple[bool, str]:
"""
Determines whether a given synapse should be blacklisted based on the recognition
of the hotkey in the metagraph. This function is used to filter out requests from
entities that are not part of the network's current state.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey.
Returns:
- (bool, str): A tuple where the first element is a boolean indicating whether the
synapse's hotkey is blacklisted, and the second element is a string message explaining
the reason.
If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and
the function returns (True, "Unrecognized hotkey"). Otherwise, it returns (False,
"Hotkey recognized!"), allowing the synapse to interact with the network.
Usage:
This method is internally used by the network to ensure that only recognized
entities can participate in communication or transactions.
"""
if synapse.dendrite.hotkey not in self.metagraph.hotkeys:
# Ignore requests from unrecognized entities.
bt.logging.trace(
f"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}"
)
return True, "Unrecognized hotkey"
bt.logging.trace(
f"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}"
)
return False, "Hotkey recognized!"
def store_priority_fn(self, synapse: storage.protocol.Store) -> float:
"""
Assigns a priority to a given synapse based on the stake of the calling entity
in the metagraph. This function is crucial for prioritizing network requests
and ensuring that higher-stake entities are given precedence in processing.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey of the caller.
Returns:
- float: The priority value assigned to the synapse, derived from the stake of
the calling hotkey in the metagraph.
The priority is determined by the stake associated with the caller's UID in the
metagraph. A higher stake results in a higher priority.
Usage:
This method is used within the network's request handling mechanism to allocate
resources and processing time based on the stake-based priority of each request.
"""
caller_uid = self.metagraph.hotkeys.index(
synapse.dendrite.hotkey
) # Get the caller index.
prirority = float(
self.metagraph.S[caller_uid]
) # Return the stake as the priority.
bt.logging.trace(
f"Prioritizing {synapse.dendrite.hotkey} with value: ", prirority
)
return prirority
def challenge_blacklist_fn(
self, synapse: storage.protocol.Challenge
) -> typing.Tuple[bool, str]:
"""
Determines whether a given synapse should be blacklisted based on the recognition
of the hotkey in the metagraph. This function is used to filter out requests from
entities that are not part of the network's current state.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey.
Returns:
- (bool, str): A tuple where the first element is a boolean indicating whether the
synapse's hotkey is blacklisted, and the second element is a string message explaining
the reason.
If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and
the function returns (True, "Unrecognized hotkey"). Otherwise, it returns (False,
"Hotkey recognized!"), allowing the synapse to interact with the network.
Usage:
This method is internally used by the network to ensure that only recognized
entities can participate in communication or transactions.
"""
if synapse.dendrite.hotkey not in self.metagraph.hotkeys:
# Ignore requests from unrecognized entities.
bt.logging.trace(
f"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}"
)
return True, "Unrecognized hotkey"
bt.logging.trace(
f"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}"
)
return False, "Hotkey recognized!"
def challenge_priority_fn(self, synapse: storage.protocol.Challenge) -> float:
"""
Assigns a priority to a given synapse based on the stake of the calling entity
in the metagraph. This function is crucial for prioritizing network requests
and ensuring that higher-stake entities are given precedence in processing.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey of the caller.
Returns:
- float: The priority value assigned to the synapse, derived from the stake of
the calling hotkey in the metagraph.
The priority is determined by the stake associated with the caller's UID in the
metagraph. A higher stake results in a higher priority.
Usage:
This method is used within the network's request handling mechanism to allocate
resources and processing time based on the stake-based priority of each request.
"""
caller_uid = self.metagraph.hotkeys.index(
synapse.dendrite.hotkey
) # Get the caller index.
prirority = float(
self.metagraph.S[caller_uid]
) # Return the stake as the priority.
bt.logging.trace(
f"Prioritizing {synapse.dendrite.hotkey} with value: ", prirority
)
return prirority
def retrieve_blacklist_fn(
self, synapse: storage.protocol.Retrieve
) -> typing.Tuple[bool, str]:
"""
Determines whether a given synapse should be blacklisted based on the recognition
of the hotkey in the metagraph. This function is used to filter out requests from
entities that are not part of the network's current state.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey.
Returns:
- (bool, str): A tuple where the first element is a boolean indicating whether the
synapse's hotkey is blacklisted, and the second element is a string message explaining
the reason.
If the hotkey is not recognized in the metagraph, the synapse is blacklisted, and
the function returns (True, "Unrecognized hotkey"). Otherwise, it returns (False,
"Hotkey recognized!"), allowing the synapse to interact with the network.
Usage:
This method is internally used by the network to ensure that only recognized
entities can participate in communication or transactions.
"""
if synapse.dendrite.hotkey not in self.metagraph.hotkeys:
# Ignore requests from unrecognized entities.
bt.logging.trace(
f"Blacklisting unrecognized hotkey {synapse.dendrite.hotkey}"
)
return True, "Unrecognized hotkey"
bt.logging.trace(
f"Not Blacklisting recognized hotkey {synapse.dendrite.hotkey}"
)
return False, "Hotkey recognized!"
def retrieve_priority_fn(self, synapse: storage.protocol.Retrieve) -> float:
"""
Assigns a priority to a given synapse based on the stake of the calling entity
in the metagraph. This function is crucial for prioritizing network requests
and ensuring that higher-stake entities are given precedence in processing.
Parameters:
- synapse (bt.Synapse): The synapse object which contains the dendrite information
including the hotkey of the caller.
Returns:
- float: The priority value assigned to the synapse, derived from the stake of
the calling hotkey in the metagraph.
The priority is determined by the stake associated with the caller's UID in the
metagraph. A higher stake results in a higher priority.
Usage:
This method is used within the network's request handling mechanism to allocate
resources and processing time based on the stake-based priority of each request.
"""
caller_uid = self.metagraph.hotkeys.index(
synapse.dendrite.hotkey
) # Get the caller index.
prirority = float(
self.metagraph.S[caller_uid]
) # Return the stake as the priority.
bt.logging.trace(
f"Prioritizing {synapse.dendrite.hotkey} with value: ", prirority
)
return prirority
async def store(self, synapse: storage.protocol.Store) -> storage.protocol.Store:
"""
Processes the storage request from a synapse by securely storing the provided data and returning
a proof of storage. The data is committed using elliptic curve cryptography, stored on the filesystem,
and the metadata is recorded in a Redis database. A cryptographic proof of the commitment, along with
a digital signature from the server's hotkey, is returned in the synapse for verification by the requester.
Args:
synapse (storage.protocol.Store): An object containing the data to be stored,
encoded in base64 format, along with associated metadata like the cryptographic
curve parameters, a seed for the commitment, and the expected commitment group elements.
Returns:
storage.protocol.Store: The synapse is returned with additional fields populated,
including the randomness used in the commitment, the commitment point itself, a signature
from this storage server's hotkey, and a commitment hash that can be used for chained proofs.
The method performs the following operations:
1. Decodes the base64-encoded data into raw bytes.
2. Commits to the data using the provided elliptic curve parameters and the seed to generate a commitment point.
3. Stores the raw byte data in the filesystem using a hash of the data as the filename.
4. Records metadata about the stored data in the Redis database, including the file path, previous seed, and data size.
5. Updates the synapse object with the commitment details and a digital signature.
This process ensures the integrity and non-repudiation of the data storage, allowing clients to verify
that their data has been stored correctly without the need to retrieve the full data set.
Example usage:
Assuming an initialized 'committer' object and 'synapse' with necessary data:
>>> updated_synapse = self.store(synapse)
"""
bt.logging.info(f"received store request: {synapse.encrypted_data[:24]}")
self.request_count += 1
# Decode the data from base64 to raw bytes
encrypted_byte_data = base64.b64decode(synapse.encrypted_data)
bt.logging.trace(f"store b64decrypted data: {encrypted_byte_data[:24]}")
# Store the data with the hash as the key in the filesystem
bt.logging.trace(f"entering hash_data()")
data_hash = hash_data(encrypted_byte_data)
# If already storing this hash, simply update the validator seeds and return challenge
bt.logging.trace(f"checking if data already exists...")
if await self.database.exists(data_hash):
# update the validator seed challenge hash in storage
await update_seed_info(
self.database, data_hash, synapse.dendrite.hotkey, synapse.seed
)
else:
# Store the data in the filesystem
filepath = save_data_to_filesystem(
encrypted_byte_data, self.config.database.directory, str(data_hash)
)
bt.logging.trace(f"stored data {data_hash} in filepath: {filepath}")
# Add the initial chunk, size, and validator seed information
await store_chunk_metadata(
self.database,
data_hash,
filepath,
synapse.dendrite.hotkey,
sys.getsizeof(encrypted_byte_data),
synapse.seed,
)
# Commit to the entire data block
bt.logging.trace(f"entering ECCommitment()")
committer = ECCommitment( | hex_to_ecc_point(synapse.g, synapse.curve), | 4 | 2023-10-26 18:54:47+00:00 | 24k |
cpacker/MemGPT | memgpt/main.py | [
{
"identifier": "logger",
"path": "memgpt/log.py",
"snippet": ""
},
{
"identifier": "CLIInterface",
"path": "memgpt/interface.py",
"snippet": "class CLIInterface(AgentInterface):\r\n \"\"\"Basic interface for dumping agent events to the command-line\"\"\"\r\n\r\n @staticmethod\r\n ... | import shutil
import configparser
import uuid
import logging
import glob
import os
import sys
import pickle
import traceback
import json
import questionary
import typer
import memgpt.agent as agent
import memgpt.system as system
import memgpt.constants as constants
import memgpt.errors as errors
from rich.console import Console
from prettytable import PrettyTable
from memgpt.log import logger
from memgpt.interface import CLIInterface as interface # for printing to terminal
from memgpt.config import MemGPTConfig
from memgpt.cli.cli import run, attach, version, server, open_folder, quickstart, migrate
from memgpt.cli.cli_config import configure, list, add, delete
from memgpt.cli.cli_load import app as load_app
from memgpt.agent_store.storage import StorageConnector, TableType
from memgpt.metadata import MetadataStore, save_agent
| 17,401 |
console = Console()
app = typer.Typer(pretty_exceptions_enable=False)
app.command(name="run")(run)
app.command(name="version")(version)
app.command(name="attach")(attach)
|
console = Console()
app = typer.Typer(pretty_exceptions_enable=False)
app.command(name="run")(run)
app.command(name="version")(version)
app.command(name="attach")(attach)
| app.command(name="configure")(configure)
| 10 | 2023-10-11 07:38:37+00:00 | 24k |
PixArt-alpha/PixArt-alpha | train_scripts/train_pixart_lcm.py | [
{
"identifier": "IDDPM",
"path": "diffusion/iddpm.py",
"snippet": "def IDDPM(\n timestep_respacing,\n noise_schedule=\"linear\",\n use_kl=False,\n sigma_small=False,\n predict_xstart=False,\n learn_sigma=True,\n pred_sigma=True,\n rescale_learned_s... | import os
import sys
import types
import argparse
import datetime
import time
import warnings
import torch
import torch.nn as nn
import numpy as np
import torch.nn.functional as F
from pathlib import Path
from accelerate import Accelerator, InitProcessGroupKwargs
from accelerate.utils import DistributedType
from diffusers.models import AutoencoderKL
from torch.utils.data import RandomSampler
from mmcv.runner import LogBuffer
from copy import deepcopy
from tqdm import tqdm
from diffusion import IDDPM
from diffusion.utils.checkpoint import save_checkpoint, load_checkpoint
from diffusion.utils.dist_utils import synchronize, get_world_size, clip_grad_norm_
from diffusion.data.builder import build_dataset, build_dataloader, set_data_root
from diffusion.model.builder import build_model
from diffusion.utils.logger import get_root_logger
from diffusion.utils.misc import set_random_seed, read_config, init_random_seed, DebugUnderflowOverflow
from diffusion.utils.optimizer import build_optimizer, auto_scale_lr
from diffusion.utils.lr_scheduler import build_lr_scheduler
from diffusion.utils.data_sampler import AspectRatioBatchSampler, BalancedAspectRatioBatchSampler
from diffusion.lcm_scheduler import LCMScheduler
from torchvision.utils import save_image
from accelerate import FullyShardedDataParallelPlugin
from torch.distributed.fsdp.fully_sharded_data_parallel import FullStateDictConfig | 16,418 | )
synchronize()
def parse_args():
parser = argparse.ArgumentParser(description="Process some integers.")
parser.add_argument("config", type=str, help="config")
parser.add_argument("--cloud", action='store_true', default=False, help="cloud or local machine")
parser.add_argument('--work-dir', help='the dir to save logs and models')
parser.add_argument('--resume-from', help='the dir to resume the training')
parser.add_argument('--load-from', default=None, help='the dir to load a ckpt for training')
parser.add_argument('--local-rank', type=int, default=-1)
parser.add_argument('--local_rank', type=int, default=-1)
parser.add_argument('--debug', action='store_true')
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
config = read_config(args.config)
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
config.work_dir = args.work_dir
if args.cloud:
config.data_root = '/data/data'
if args.resume_from is not None:
config.load_from = None
config.resume_from = dict(
checkpoint=args.resume_from,
load_ema=False,
resume_optimizer=True,
resume_lr_scheduler=True)
if args.debug:
config.log_interval = 1
config.train_batch_size = 11
config.valid_num = 100
config.load_from = None
os.umask(0o000)
os.makedirs(config.work_dir, exist_ok=True)
init_handler = InitProcessGroupKwargs()
init_handler.timeout = datetime.timedelta(seconds=5400) # change timeout to avoid a strange NCCL bug
# Initialize accelerator and tensorboard logging
if config.use_fsdp:
init_train = 'FSDP'
set_fsdp_env()
fsdp_plugin = FullyShardedDataParallelPlugin(state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),)
else:
init_train = 'DDP'
fsdp_plugin = None
even_batches = True
if config.multi_scale:
even_batches=False,
accelerator = Accelerator(
mixed_precision=config.mixed_precision,
gradient_accumulation_steps=config.gradient_accumulation_steps,
log_with="tensorboard",
project_dir=os.path.join(config.work_dir, "logs"),
fsdp_plugin=fsdp_plugin,
even_batches=even_batches,
kwargs_handlers=[init_handler]
)
logger = get_root_logger(os.path.join(config.work_dir, 'train_log.log'))
config.seed = init_random_seed(config.get('seed', None))
set_random_seed(config.seed)
if accelerator.is_main_process:
config.dump(os.path.join(config.work_dir, 'config.py'))
logger.info(f"Config: \n{config.pretty_text}")
logger.info(f"World_size: {get_world_size()}, seed: {config.seed}")
logger.info(f"Initializing: {init_train} for training")
image_size = config.image_size # @param [256, 512]
latent_size = int(image_size) // 8
pred_sigma = getattr(config, 'pred_sigma', True)
learn_sigma = getattr(config, 'learn_sigma', True) and pred_sigma
model_kwargs={"window_block_indexes": config.window_block_indexes, "window_size": config.window_size,
"use_rel_pos": config.use_rel_pos, "lewei_scale": config.lewei_scale, 'config':config,
'model_max_length': config.model_max_length}
# build models
train_diffusion = IDDPM(str(config.train_sampling_steps), learn_sigma=learn_sigma, pred_sigma=pred_sigma,
snr=config.snr_loss, return_startx=True)
model = build_model(config.model,
config.grad_checkpointing,
config.get('fp32_attention', False),
input_size=latent_size,
learn_sigma=learn_sigma,
pred_sigma=pred_sigma,
**model_kwargs).train()
logger.info(f"{model.__class__.__name__} Model Parameters: {sum(p.numel() for p in model.parameters()):,}")
if config.load_from is not None:
if args.load_from is not None:
config.load_from = args.load_from
missing, unexpected = load_checkpoint(config.load_from, model, load_ema=config.get('load_ema', False))
logger.warning(f'Missing keys: {missing}')
logger.warning(f'Unexpected keys: {unexpected}')
model_ema = deepcopy(model).eval()
model_teacher = deepcopy(model).eval()
if not config.data.load_vae_feat:
vae = AutoencoderKL.from_pretrained(config.vae_pretrained).cuda()
# prepare for FSDP clip grad norm calculation
if accelerator.distributed_type == DistributedType.FSDP:
for m in accelerator._models:
m.clip_grad_norm_ = types.MethodType(clip_grad_norm_, m)
# build dataloader
set_data_root(config.data_root)
dataset = build_dataset(config.data, resolution=image_size, aspect_ratio_type=config.aspect_ratio_type)
if config.multi_scale:
| current_file_path = Path(__file__).resolve()
sys.path.insert(0, str(current_file_path.parent.parent))
warnings.filterwarnings("ignore") # ignore warning
def set_fsdp_env():
os.environ["ACCELERATE_USE_FSDP"] = 'true'
os.environ["FSDP_AUTO_WRAP_POLICY"] = 'TRANSFORMER_BASED_WRAP'
os.environ["FSDP_BACKWARD_PREFETCH"] = 'BACKWARD_PRE'
os.environ["FSDP_TRANSFORMER_CLS_TO_WRAP"] = 'PixArtBlock'
def ema_update(model_dest: nn.Module, model_src: nn.Module, rate):
param_dict_src = dict(model_src.named_parameters())
for p_name, p_dest in model_dest.named_parameters():
p_src = param_dict_src[p_name]
assert p_src is not p_dest
p_dest.data.mul_(rate).add_((1 - rate) * p_src.data)
def append_dims(x, target_dims):
"""Appends dimensions to the end of a tensor until it has target_dims dimensions."""
dims_to_append = target_dims - x.ndim
if dims_to_append < 0:
raise ValueError(f"input has {x.ndim} dims but target_dims is {target_dims}, which is less")
return x[(...,) + (None,) * dims_to_append]
# From LCMScheduler.get_scalings_for_boundary_condition_discrete
def scalings_for_boundary_conditions(timestep, sigma_data=0.5, timestep_scaling=10.0):
c_skip = sigma_data**2 / ((timestep / 0.1) ** 2 + sigma_data**2)
c_out = (timestep / 0.1) / ((timestep / 0.1) ** 2 + sigma_data**2) ** 0.5
return c_skip, c_out
def extract_into_tensor(a, t, x_shape):
b, *_ = t.shape
out = a.gather(-1, t)
return out.reshape(b, *((1,) * (len(x_shape) - 1)))
class DDIMSolver:
def __init__(self, alpha_cumprods, timesteps=1000, ddim_timesteps=50):
# DDIM sampling parameters
step_ratio = timesteps // ddim_timesteps
self.ddim_timesteps = (np.arange(1, ddim_timesteps + 1) * step_ratio).round().astype(np.int64) - 1
self.ddim_alpha_cumprods = alpha_cumprods[self.ddim_timesteps]
self.ddim_alpha_cumprods_prev = np.asarray(
[alpha_cumprods[0]] + alpha_cumprods[self.ddim_timesteps[:-1]].tolist()
)
# convert to torch tensors
self.ddim_timesteps = torch.from_numpy(self.ddim_timesteps).long()
self.ddim_alpha_cumprods = torch.from_numpy(self.ddim_alpha_cumprods)
self.ddim_alpha_cumprods_prev = torch.from_numpy(self.ddim_alpha_cumprods_prev)
def to(self, device):
self.ddim_timesteps = self.ddim_timesteps.to(device)
self.ddim_alpha_cumprods = self.ddim_alpha_cumprods.to(device)
self.ddim_alpha_cumprods_prev = self.ddim_alpha_cumprods_prev.to(device)
return self
def ddim_step(self, pred_x0, pred_noise, timestep_index):
alpha_cumprod_prev = extract_into_tensor(self.ddim_alpha_cumprods_prev, timestep_index, pred_x0.shape)
dir_xt = (1.0 - alpha_cumprod_prev).sqrt() * pred_noise
x_prev = alpha_cumprod_prev.sqrt() * pred_x0 + dir_xt
return x_prev
@torch.no_grad()
def log_validation(model, step, device):
if hasattr(model, 'module'):
model = model.module
scheduler = LCMScheduler(beta_start=0.0001, beta_end=0.02, beta_schedule="linear", prediction_type="epsilon")
scheduler.set_timesteps(4, 50)
infer_timesteps = scheduler.timesteps
dog_embed = torch.load('data/tmp/dog.pth', map_location='cpu')
caption_embs, emb_masks = dog_embed['dog_text'].to(device), dog_embed['dog_mask'].to(device)
hw = torch.tensor([[1024, 1024]], dtype=torch.float, device=device).repeat(1, 1)
ar = torch.tensor([[1.]], device=device).repeat(1, 1)
# Create sampling noise:
infer_latents = torch.randn(1, 4, 1024, 1024, device=device)
model_kwargs = dict(data_info={'img_hw': hw, 'aspect_ratio': ar}, mask=emb_masks)
logger.info("Running validation... ")
# 7. LCM MultiStep Sampling Loop:
for i, t in tqdm(list(enumerate(infer_timesteps))):
ts = torch.full((1,), t, device=device, dtype=torch.long)
# model prediction (v-prediction, eps, x)
model_pred = model(infer_latents, ts, caption_embs, **model_kwargs)[:, :4]
# compute the previous noisy sample x_t -> x_t-1
infer_latents, denoised = scheduler.step(model_pred, i, t, infer_latents, return_dict=False)
samples = vae.decode(denoised / 0.18215).sample
torch.cuda.empty_cache()
save_image(samples[0], f'output_cv/vis/{step}.jpg', nrow=1, normalize=True, value_range=(-1, 1))
def train():
if config.get('debug_nan', False):
DebugUnderflowOverflow(model)
logger.info('NaN debugger registered. Start to detect overflow during training.')
time_start, last_tic = time.time(), time.time()
log_buffer = LogBuffer()
start_step = start_epoch * len(train_dataloader)
global_step = 0
total_steps = len(train_dataloader) * config.num_epochs
load_vae_feat = getattr(train_dataloader.dataset, 'load_vae_feat', False)
# Create uncond embeds for classifier free guidance
uncond_prompt_embeds = model.module.y_embedder.y_embedding.repeat(config.train_batch_size, 1, 1, 1)
# Now you train the model
for epoch in range(start_epoch + 1, config.num_epochs + 1):
data_time_start= time.time()
data_time_all = 0
for step, batch in enumerate(train_dataloader):
data_time_all += time.time() - data_time_start
if load_vae_feat:
z = batch[0]
else:
with torch.no_grad():
with torch.cuda.amp.autocast(enabled=config.mixed_precision == 'fp16'):
posterior = vae.encode(batch[0]).latent_dist
if config.sample_posterior:
z = posterior.sample()
else:
z = posterior.mode()
latents = z * config.scale_factor
y = batch[1]
y_mask = batch[2]
data_info = batch[3]
# Sample a random timestep for each image
grad_norm = None
with accelerator.accumulate(model):
# Predict the noise residual
optimizer.zero_grad()
# Sample noise that we'll add to the latents
noise = torch.randn_like(latents)
bsz = latents.shape[0]
# Sample a random timestep for each image t_n ~ U[0, N - k - 1] without bias.
topk = config.train_sampling_steps // config.num_ddim_timesteps
index = torch.randint(0, config.num_ddim_timesteps, (bsz,), device=latents.device).long()
start_timesteps = solver.ddim_timesteps[index]
timesteps = start_timesteps - topk
timesteps = torch.where(timesteps < 0, torch.zeros_like(timesteps), timesteps)
# Get boundary scalings for start_timesteps and (end) timesteps.
c_skip_start, c_out_start = scalings_for_boundary_conditions(start_timesteps)
c_skip_start, c_out_start = [append_dims(x, latents.ndim) for x in [c_skip_start, c_out_start]]
c_skip, c_out = scalings_for_boundary_conditions(timesteps)
c_skip, c_out = [append_dims(x, latents.ndim) for x in [c_skip, c_out]]
# Sample a random guidance scale w from U[w_min, w_max] and embed it
# w = (config.w_max - config.w_min) * torch.rand((bsz,)) + config.w_min
w = config.cfg_scale * torch.ones((bsz,))
w = w.reshape(bsz, 1, 1, 1)
w = w.to(device=latents.device, dtype=latents.dtype)
# Get online LCM prediction on z_{t_{n + k}}, w, c, t_{n + k}
_, pred_x_0, noisy_model_input = train_diffusion.training_losses(model, latents, start_timesteps, model_kwargs=dict(y=y, mask=y_mask, data_info=data_info), noise=noise)
model_pred = c_skip_start * noisy_model_input + c_out_start * pred_x_0
# Use the ODE solver to predict the kth step in the augmented PF-ODE trajectory after
# noisy_latents with both the conditioning embedding c and unconditional embedding 0
# Get teacher model prediction on noisy_latents and conditional embedding
with torch.no_grad():
with torch.autocast("cuda"):
cond_teacher_output, cond_pred_x0, _ = train_diffusion.training_losses(model_teacher, latents, start_timesteps, model_kwargs=dict(y=y, mask=y_mask, data_info=data_info), noise=noise)
# Get teacher model prediction on noisy_latents and unconditional embedding
uncond_teacher_output, uncond_pred_x0, _ = train_diffusion.training_losses(model_teacher, latents, start_timesteps, model_kwargs=dict(y=uncond_prompt_embeds, mask=y_mask, data_info=data_info), noise=noise)
# Perform "CFG" to get x_prev estimate (using the LCM paper's CFG formulation)
pred_x0 = cond_pred_x0 + w * (cond_pred_x0 - uncond_pred_x0)
pred_noise = cond_teacher_output + w * (cond_teacher_output - uncond_teacher_output)
x_prev = solver.ddim_step(pred_x0, pred_noise, index)
# Get target LCM prediction on x_prev, w, c, t_n
with torch.no_grad():
with torch.autocast("cuda", enabled=True):
_, pred_x_0, _ = train_diffusion.training_losses(model_ema, x_prev.float(), timesteps, model_kwargs=dict(y=y, mask=y_mask, data_info=data_info), skip_noise=True)
target = c_skip * x_prev + c_out * pred_x_0
# Calculate loss
if config.loss_type == "l2":
loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean")
elif config.loss_type == "huber":
loss = torch.mean(torch.sqrt((model_pred.float() - target.float()) ** 2 + config.huber_c**2) - config.huber_c)
# Backpropagation on the online student model (`model`)
accelerator.backward(loss)
if accelerator.sync_gradients:
grad_norm = accelerator.clip_grad_norm_(model.parameters(), config.gradient_clip)
optimizer.step()
lr_scheduler.step()
optimizer.zero_grad(set_to_none=True)
if accelerator.sync_gradients:
ema_update(model_ema, model, config.ema_decay)
lr = lr_scheduler.get_last_lr()[0]
logs = {"loss": accelerator.gather(loss).mean().item()}
if grad_norm is not None:
logs.update(grad_norm=accelerator.gather(grad_norm).mean().item())
log_buffer.update(logs)
if (step + 1) % config.log_interval == 0 or (step + 1) == 1:
t = (time.time() - last_tic) / config.log_interval
t_d = data_time_all / config.log_interval
avg_time = (time.time() - time_start) / (global_step + 1)
eta = str(datetime.timedelta(seconds=int(avg_time * (total_steps - start_step - global_step - 1))))
eta_epoch = str(datetime.timedelta(seconds=int(avg_time * (len(train_dataloader) - step - 1))))
# avg_loss = sum(loss_buffer) / len(loss_buffer)
log_buffer.average()
info = f"Step/Epoch [{(epoch-1)*len(train_dataloader)+step+1}/{epoch}][{step + 1}/{len(train_dataloader)}]:total_eta: {eta}, " \
f"epoch_eta:{eta_epoch}, time_all:{t:.3f}, time_data:{t_d:.3f}, lr:{lr:.3e}, s:({data_info['resolution'][0][0].item()}, {data_info['resolution'][0][1].item()}), "
info += ', '.join([f"{k}:{v:.4f}" for k, v in log_buffer.output.items()])
logger.info(info)
last_tic = time.time()
log_buffer.clear()
data_time_all = 0
logs.update(lr=lr)
accelerator.log(logs, step=global_step + start_step)
global_step += 1
data_time_start= time.time()
synchronize()
torch.cuda.empty_cache()
if accelerator.is_main_process:
# log_validation(model_ema, step, model.device)
if ((epoch - 1) * len(train_dataloader) + step + 1) % config.save_model_steps == 0:
os.umask(0o000)
save_checkpoint(os.path.join(config.work_dir, 'checkpoints'),
epoch=epoch,
step=(epoch - 1) * len(train_dataloader) + step + 1,
model=accelerator.unwrap_model(model),
model_ema=accelerator.unwrap_model(model_ema),
optimizer=optimizer,
lr_scheduler=lr_scheduler
)
synchronize()
synchronize()
if accelerator.is_main_process:
if epoch % config.save_model_epochs == 0 or epoch == config.num_epochs:
os.umask(0o000)
save_checkpoint(os.path.join(config.work_dir, 'checkpoints'),
epoch=epoch,
step=(epoch - 1) * len(train_dataloader) + step + 1,
model=accelerator.unwrap_model(model),
model_ema=accelerator.unwrap_model(model_ema),
optimizer=optimizer,
lr_scheduler=lr_scheduler
)
synchronize()
def parse_args():
parser = argparse.ArgumentParser(description="Process some integers.")
parser.add_argument("config", type=str, help="config")
parser.add_argument("--cloud", action='store_true', default=False, help="cloud or local machine")
parser.add_argument('--work-dir', help='the dir to save logs and models')
parser.add_argument('--resume-from', help='the dir to resume the training')
parser.add_argument('--load-from', default=None, help='the dir to load a ckpt for training')
parser.add_argument('--local-rank', type=int, default=-1)
parser.add_argument('--local_rank', type=int, default=-1)
parser.add_argument('--debug', action='store_true')
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
config = read_config(args.config)
if args.work_dir is not None:
# update configs according to CLI args if args.work_dir is not None
config.work_dir = args.work_dir
if args.cloud:
config.data_root = '/data/data'
if args.resume_from is not None:
config.load_from = None
config.resume_from = dict(
checkpoint=args.resume_from,
load_ema=False,
resume_optimizer=True,
resume_lr_scheduler=True)
if args.debug:
config.log_interval = 1
config.train_batch_size = 11
config.valid_num = 100
config.load_from = None
os.umask(0o000)
os.makedirs(config.work_dir, exist_ok=True)
init_handler = InitProcessGroupKwargs()
init_handler.timeout = datetime.timedelta(seconds=5400) # change timeout to avoid a strange NCCL bug
# Initialize accelerator and tensorboard logging
if config.use_fsdp:
init_train = 'FSDP'
set_fsdp_env()
fsdp_plugin = FullyShardedDataParallelPlugin(state_dict_config=FullStateDictConfig(offload_to_cpu=False, rank0_only=False),)
else:
init_train = 'DDP'
fsdp_plugin = None
even_batches = True
if config.multi_scale:
even_batches=False,
accelerator = Accelerator(
mixed_precision=config.mixed_precision,
gradient_accumulation_steps=config.gradient_accumulation_steps,
log_with="tensorboard",
project_dir=os.path.join(config.work_dir, "logs"),
fsdp_plugin=fsdp_plugin,
even_batches=even_batches,
kwargs_handlers=[init_handler]
)
logger = get_root_logger(os.path.join(config.work_dir, 'train_log.log'))
config.seed = init_random_seed(config.get('seed', None))
set_random_seed(config.seed)
if accelerator.is_main_process:
config.dump(os.path.join(config.work_dir, 'config.py'))
logger.info(f"Config: \n{config.pretty_text}")
logger.info(f"World_size: {get_world_size()}, seed: {config.seed}")
logger.info(f"Initializing: {init_train} for training")
image_size = config.image_size # @param [256, 512]
latent_size = int(image_size) // 8
pred_sigma = getattr(config, 'pred_sigma', True)
learn_sigma = getattr(config, 'learn_sigma', True) and pred_sigma
model_kwargs={"window_block_indexes": config.window_block_indexes, "window_size": config.window_size,
"use_rel_pos": config.use_rel_pos, "lewei_scale": config.lewei_scale, 'config':config,
'model_max_length': config.model_max_length}
# build models
train_diffusion = IDDPM(str(config.train_sampling_steps), learn_sigma=learn_sigma, pred_sigma=pred_sigma,
snr=config.snr_loss, return_startx=True)
model = build_model(config.model,
config.grad_checkpointing,
config.get('fp32_attention', False),
input_size=latent_size,
learn_sigma=learn_sigma,
pred_sigma=pred_sigma,
**model_kwargs).train()
logger.info(f"{model.__class__.__name__} Model Parameters: {sum(p.numel() for p in model.parameters()):,}")
if config.load_from is not None:
if args.load_from is not None:
config.load_from = args.load_from
missing, unexpected = load_checkpoint(config.load_from, model, load_ema=config.get('load_ema', False))
logger.warning(f'Missing keys: {missing}')
logger.warning(f'Unexpected keys: {unexpected}')
model_ema = deepcopy(model).eval()
model_teacher = deepcopy(model).eval()
if not config.data.load_vae_feat:
vae = AutoencoderKL.from_pretrained(config.vae_pretrained).cuda()
# prepare for FSDP clip grad norm calculation
if accelerator.distributed_type == DistributedType.FSDP:
for m in accelerator._models:
m.clip_grad_norm_ = types.MethodType(clip_grad_norm_, m)
# build dataloader
set_data_root(config.data_root)
dataset = build_dataset(config.data, resolution=image_size, aspect_ratio_type=config.aspect_ratio_type)
if config.multi_scale: | batch_sampler = AspectRatioBatchSampler(sampler=RandomSampler(dataset), dataset=dataset, | 18 | 2023-10-12 14:16:33+00:00 | 24k |
NVlabs/EmerNeRF | train_emernerf.py | [
{
"identifier": "metrics",
"path": "datasets/metrics.py",
"snippet": "def compute_valid_depth_rmse(prediction: Tensor, target: Tensor) -> float:\ndef compute_psnr(prediction: Tensor, target: Tensor) -> float:\ndef compute_ssim(\n prediction: Union[Tensor, np.ndarray], target: Union[Tensor, np.ndarray... | import argparse
import json
import logging
import os
import time
import imageio
import numpy as np
import torch
import torch.utils.data
import builders
import loss
import utils.misc as misc
import wandb
from typing import List, Optional
from omegaconf import OmegaConf
from tqdm import tqdm
from datasets import metrics
from datasets.base import SceneDataset
from radiance_fields import DensityField, RadianceField
from radiance_fields.render_utils import render_rays
from radiance_fields.video_utils import render_pixels, save_videos
from third_party.nerfacc_prop_net import PropNetEstimator, get_proposal_requires_grad_fn
from utils.logging import MetricLogger, setup_logging
from utils.visualization_tools import visualize_voxels, visualize_scene_flow
from datasets.waymo import WaymoDataset
from datasets.nuscenes import NuScenesDataset | 19,797 | )
parser.add_argument(
"--render_data_video_only",
action="store_true",
help="Quit after rendering a data video",
)
parser.add_argument(
"--render_video_postfix",
type=str,
default=None,
help="an optional postfix for video",
)
parser.add_argument(
"--output_root",
default="./work_dirs/",
help="path to save checkpoints and logs",
type=str,
)
# wandb logging part
parser.add_argument(
"--enable_wandb", action="store_true", help="enable wandb logging"
)
parser.add_argument(
"--entity",
default="YOUR ENTITY NAME",
type=str,
help="wandb entity name",
required=False,
)
parser.add_argument(
"--project",
default="emernerf",
type=str,
help="wandb project name, also used to enhance log_dir",
required=True,
)
parser.add_argument(
"--run_name",
default="debug",
type=str,
help="wandb run name, also used to enhance log_dir",
required=True,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
return parser
def setup(args):
# ------ get config from args -------- #
default_config = OmegaConf.create(OmegaConf.load("configs/default_config.yaml"))
cfg = OmegaConf.load(args.config_file)
cfg = OmegaConf.merge(default_config, cfg, OmegaConf.from_cli(args.opts))
log_dir = os.path.join(args.output_root, args.project, args.run_name)
cfg.log_dir = log_dir
cfg.nerf.model.num_cams = cfg.data.pixel_source.num_cams
cfg.nerf.model.unbounded = cfg.nerf.unbounded
cfg.nerf.propnet.unbounded = cfg.nerf.unbounded
cfg.nerf.model.resume_from = cfg.resume_from
os.makedirs(log_dir, exist_ok=True)
for folder in [
"images",
"full_videos",
"test_videos",
"lowres_videos",
"metrics",
"configs_bk",
"buffer_maps",
]:
os.makedirs(os.path.join(log_dir, folder), exist_ok=True)
# ------ setup logging -------- #
if args.enable_wandb:
# sometimes wandb fails to init in cloud machines, so we give it several (many) tries
while (
wandb.init(
project=args.project,
entity=args.entity,
sync_tensorboard=True,
settings=wandb.Settings(start_method="fork"),
)
is not wandb.run
):
continue
wandb.run.name = args.run_name
wandb.run.save()
wandb.config.update(OmegaConf.to_container(cfg, resolve=True))
wandb.config.update(args)
misc.fix_random_seeds(cfg.optim.seed)
global logger
setup_logging(output=log_dir, level=logging.INFO, time_string=current_time)
logger.info(
"\n".join("%s: %s" % (k, str(v)) for k, v in sorted(dict(vars(args)).items()))
)
# -------- write config -------- #
logger.info(f"Config:\n{OmegaConf.to_yaml(cfg)}")
saved_cfg_path = os.path.join(log_dir, "config.yaml")
with open(saved_cfg_path, "w") as f:
OmegaConf.save(config=cfg, f=f)
# also save a backup copy
saved_cfg_path_bk = os.path.join(
log_dir, "configs_bk", f"config_{current_time}.yaml"
)
with open(saved_cfg_path_bk, "w") as f:
OmegaConf.save(config=cfg, f=f)
logger.info(f"Full config saved to {saved_cfg_path}, and {saved_cfg_path_bk}")
return cfg
@torch.no_grad()
def do_evaluation(
step: int = 0,
cfg: OmegaConf = None,
model: RadianceField = None,
proposal_networks: Optional[List[DensityField]] = None,
|
logger = logging.getLogger()
current_time = time.strftime("%Y-%m-%d_%H-%M-%S", time.localtime())
# a global list of keys to render,
# comment out the keys you don't want to render or uncomment the keys you want to render
render_keys = [
"gt_rgbs",
"rgbs",
"depths",
# "median_depths",
"gt_dino_feats",
"dino_feats",
"dynamic_rgbs",
"dynamic_depths",
"static_rgbs",
"static_depths",
"forward_flows",
"backward_flows",
"dynamic_rgb_on_static_dinos",
"dino_pe",
"dino_feats_pe_free",
# "dynamic_dino_on_static_rgbs",
# "shadow_reduced_static_rgbs",
# "shadow_only_static_rgbs",
# "shadows",
# "gt_sky_masks",
# "sky_masks",
]
def get_args_parser():
parser = argparse.ArgumentParser("Train EmernNerf for a single scene")
parser.add_argument("--config_file", help="path to config file", type=str)
parser.add_argument(
"--eval_only", action="store_true", help="perform evaluation only"
)
parser.add_argument(
"--visualize_voxel", action="store_true", help="perform evaluation only"
)
parser.add_argument(
"--render_data_video",
action="store_true",
help="Render a data video",
)
parser.add_argument(
"--render_data_video_only",
action="store_true",
help="Quit after rendering a data video",
)
parser.add_argument(
"--render_video_postfix",
type=str,
default=None,
help="an optional postfix for video",
)
parser.add_argument(
"--output_root",
default="./work_dirs/",
help="path to save checkpoints and logs",
type=str,
)
# wandb logging part
parser.add_argument(
"--enable_wandb", action="store_true", help="enable wandb logging"
)
parser.add_argument(
"--entity",
default="YOUR ENTITY NAME",
type=str,
help="wandb entity name",
required=False,
)
parser.add_argument(
"--project",
default="emernerf",
type=str,
help="wandb project name, also used to enhance log_dir",
required=True,
)
parser.add_argument(
"--run_name",
default="debug",
type=str,
help="wandb run name, also used to enhance log_dir",
required=True,
)
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
return parser
def setup(args):
# ------ get config from args -------- #
default_config = OmegaConf.create(OmegaConf.load("configs/default_config.yaml"))
cfg = OmegaConf.load(args.config_file)
cfg = OmegaConf.merge(default_config, cfg, OmegaConf.from_cli(args.opts))
log_dir = os.path.join(args.output_root, args.project, args.run_name)
cfg.log_dir = log_dir
cfg.nerf.model.num_cams = cfg.data.pixel_source.num_cams
cfg.nerf.model.unbounded = cfg.nerf.unbounded
cfg.nerf.propnet.unbounded = cfg.nerf.unbounded
cfg.nerf.model.resume_from = cfg.resume_from
os.makedirs(log_dir, exist_ok=True)
for folder in [
"images",
"full_videos",
"test_videos",
"lowres_videos",
"metrics",
"configs_bk",
"buffer_maps",
]:
os.makedirs(os.path.join(log_dir, folder), exist_ok=True)
# ------ setup logging -------- #
if args.enable_wandb:
# sometimes wandb fails to init in cloud machines, so we give it several (many) tries
while (
wandb.init(
project=args.project,
entity=args.entity,
sync_tensorboard=True,
settings=wandb.Settings(start_method="fork"),
)
is not wandb.run
):
continue
wandb.run.name = args.run_name
wandb.run.save()
wandb.config.update(OmegaConf.to_container(cfg, resolve=True))
wandb.config.update(args)
misc.fix_random_seeds(cfg.optim.seed)
global logger
setup_logging(output=log_dir, level=logging.INFO, time_string=current_time)
logger.info(
"\n".join("%s: %s" % (k, str(v)) for k, v in sorted(dict(vars(args)).items()))
)
# -------- write config -------- #
logger.info(f"Config:\n{OmegaConf.to_yaml(cfg)}")
saved_cfg_path = os.path.join(log_dir, "config.yaml")
with open(saved_cfg_path, "w") as f:
OmegaConf.save(config=cfg, f=f)
# also save a backup copy
saved_cfg_path_bk = os.path.join(
log_dir, "configs_bk", f"config_{current_time}.yaml"
)
with open(saved_cfg_path_bk, "w") as f:
OmegaConf.save(config=cfg, f=f)
logger.info(f"Full config saved to {saved_cfg_path}, and {saved_cfg_path_bk}")
return cfg
@torch.no_grad()
def do_evaluation(
step: int = 0,
cfg: OmegaConf = None,
model: RadianceField = None,
proposal_networks: Optional[List[DensityField]] = None, | proposal_estimator: PropNetEstimator = None, | 7 | 2023-10-11 20:56:27+00:00 | 24k |
Subsets and Splits
SQL Console for tianyang/repobench_python_v1.1
Identifies repositories that have consistent code formatting levels across multiple scales (2k, 4k, 8k, 12k) and reveals the structured formatting patterns within these repositories.
SQL Console for tianyang/repobench_python_v1.1
Compares cross-file and in-file code structure patterns across different complexity levels, revealing how file organization strategies vary with code size and potentially informing better code architecture decisions.
SQL Console for tianyang/repobench_python_v1.1
Identifies repositories that have complete performance data across all seven code complexity levels, revealing consistent benchmarking patterns across different code sizes.
SQL Console for tianyang/repobench_python_v1.1
Identifies repositories that contain all 7 distinct quality levels (2k through 32k), revealing complete datasets that might be useful for comprehensive analysis.